Added Saturation to FMUL32I

web_service/CMakeLists: Make the CPPHTTPLIB_OPENSSL_SUPPORT constrained to the web_service library only

src/core/CMakeLists.txt

@@ -156,6 +156,8 @@ add_library(core STATIC
     hle/service/am/omm.h
     hle/service/am/spsm.cpp
     hle/service/am/spsm.h
+    hle/service/am/tcap.cpp
+    hle/service/am/tcap.h
     hle/service/aoc/aoc_u.cpp
     hle/service/aoc/aoc_u.h
     hle/service/apm/apm.cpp
@@ -280,6 +282,8 @@ add_library(core STATIC
     hle/service/nifm/nifm.h
     hle/service/nim/nim.cpp
     hle/service/nim/nim.h
+    hle/service/npns/npns.cpp
+    hle/service/npns/npns.h
     hle/service/ns/ns.cpp
     hle/service/ns/ns.h
     hle/service/ns/pl_u.cpp

src/core/crypto/partition_data_manager.cpp

@@ -516,7 +516,8 @@ void PartitionDataManager::DecryptPackage2(const std::array<Key128, 0x20>& packa
         out.insert(out.end(), rodata.begin(), rodata.end());
         out.insert(out.end(), data.begin(), data.end());
 
-        offset += sizeof(KIPHeader) + out.size();
+        offset += sizeof(KIPHeader) + kip.sections[0].size_compressed +
+                  kip.sections[1].size_compressed + kip.sections[2].size_compressed;
 
         if (name == "FS")
             package2_fs[static_cast<size_t>(type)] = std::move(out);

src/core/file_sys/card_image.cpp

@@ -168,6 +168,10 @@ VirtualDir XCI::GetParentDirectory() const {
     return file->GetContainingDirectory();
 }
 
+bool XCI::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    return false;
+}
+
 Loader::ResultStatus XCI::AddNCAFromPartition(XCIPartition part) {
     if (partitions[static_cast<std::size_t>(part)] == nullptr) {
         return Loader::ResultStatus::ErrorXCIMissingPartition;

src/core/file_sys/card_image.h

@@ -94,6 +94,9 @@ public:
 
     VirtualDir GetParentDirectory() const override;
 
+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
 private:
     Loader::ResultStatus AddNCAFromPartition(XCIPartition part);
 

src/core/file_sys/content_archive.cpp

@@ -546,4 +546,7 @@ u64 NCA::GetBaseIVFCOffset() const {
     return ivfc_offset;
 }
 
+bool NCA::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    return false;
+}
 } // namespace FileSys

src/core/file_sys/content_archive.h

@@ -100,6 +100,9 @@ public:
     // Returns the base ivfc offset used in BKTR patching.
     u64 GetBaseIVFCOffset() const;
 
+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
 private:
     bool CheckSupportedNCA(const NCAHeader& header);
     bool HandlePotentialHeaderDecryption();

src/core/file_sys/partition_filesystem.cpp

@@ -83,7 +83,7 @@ std::vector<std::shared_ptr<VfsFile>> PartitionFilesystem::GetFiles() const {
 }
 
 std::vector<std::shared_ptr<VfsDirectory>> PartitionFilesystem::GetSubdirectories() const {
-    return {};
+    return pfs_dirs;
 }
 
 std::string PartitionFilesystem::GetName() const {
@@ -103,4 +103,18 @@ void PartitionFilesystem::PrintDebugInfo() const {
                   pfs_files[i]->GetName(), pfs_files[i]->GetSize());
     }
 }
+
+bool PartitionFilesystem::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    const auto iter = std::find(pfs_files.begin(), pfs_files.end(), file);
+    if (iter == pfs_files.end())
+        return false;
+
+    const std::ptrdiff_t offset = std::distance(pfs_files.begin(), iter);
+    pfs_files[offset] = std::move(pfs_files.back());
+    pfs_files.pop_back();
+
+    pfs_dirs.emplace_back(std::move(dir));
+
+    return true;
+}
 } // namespace FileSys

src/core/file_sys/partition_filesystem.h

@@ -35,6 +35,9 @@ public:
     std::shared_ptr<VfsDirectory> GetParentDirectory() const override;
     void PrintDebugInfo() const;
 
+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
 private:
     struct Header {
         u32_le magic;
@@ -81,6 +84,7 @@ private:
     std::size_t content_offset = 0;
 
     std::vector<VirtualFile> pfs_files;
+    std::vector<VirtualDir> pfs_dirs;
 };
 
 } // namespace FileSys

src/core/file_sys/submission_package.cpp

@@ -205,6 +205,10 @@ VirtualDir NSP::GetParentDirectory() const {
     return file->GetContainingDirectory();
 }
 
+bool NSP::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    return false;
+}
+
 void NSP::InitializeExeFSAndRomFS(const std::vector<VirtualFile>& files) {
     exefs = pfs;
 

src/core/file_sys/submission_package.h

@@ -55,6 +55,9 @@ public:
 
     VirtualDir GetParentDirectory() const override;
 
+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
 private:
     void InitializeExeFSAndRomFS(const std::vector<VirtualFile>& files);
     void ReadNCAs(const std::vector<VirtualFile>& files);

src/core/file_sys/vfs.h

@@ -262,8 +262,36 @@ public:
     // item name -> type.
     virtual std::map<std::string, VfsEntryType, std::less<>> GetEntries() const;
 
+    // Interprets the file with name file instead as a directory of type directory.
+    // The directory must have a constructor that takes a single argument of type
+    // std::shared_ptr<VfsFile>. Allows to reinterpret container files (i.e NCA, zip, XCI, etc) as a
+    // subdirectory in one call.
+    template <typename Directory>
+    bool InterpretAsDirectory(std::string_view file) {
+        auto file_p = GetFile(file);
+
+        if (file_p == nullptr) {
+            return false;
+        }
+
+        return ReplaceFileWithSubdirectory(file_p, std::make_shared<Directory>(file_p));
+    }
+
+    bool InterpretAsDirectory(const std::function<VirtualDir(VirtualFile)>& function,
+                              const std::string& file) {
+        auto file_p = GetFile(file);
+        if (file_p == nullptr)
+            return false;
+        return ReplaceFileWithSubdirectory(file_p, function(file_p));
+    }
+
     // Returns the full path of this directory as a string, recursively
     virtual std::string GetFullPath() const;
+
+protected:
+    // Backend for InterpretAsDirectory.
+    // Removes all references to file and adds a reference to dir in the directory's implementation.
+    virtual bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) = 0;
 };
 
 // A convenience partial-implementation of VfsDirectory that stubs out methods that should only work

src/core/file_sys/vfs_layered.cpp

@@ -126,4 +126,7 @@ bool LayeredVfsDirectory::Rename(std::string_view name_) {
     return true;
 }
 
+bool LayeredVfsDirectory::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    return false;
+}
 } // namespace FileSys

src/core/file_sys/vfs_layered.h

@@ -39,6 +39,9 @@ public:
     bool DeleteFile(std::string_view name) override;
     bool Rename(std::string_view name) override;
 
+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
 private:
     std::vector<VirtualDir> dirs;
     std::string name;

src/core/file_sys/vfs_real.cpp

@@ -430,4 +430,7 @@ std::map<std::string, VfsEntryType, std::less<>> RealVfsDirectory::GetEntries()
     return out;
 }
 
+bool RealVfsDirectory::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    return false;
+}
 } // namespace FileSys

src/core/file_sys/vfs_real.h

@@ -100,6 +100,9 @@ public:
     std::string GetFullPath() const override;
     std::map<std::string, VfsEntryType, std::less<>> GetEntries() const override;
 
+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
 private:
     RealVfsDirectory(RealVfsFilesystem& base, const std::string& path, Mode perms = Mode::Read);
 

src/core/file_sys/vfs_vector.cpp

@@ -132,4 +132,11 @@ void VectorVfsDirectory::AddFile(VirtualFile file) {
 void VectorVfsDirectory::AddDirectory(VirtualDir dir) {
     dirs.push_back(std::move(dir));
 }
+
+bool VectorVfsDirectory::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    if (!DeleteFile(file->GetName()))
+        return false;
+    dirs.emplace_back(std::move(dir));
+    return true;
+}
 } // namespace FileSys

src/core/file_sys/vfs_vector.h

@@ -57,6 +57,9 @@ public:
     virtual void AddFile(VirtualFile file);
     virtual void AddDirectory(VirtualDir dir);
 
+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
 private:
     std::vector<VirtualFile> files;
     std::vector<VirtualDir> dirs;

src/core/file_sys/xts_archive.cpp

@@ -163,4 +163,7 @@ std::shared_ptr<VfsDirectory> NAX::GetParentDirectory() const {
     return file->GetContainingDirectory();
 }
 
+bool NAX::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    return false;
+}
 } // namespace FileSys

src/core/file_sys/xts_archive.h

@@ -51,6 +51,9 @@ public:
 
     std::shared_ptr<VfsDirectory> GetParentDirectory() const override;
 
+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
 private:
     Loader::ResultStatus Parse(std::string_view path);
 

src/core/hle/kernel/svc.cpp

@@ -584,6 +584,10 @@ static ResultCode MapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 s
         return ERR_INVALID_SIZE;
     }
 
+    if (!IsValidAddressRange(addr, size)) {
+        return ERR_INVALID_ADDRESS_STATE;
+    }
+
     const auto permissions_type = static_cast<MemoryPermission>(permissions);
     if (permissions_type != MemoryPermission::Read &&
         permissions_type != MemoryPermission::ReadWrite) {
@@ -597,8 +601,14 @@ static ResultCode MapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 s
         return ERR_INVALID_HANDLE;
     }
 
-    return shared_memory->Map(Core::CurrentProcess(), addr, permissions_type,
-                              MemoryPermission::DontCare);
+    auto* const current_process = Core::CurrentProcess();
+    const auto& vm_manager = current_process->VMManager();
+
+    if (!vm_manager.IsWithinASLRRegion(addr, size)) {
+        return ERR_INVALID_MEMORY_RANGE;
+    }
+
+    return shared_memory->Map(current_process, addr, permissions_type, MemoryPermission::DontCare);
 }
 
 static ResultCode UnmapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 size) {
@@ -613,10 +623,24 @@ static ResultCode UnmapSharedMemory(Handle shared_memory_handle, VAddr addr, u64
         return ERR_INVALID_SIZE;
     }
 
+    if (!IsValidAddressRange(addr, size)) {
+        return ERR_INVALID_ADDRESS_STATE;
+    }
+
     auto& kernel = Core::System::GetInstance().Kernel();
     auto shared_memory = kernel.HandleTable().Get<SharedMemory>(shared_memory_handle);
+    if (!shared_memory) {
+        return ERR_INVALID_HANDLE;
+    }
 
-    return shared_memory->Unmap(Core::CurrentProcess(), addr);
+    auto* const current_process = Core::CurrentProcess();
+    const auto& vm_manager = current_process->VMManager();
+
+    if (!vm_manager.IsWithinASLRRegion(addr, size)) {
+        return ERR_INVALID_MEMORY_RANGE;
+    }
+
+    return shared_memory->Unmap(current_process, addr);
 }
 
 /// Query process memory
@@ -630,7 +654,7 @@ static ResultCode QueryProcessMemory(MemoryInfo* memory_info, PageInfo* /*page_i
     }
     auto vma = process->VMManager().FindVMA(addr);
     memory_info->attributes = 0;
-    if (vma == Core::CurrentProcess()->VMManager().vma_map.end()) {
+    if (vma == process->VMManager().vma_map.end()) {
         memory_info->base_address = 0;
         memory_info->permission = static_cast<u32>(VMAPermission::None);
         memory_info->size = 0;

src/core/hle/kernel/vm_manager.cpp

@@ -507,6 +507,26 @@ u64 VMManager::GetASLRRegionSize() const {
     return aslr_region_end - aslr_region_base;
 }
 
+bool VMManager::IsWithinASLRRegion(VAddr begin, u64 size) const {
+    const VAddr range_end = begin + size;
+    const VAddr aslr_start = GetASLRRegionBaseAddress();
+    const VAddr aslr_end = GetASLRRegionEndAddress();
+
+    if (aslr_start > begin || begin > range_end || range_end - 1 > aslr_end - 1) {
+        return false;
+    }
+
+    if (range_end > heap_region_base && heap_region_end > begin) {
+        return false;
+    }
+
+    if (range_end > map_region_base && map_region_end > begin) {
+        return false;
+    }
+
+    return true;
+}
+
 VAddr VMManager::GetCodeRegionBaseAddress() const {
     return code_region_base;
 }

src/core/hle/kernel/vm_manager.h

@@ -211,6 +211,9 @@ public:
     /// Gets the end address of the ASLR region.
     VAddr GetASLRRegionEndAddress() const;
 
+    /// Determines whether or not the specified address range is within the ASLR region.
+    bool IsWithinASLRRegion(VAddr address, u64 size) const;
+
     /// Gets the size of the ASLR region
     u64 GetASLRRegionSize() const;
 

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

@@ -15,6 +15,7 @@
 #include "core/hle/service/am/idle.h"
 #include "core/hle/service/am/omm.h"
 #include "core/hle/service/am/spsm.h"
+#include "core/hle/service/am/tcap.h"
 #include "core/hle/service/apm/apm.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/nvflinger/nvflinger.h"
@@ -26,13 +27,18 @@
 namespace Service::AM {
 
 IWindowController::IWindowController() : ServiceFramework("IWindowController") {
+    // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "CreateWindow"},
         {1, &IWindowController::GetAppletResourceUserId, "GetAppletResourceUserId"},
         {10, &IWindowController::AcquireForegroundRights, "AcquireForegroundRights"},
         {11, nullptr, "ReleaseForegroundRights"},
         {12, nullptr, "RejectToChangeIntoBackground"},
+        {20, nullptr, "SetAppletWindowVisibility"},
+        {21, nullptr, "SetAppletGpuTimeSlice"},
     };
+    // clang-format on
+
     RegisterHandlers(functions);
 }
 
@@ -87,6 +93,7 @@ void IAudioController::GetLibraryAppletExpectedMasterVolume(Kernel::HLERequestCo
 }
 
 IDisplayController::IDisplayController() : ServiceFramework("IDisplayController") {
+    // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "GetLastForegroundCaptureImage"},
         {1, nullptr, "UpdateLastForegroundCaptureImage"},
@@ -117,7 +124,11 @@ IDisplayController::IDisplayController() : ServiceFramework("IDisplayController"
         {25, nullptr, "ReleaseLastForegroundCaptureSharedBuffer"},
         {26, nullptr, "AcquireCallerAppletCaptureSharedBuffer"},
         {27, nullptr, "ReleaseCallerAppletCaptureSharedBuffer"},
+        // 6.0.0+
+        {28, nullptr, "TakeScreenShotOfOwnLayerEx"},
     };
+    // clang-format on
+
     RegisterHandlers(functions);
 }
 
@@ -128,6 +139,7 @@ IDebugFunctions::~IDebugFunctions() = default;
 
 ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
     : ServiceFramework("ISelfController"), nvflinger(std::move(nvflinger)) {
+    // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "Exit"},
         {1, &ISelfController::LockExit, "LockExit"},
@@ -136,10 +148,8 @@ ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger
         {4, nullptr, "LeaveFatalSection"},
         {9, &ISelfController::GetLibraryAppletLaunchableEvent, "GetLibraryAppletLaunchableEvent"},
         {10, &ISelfController::SetScreenShotPermission, "SetScreenShotPermission"},
-        {11, &ISelfController::SetOperationModeChangedNotification,
-         "SetOperationModeChangedNotification"},
-        {12, &ISelfController::SetPerformanceModeChangedNotification,
-         "SetPerformanceModeChangedNotification"},
+        {11, &ISelfController::SetOperationModeChangedNotification, "SetOperationModeChangedNotification"},
+        {12, &ISelfController::SetPerformanceModeChangedNotification, "SetPerformanceModeChangedNotification"},
         {13, &ISelfController::SetFocusHandlingMode, "SetFocusHandlingMode"},
         {14, &ISelfController::SetRestartMessageEnabled, "SetRestartMessageEnabled"},
         {15, nullptr, "SetScreenShotAppletIdentityInfo"},
@@ -165,7 +175,12 @@ ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger
         {69, nullptr, "IsAutoSleepDisabled"},
         {70, nullptr, "ReportMultimediaError"},
         {80, nullptr, "SetWirelessPriorityMode"},
+        {90, nullptr, "GetAccumulatedSuspendedTickValue"},
+        {91, nullptr, "GetAccumulatedSuspendedTickChangedEvent"},
+        {1000, nullptr, "GetDebugStorageChannel"},
     };
+    // clang-format on
+
     RegisterHandlers(functions);
 
     auto& kernel = Core::System::GetInstance().Kernel();
@@ -312,6 +327,7 @@ void ISelfController::GetIdleTimeDetectionExtension(Kernel::HLERequestContext& c
 }
 
 ICommonStateGetter::ICommonStateGetter() : ServiceFramework("ICommonStateGetter") {
+    // clang-format off
     static const FunctionInfo functions[] = {
         {0, &ICommonStateGetter::GetEventHandle, "GetEventHandle"},
         {1, &ICommonStateGetter::ReceiveMessage, "ReceiveMessage"},
@@ -336,11 +352,12 @@ ICommonStateGetter::ICommonStateGetter() : ServiceFramework("ICommonStateGetter"
         {52, nullptr, "SwitchLcdBacklight"},
         {55, nullptr, "IsInControllerFirmwareUpdateSection"},
         {60, &ICommonStateGetter::GetDefaultDisplayResolution, "GetDefaultDisplayResolution"},
-        {61, &ICommonStateGetter::GetDefaultDisplayResolutionChangeEvent,
-         "GetDefaultDisplayResolutionChangeEvent"},
+        {61, &ICommonStateGetter::GetDefaultDisplayResolutionChangeEvent, "GetDefaultDisplayResolutionChangeEvent"},
         {62, nullptr, "GetHdcpAuthenticationState"},
         {63, nullptr, "GetHdcpAuthenticationStateChangeEvent"},
     };
+    // clang-format on
+
     RegisterHandlers(functions);
 
     auto& kernel = Core::System::GetInstance().Kernel();
@@ -432,11 +449,14 @@ class IStorageAccessor final : public ServiceFramework<IStorageAccessor> {
 public:
     explicit IStorageAccessor(std::vector<u8> buffer)
         : ServiceFramework("IStorageAccessor"), buffer(std::move(buffer)) {
+        // clang-format off
         static const FunctionInfo functions[] = {
             {0, &IStorageAccessor::GetSize, "GetSize"},
             {10, &IStorageAccessor::Write, "Write"},
             {11, &IStorageAccessor::Read, "Read"},
         };
+        // clang-format on
+
         RegisterHandlers(functions);
     }
 
@@ -489,10 +509,13 @@ class IStorage final : public ServiceFramework<IStorage> {
 public:
     explicit IStorage(std::vector<u8> buffer)
         : ServiceFramework("IStorage"), buffer(std::move(buffer)) {
+        // clang-format off
         static const FunctionInfo functions[] = {
             {0, &IStorage::Open, "Open"},
             {1, nullptr, "OpenTransferStorage"},
         };
+        // clang-format on
+
         RegisterHandlers(functions);
     }
 
@@ -512,6 +535,7 @@ private:
 class ILibraryAppletAccessor final : public ServiceFramework<ILibraryAppletAccessor> {
 public:
     explicit ILibraryAppletAccessor() : ServiceFramework("ILibraryAppletAccessor") {
+        // clang-format off
         static const FunctionInfo functions[] = {
             {0, &ILibraryAppletAccessor::GetAppletStateChangedEvent, "GetAppletStateChangedEvent"},
             {1, nullptr, "IsCompleted"},
@@ -532,6 +556,8 @@ public:
             {150, nullptr, "RequestForAppletToGetForeground"},
             {160, nullptr, "GetIndirectLayerConsumerHandle"},
         };
+        // clang-format on
+
         RegisterHandlers(functions);
 
         auto& kernel = Core::System::GetInstance().Kernel();
@@ -624,13 +650,13 @@ void ILibraryAppletCreator::CreateStorage(Kernel::HLERequestContext& ctx) {
 }
 
 IApplicationFunctions::IApplicationFunctions() : ServiceFramework("IApplicationFunctions") {
+    // clang-format off
     static const FunctionInfo functions[] = {
         {1, &IApplicationFunctions::PopLaunchParameter, "PopLaunchParameter"},
         {10, nullptr, "CreateApplicationAndPushAndRequestToStart"},
         {11, nullptr, "CreateApplicationAndPushAndRequestToStartForQuest"},
         {12, nullptr, "CreateApplicationAndRequestToStart"},
-        {13, &IApplicationFunctions::CreateApplicationAndRequestToStartForQuest,
-         "CreateApplicationAndRequestToStartForQuest"},
+        {13, &IApplicationFunctions::CreateApplicationAndRequestToStartForQuest, "CreateApplicationAndRequestToStartForQuest"},
         {20, &IApplicationFunctions::EnsureSaveData, "EnsureSaveData"},
         {21, &IApplicationFunctions::GetDesiredLanguage, "GetDesiredLanguage"},
         {22, &IApplicationFunctions::SetTerminateResult, "SetTerminateResult"},
@@ -638,10 +664,8 @@ IApplicationFunctions::IApplicationFunctions() : ServiceFramework("IApplicationF
         {24, nullptr, "GetLaunchStorageInfoForDebug"},
         {25, nullptr, "ExtendSaveData"},
         {26, nullptr, "GetSaveDataSize"},
-        {30, &IApplicationFunctions::BeginBlockingHomeButtonShortAndLongPressed,
-         "BeginBlockingHomeButtonShortAndLongPressed"},
-        {31, &IApplicationFunctions::EndBlockingHomeButtonShortAndLongPressed,
-         "EndBlockingHomeButtonShortAndLongPressed"},
+        {30, &IApplicationFunctions::BeginBlockingHomeButtonShortAndLongPressed, "BeginBlockingHomeButtonShortAndLongPressed"},
+        {31, &IApplicationFunctions::EndBlockingHomeButtonShortAndLongPressed, "EndBlockingHomeButtonShortAndLongPressed"},
         {32, &IApplicationFunctions::BeginBlockingHomeButton, "BeginBlockingHomeButton"},
         {33, &IApplicationFunctions::EndBlockingHomeButton, "EndBlockingHomeButton"},
         {40, &IApplicationFunctions::NotifyRunning, "NotifyRunning"},
@@ -666,6 +690,8 @@ IApplicationFunctions::IApplicationFunctions() : ServiceFramework("IApplicationF
         {1000, nullptr, "CreateMovieMaker"},
         {1001, nullptr, "PrepareForJit"},
     };
+    // clang-format on
+
     RegisterHandlers(functions);
 }
 
@@ -804,9 +830,11 @@ void InstallInterfaces(SM::ServiceManager& service_manager,
     std::make_shared<IdleSys>()->InstallAsService(service_manager);
     std::make_shared<OMM>()->InstallAsService(service_manager);
     std::make_shared<SPSM>()->InstallAsService(service_manager);
+    std::make_shared<TCAP>()->InstallAsService(service_manager);
 }
 
 IHomeMenuFunctions::IHomeMenuFunctions() : ServiceFramework("IHomeMenuFunctions") {
+    // clang-format off
     static const FunctionInfo functions[] = {
         {10, &IHomeMenuFunctions::RequestToGetForeground, "RequestToGetForeground"},
         {11, nullptr, "LockForeground"},
@@ -815,7 +843,10 @@ IHomeMenuFunctions::IHomeMenuFunctions() : ServiceFramework("IHomeMenuFunctions"
         {21, nullptr, "GetPopFromGeneralChannelEvent"},
         {30, nullptr, "GetHomeButtonWriterLockAccessor"},
         {31, nullptr, "GetWriterLockAccessorEx"},
+        {100, nullptr, "PopRequestLaunchApplicationForDebug"},
     };
+    // clang-format on
+
     RegisterHandlers(functions);
 }
 
@@ -828,6 +859,7 @@ void IHomeMenuFunctions::RequestToGetForeground(Kernel::HLERequestContext& ctx)
 }
 
 IGlobalStateController::IGlobalStateController() : ServiceFramework("IGlobalStateController") {
+    // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "RequestToEnterSleep"},
         {1, nullptr, "EnterSleep"},
@@ -841,18 +873,23 @@ IGlobalStateController::IGlobalStateController() : ServiceFramework("IGlobalStat
         {14, nullptr, "ShouldSleepOnBoot"},
         {15, nullptr, "GetHdcpAuthenticationFailedEvent"},
     };
+    // clang-format on
+
     RegisterHandlers(functions);
 }
 
 IGlobalStateController::~IGlobalStateController() = default;
 
 IApplicationCreator::IApplicationCreator() : ServiceFramework("IApplicationCreator") {
+    // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "CreateApplication"},
         {1, nullptr, "PopLaunchRequestedApplication"},
         {10, nullptr, "CreateSystemApplication"},
         {100, nullptr, "PopFloatingApplicationForDevelopment"},
     };
+    // clang-format on
+
     RegisterHandlers(functions);
 }
 
@@ -860,6 +897,7 @@ IApplicationCreator::~IApplicationCreator() = default;
 
 IProcessWindingController::IProcessWindingController()
     : ServiceFramework("IProcessWindingController") {
+    // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "GetLaunchReason"},
         {11, nullptr, "OpenCallingLibraryApplet"},
@@ -870,6 +908,8 @@ IProcessWindingController::IProcessWindingController()
         {40, nullptr, "ReserveToStartAndWaitAndUnwindThis"},
         {41, nullptr, "ReserveToStartAndWait"},
     };
+    // clang-format on
+
     RegisterHandlers(functions);
 }
 

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

@@ -211,6 +211,7 @@ void AppletAE::OpenLibraryAppletProxyOld(Kernel::HLERequestContext& ctx) {
 
 AppletAE::AppletAE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
     : ServiceFramework("appletAE"), nvflinger(std::move(nvflinger)) {
+    // clang-format off
     static const FunctionInfo functions[] = {
         {100, &AppletAE::OpenSystemAppletProxy, "OpenSystemAppletProxy"},
         {200, &AppletAE::OpenLibraryAppletProxyOld, "OpenLibraryAppletProxyOld"},
@@ -218,7 +219,10 @@ AppletAE::AppletAE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
         {300, nullptr, "OpenOverlayAppletProxy"},
         {350, nullptr, "OpenSystemApplicationProxy"},
         {400, nullptr, "CreateSelfLibraryAppletCreatorForDevelop"},
+        {401, nullptr, "GetSystemAppletControllerForDebug"},
     };
+    // clang-format on
+
     RegisterHandlers(functions);
 }
 

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

@@ -14,6 +14,7 @@ class IApplicationProxy final : public ServiceFramework<IApplicationProxy> {
 public:
     explicit IApplicationProxy(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
         : ServiceFramework("IApplicationProxy"), nvflinger(std::move(nvflinger)) {
+        // clang-format off
         static const FunctionInfo functions[] = {
             {0, &IApplicationProxy::GetCommonStateGetter, "GetCommonStateGetter"},
             {1, &IApplicationProxy::GetSelfController, "GetSelfController"},
@@ -25,6 +26,8 @@ public:
             {20, &IApplicationProxy::GetApplicationFunctions, "GetApplicationFunctions"},
             {1000, &IApplicationProxy::GetDebugFunctions, "GetDebugFunctions"},
         };
+        // clang-format on
+
         RegisterHandlers(functions);
     }
 

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

@@ -12,9 +12,9 @@ IdleSys::IdleSys() : ServiceFramework{"idle:sys"} {
         {0, nullptr, "GetAutoPowerDownEvent"},
         {1, nullptr, "Unknown1"},
         {2, nullptr, "Unknown2"},
-        {3, nullptr, "Unknown3"},
-        {4, nullptr, "Unknown4"},
-        {5, nullptr, "Unknown5"},
+        {3, nullptr, "SetHandlingContext"},
+        {4, nullptr, "LoadAndApplySettings"},
+        {5, nullptr, "ReportUserIsActive"},
     };
     // clang-format on
 

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

@@ -17,22 +17,24 @@ OMM::OMM() : ServiceFramework{"omm"} {
         {5, nullptr, "GetCradleStatus"},
         {6, nullptr, "FadeInDisplay"},
         {7, nullptr, "FadeOutDisplay"},
-        {8, nullptr, "Unknown1"},
-        {9, nullptr, "Unknown2"},
-        {10, nullptr, "Unknown3"},
-        {11, nullptr, "Unknown4"},
-        {12, nullptr, "Unknown5"},
-        {13, nullptr, "Unknown6"},
-        {14, nullptr, "Unknown7"},
-        {15, nullptr, "Unknown8"},
-        {16, nullptr, "Unknown9"},
-        {17, nullptr, "Unknown10"},
-        {18, nullptr, "Unknown11"},
-        {19, nullptr, "Unknown12"},
-        {20, nullptr, "Unknown13"},
-        {21, nullptr, "Unknown14"},
-        {22, nullptr, "Unknown15"},
-        {23, nullptr, "Unknown16"},
+        {8, nullptr, "GetCradleFwVersion"},
+        {9, nullptr, "NotifyCecSettingsChanged"},
+        {10, nullptr, "SetOperationModePolicy"},
+        {11, nullptr, "GetDefaultDisplayResolution"},
+        {12, nullptr, "GetDefaultDisplayResolutionChangeEvent"},
+        {13, nullptr, "UpdateDefaultDisplayResolution"},
+        {14, nullptr, "ShouldSleepOnBoot"},
+        {15, nullptr, "NotifyHdcpApplicationExecutionStarted"},
+        {16, nullptr, "NotifyHdcpApplicationExecutionFinished"},
+        {17, nullptr, "NotifyHdcpApplicationDrawingStarted"},
+        {18, nullptr, "NotifyHdcpApplicationDrawingFinished"},
+        {19, nullptr, "GetHdcpAuthenticationFailedEvent"},
+        {20, nullptr, "GetHdcpAuthenticationFailedEmulationEnabled"},
+        {21, nullptr, "SetHdcpAuthenticationFailedEmulation"},
+        {22, nullptr, "GetHdcpStateChangeEvent"},
+        {23, nullptr, "GetHdcpState"},
+        {24, nullptr, "ShowCardUpdateProcessing"},
+        {25, nullptr, "SetApplicationCecSettingsAndNotifyChanged"},
     };
     // clang-format on
 

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

@@ -0,0 +1,23 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/service/am/tcap.h"
+
+namespace Service::AM {
+
+TCAP::TCAP() : ServiceFramework{"tcap"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "GetContinuousHighSkinTemperatureEvent"},
+        {1, nullptr, "SetOperationMode"},
+        {2, nullptr, "LoadAndApplySettings"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+TCAP::~TCAP() = default;
+
+} // namespace Service::AM

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

@@ -0,0 +1,17 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/hle/service/service.h"
+
+namespace Service::AM {
+
+class TCAP final : public ServiceFramework<TCAP> {
+public:
+    explicit TCAP();
+    ~TCAP() override;
+};
+
+} // namespace Service::AM

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

@@ -13,6 +13,7 @@
 #include "core/file_sys/patch_manager.h"
 #include "core/file_sys/registered_cache.h"
 #include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/event.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/service/aoc/aoc_u.h"
 #include "core/hle/service/filesystem/filesystem.h"
@@ -55,9 +56,13 @@ AOC_U::AOC_U() : ServiceFramework("aoc:u"), add_on_content(AccumulateAOCTitleIDs
         {5, &AOC_U::GetAddOnContentBaseId, "GetAddOnContentBaseId"},
         {6, nullptr, "PrepareAddOnContentByApplicationId"},
         {7, &AOC_U::PrepareAddOnContent, "PrepareAddOnContent"},
-        {8, nullptr, "GetAddOnContentListChangedEvent"},
+        {8, &AOC_U::GetAddOnContentListChangedEvent, "GetAddOnContentListChangedEvent"},
     };
     RegisterHandlers(functions);
+
+    auto& kernel = Core::System::GetInstance().Kernel();
+    aoc_change_event = Kernel::Event::Create(kernel, Kernel::ResetType::Sticky,
+                                             "GetAddOnContentListChanged:Event");
 }
 
 AOC_U::~AOC_U() = default;
@@ -130,6 +135,14 @@ void AOC_U::PrepareAddOnContent(Kernel::HLERequestContext& ctx) {
     rb.Push(RESULT_SUCCESS);
 }
 
+void AOC_U::GetAddOnContentListChangedEvent(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AOC, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushCopyObjects(aoc_change_event);
+}
+
 void InstallInterfaces(SM::ServiceManager& service_manager) {
     std::make_shared<AOC_U>()->InstallAsService(service_manager);
 }

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

@@ -18,8 +18,10 @@ private:
     void ListAddOnContent(Kernel::HLERequestContext& ctx);
     void GetAddOnContentBaseId(Kernel::HLERequestContext& ctx);
     void PrepareAddOnContent(Kernel::HLERequestContext& ctx);
+    void GetAddOnContentListChangedEvent(Kernel::HLERequestContext& ctx);
 
     std::vector<u64> add_on_content;
+    Kernel::SharedPtr<Kernel::Event> aoc_change_event;
 };
 
 /// Registers all AOC services with the specified service manager.

src/core/hle/service/audio/audren_u.cpp

@@ -22,20 +22,22 @@ class IAudioRenderer final : public ServiceFramework<IAudioRenderer> {
 public:
     explicit IAudioRenderer(AudioCore::AudioRendererParameter audren_params)
         : ServiceFramework("IAudioRenderer") {
+        // clang-format off
         static const FunctionInfo functions[] = {
-            {0, &IAudioRenderer::GetAudioRendererSampleRate, "GetAudioRendererSampleRate"},
-            {1, &IAudioRenderer::GetAudioRendererSampleCount, "GetAudioRendererSampleCount"},
-            {2, &IAudioRenderer::GetAudioRendererMixBufferCount, "GetAudioRendererMixBufferCount"},
-            {3, &IAudioRenderer::GetAudioRendererState, "GetAudioRendererState"},
-            {4, &IAudioRenderer::RequestUpdateAudioRenderer, "RequestUpdateAudioRenderer"},
-            {5, &IAudioRenderer::StartAudioRenderer, "StartAudioRenderer"},
-            {6, &IAudioRenderer::StopAudioRenderer, "StopAudioRenderer"},
+            {0, &IAudioRenderer::GetSampleRate, "GetSampleRate"},
+            {1, &IAudioRenderer::GetSampleCount, "GetSampleCount"},
+            {2, &IAudioRenderer::GetMixBufferCount, "GetMixBufferCount"},
+            {3, &IAudioRenderer::GetState, "GetState"},
+            {4, &IAudioRenderer::RequestUpdate, "RequestUpdate"},
+            {5, &IAudioRenderer::Start, "Start"},
+            {6, &IAudioRenderer::Stop, "Stop"},
             {7, &IAudioRenderer::QuerySystemEvent, "QuerySystemEvent"},
-            {8, nullptr, "SetAudioRendererRenderingTimeLimit"},
-            {9, nullptr, "GetAudioRendererRenderingTimeLimit"},
-            {10, nullptr, "RequestUpdateAudioRendererAuto"},
+            {8, nullptr, "SetRenderingTimeLimit"},
+            {9, nullptr, "GetRenderingTimeLimit"},
+            {10, nullptr, "RequestUpdateAuto"},
             {11, nullptr, "ExecuteAudioRendererRendering"},
         };
+        // clang-format on
         RegisterHandlers(functions);
 
         auto& kernel = Core::System::GetInstance().Kernel();
@@ -49,42 +51,42 @@ private:
         system_event->Signal();
     }
 
-    void GetAudioRendererSampleRate(Kernel::HLERequestContext& ctx) {
+    void GetSampleRate(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
         rb.Push<u32>(renderer->GetSampleRate());
         LOG_DEBUG(Service_Audio, "called");
     }
 
-    void GetAudioRendererSampleCount(Kernel::HLERequestContext& ctx) {
+    void GetSampleCount(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
         rb.Push<u32>(renderer->GetSampleCount());
         LOG_DEBUG(Service_Audio, "called");
     }
 
-    void GetAudioRendererState(Kernel::HLERequestContext& ctx) {
+    void GetState(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
         rb.Push<u32>(static_cast<u32>(renderer->GetStreamState()));
         LOG_DEBUG(Service_Audio, "called");
     }
 
-    void GetAudioRendererMixBufferCount(Kernel::HLERequestContext& ctx) {
+    void GetMixBufferCount(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
         rb.Push<u32>(renderer->GetMixBufferCount());
         LOG_DEBUG(Service_Audio, "called");
     }
 
-    void RequestUpdateAudioRenderer(Kernel::HLERequestContext& ctx) {
+    void RequestUpdate(Kernel::HLERequestContext& ctx) {
         ctx.WriteBuffer(renderer->UpdateAudioRenderer(ctx.ReadBuffer()));
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
         LOG_WARNING(Service_Audio, "(STUBBED) called");
     }
 
-    void StartAudioRenderer(Kernel::HLERequestContext& ctx) {
+    void Start(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 2};
 
         rb.Push(RESULT_SUCCESS);
@@ -92,7 +94,7 @@ private:
         LOG_WARNING(Service_Audio, "(STUBBED) called");
     }
 
-    void StopAudioRenderer(Kernel::HLERequestContext& ctx) {
+    void Stop(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 2};
 
         rb.Push(RESULT_SUCCESS);
@@ -129,6 +131,7 @@ public:
             {10, &IAudioDevice::GetActiveAudioDeviceName, "GetActiveAudioDeviceNameAuto"},
             {11, nullptr, "QueryAudioDeviceInputEvent"},
             {12, nullptr, "QueryAudioDeviceOutputEvent"},
+            {13, nullptr, "GetAudioSystemMasterVolumeSetting"},
         };
         RegisterHandlers(functions);
 

src/core/hle/service/es/es.cpp

@@ -9,6 +9,7 @@ namespace Service::ES {
 class ETicket final : public ServiceFramework<ETicket> {
 public:
     explicit ETicket() : ServiceFramework{"es"} {
+        // clang-format off
         static const FunctionInfo functions[] = {
             {1, nullptr, "ImportTicket"},
             {2, nullptr, "ImportTicketCertificateSet"},
@@ -37,15 +38,18 @@ public:
             {25, nullptr, "DeletePrepurchaseRecord"},
             {26, nullptr, "DeleteAllPrepurchaseRecord"},
             {27, nullptr, "CountPrepurchaseRecord"},
-            {28, nullptr, "ListPrepurchaseRecord"},
+            {28, nullptr, "ListPrepurchaseRecordRightsIds"},
             {29, nullptr, "ListPrepurchaseRecordInfo"},
-            {30, nullptr, "Unknown1"},
-            {31, nullptr, "Unknown2"},
-            {32, nullptr, "Unknown3"},
-            {33, nullptr, "Unknown4"},
-            {34, nullptr, "Unknown5"},
-            {35, nullptr, "Unknown6"},
+            {30, nullptr, "CountTicket"},
+            {31, nullptr, "ListTicketRightsIds"},
+            {32, nullptr, "CountPrepurchaseRecordEx"},
+            {33, nullptr, "ListPrepurchaseRecordRightsIdsEx"},
+            {34, nullptr, "GetEncryptedTicketSize"},
+            {35, nullptr, "GetEncryptedTicketData"},
+            {36, nullptr, "DeleteAllInactiveELicenseRequiredPersonalizedTicket"},
+            {503, nullptr, "GetTitleKey"},
         };
+        // clang-format on
         RegisterHandlers(functions);
     }
 };

src/core/hle/service/hid/controllers/controller_base.cpp

@@ -5,6 +5,8 @@
 #include "core/hle/service/hid/controllers/controller_base.h"
 
 namespace Service::HID {
+
+ControllerBase::ControllerBase() = default;
 ControllerBase::~ControllerBase() = default;
 
 void ControllerBase::ActivateController() {

src/core/hle/service/hid/controllers/controller_base.h

@@ -10,8 +10,8 @@
 namespace Service::HID {
 class ControllerBase {
 public:
-    ControllerBase() = default;
-    virtual ~ControllerBase() = 0;
+    ControllerBase();
+    virtual ~ControllerBase();
 
     // Called when the controller is initialized
     virtual void OnInit() = 0;

src/core/hle/service/hid/controllers/debug_pad.cpp

@@ -4,13 +4,13 @@
 
 #include <cstring>
 #include "common/common_types.h"
-#include "common/swap.h"
 #include "core/core_timing.h"
 #include "core/hle/service/hid/controllers/debug_pad.h"
 
 namespace Service::HID {
 
 Controller_DebugPad::Controller_DebugPad() = default;
+Controller_DebugPad::~Controller_DebugPad() = default;
 
 void Controller_DebugPad::OnInit() {}
 

src/core/hle/service/hid/controllers/debug_pad.h

@@ -14,6 +14,7 @@ namespace Service::HID {
 class Controller_DebugPad final : public ControllerBase {
 public:
     Controller_DebugPad();
+    ~Controller_DebugPad() override;
 
     // Called when the controller is initialized
     void OnInit() override;

src/core/hle/service/hid/controllers/gesture.cpp

@@ -4,7 +4,6 @@
 
 #include <cstring>
 #include "common/common_types.h"
-#include "common/swap.h"
 #include "core/core_timing.h"
 #include "core/hle/service/hid/controllers/gesture.h"
 
@@ -12,6 +11,7 @@ namespace Service::HID {
 constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3BA00;
 
 Controller_Gesture::Controller_Gesture() = default;
+Controller_Gesture::~Controller_Gesture() = default;
 
 void Controller_Gesture::OnInit() {}
 

src/core/hle/service/hid/controllers/gesture.h

@@ -13,6 +13,7 @@ namespace Service::HID {
 class Controller_Gesture final : public ControllerBase {
 public:
     Controller_Gesture();
+    ~Controller_Gesture() override;
 
     // Called when the controller is initialized
     void OnInit() override;

src/core/hle/service/hid/controllers/keyboard.cpp

@@ -4,7 +4,6 @@
 
 #include <cstring>
 #include "common/common_types.h"
-#include "common/swap.h"
 #include "core/core_timing.h"
 #include "core/hle/service/hid/controllers/keyboard.h"
 
@@ -12,6 +11,7 @@ namespace Service::HID {
 constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3800;
 
 Controller_Keyboard::Controller_Keyboard() = default;
+Controller_Keyboard::~Controller_Keyboard() = default;
 
 void Controller_Keyboard::OnInit() {}
 

src/core/hle/service/hid/controllers/keyboard.h

@@ -14,6 +14,7 @@ namespace Service::HID {
 class Controller_Keyboard final : public ControllerBase {
 public:
     Controller_Keyboard();
+    ~Controller_Keyboard() override;
 
     // Called when the controller is initialized
     void OnInit() override;

src/core/hle/service/hid/controllers/mouse.cpp

@@ -4,7 +4,6 @@
 
 #include <cstring>
 #include "common/common_types.h"
-#include "common/swap.h"
 #include "core/core_timing.h"
 #include "core/hle/service/hid/controllers/mouse.h"
 
@@ -12,6 +11,7 @@ namespace Service::HID {
 constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3400;
 
 Controller_Mouse::Controller_Mouse() = default;
+Controller_Mouse::~Controller_Mouse() = default;
 
 void Controller_Mouse::OnInit() {}
 

src/core/hle/service/hid/controllers/mouse.h

@@ -13,6 +13,7 @@ namespace Service::HID {
 class Controller_Mouse final : public ControllerBase {
 public:
     Controller_Mouse();
+    ~Controller_Mouse() override;
 
     // Called when the controller is initialized
     void OnInit() override;

src/core/hle/service/hid/controllers/npad.cpp

@@ -2,8 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#pragma once
-
 #include <algorithm>
 #include <array>
 #include <cstring>
@@ -11,7 +9,6 @@
 #include "common/bit_field.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
-#include "common/swap.h"
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/frontend/input.h"
@@ -20,6 +17,7 @@
 #include "core/settings.h"
 
 namespace Service::HID {
+
 constexpr u32 JOYCON_BODY_NEON_RED = 0xFF3C28;
 constexpr u32 JOYCON_BUTTONS_NEON_RED = 0x1E0A0A;
 constexpr u32 JOYCON_BODY_NEON_BLUE = 0x0AB9E6;
@@ -28,9 +26,22 @@ constexpr s32 HID_JOYSTICK_MAX = 0x7fff;
 constexpr s32 HID_JOYSTICK_MIN = -0x7fff;
 constexpr std::size_t NPAD_OFFSET = 0x9A00;
 constexpr u32 BATTERY_FULL = 2;
-enum class JoystickId : std::size_t { Joystick_Left, Joystick_Right };
+constexpr u32 NPAD_HANDHELD = 32;
+constexpr u32 NPAD_UNKNOWN = 16; // TODO(ogniK): What is this?
+constexpr u32 MAX_NPAD_ID = 7;
+constexpr Controller_NPad::NPadControllerType PREFERRED_CONTROLLER =
+    Controller_NPad::NPadControllerType::JoyDual;
+constexpr std::array<u32, 10> npad_id_list{
+    0, 1, 2, 3, 4, 5, 6, 7, 32, 16,
+};
+
+enum class JoystickId : std::size_t {
+    Joystick_Left,
+    Joystick_Right,
+};
 
 Controller_NPad::Controller_NPad() = default;
+Controller_NPad::~Controller_NPad() = default;
 
 void Controller_NPad::InitNewlyAddedControler(std::size_t controller_idx) {
     const auto controller_type = connected_controllers[controller_idx].type;
@@ -114,7 +125,7 @@ void Controller_NPad::OnInit() {
         supported_npad_id_types.resize(npad_id_list.size());
         std::memcpy(supported_npad_id_types.data(), npad_id_list.data(),
                     npad_id_list.size() * sizeof(u32));
-        AddNewController(NPadControllerType::JoyDual);
+        AddNewController(PREFERRED_CONTROLLER);
     }
 }
 
@@ -211,6 +222,51 @@ void Controller_NPad::OnUpdate(u8* data, std::size_t data_len) {
         rstick_entry.x = static_cast<s32>(stick_r_x_f * HID_JOYSTICK_MAX);
         rstick_entry.y = static_cast<s32>(stick_r_y_f * HID_JOYSTICK_MAX);
 
+        if (controller_type == NPadControllerType::JoyLeft ||
+            controller_type == NPadControllerType::JoyRight) {
+            if (npad.properties.is_horizontal) {
+                ControllerPadState state{};
+                AnalogPosition temp_lstick_entry{};
+                AnalogPosition temp_rstick_entry{};
+                if (controller_type == NPadControllerType::JoyLeft) {
+                    state.d_down.Assign(pad_state.d_left.Value());
+                    state.d_left.Assign(pad_state.d_up.Value());
+                    state.d_right.Assign(pad_state.d_down.Value());
+                    state.d_up.Assign(pad_state.d_right.Value());
+                    state.l.Assign(pad_state.l.Value() | pad_state.sl.Value());
+                    state.r.Assign(pad_state.r.Value() | pad_state.sr.Value());
+
+                    state.zl.Assign(pad_state.zl.Value());
+                    state.plus.Assign(pad_state.minus.Value());
+
+                    temp_lstick_entry = lstick_entry;
+                    temp_rstick_entry = rstick_entry;
+                    std::swap(temp_lstick_entry.x, temp_lstick_entry.y);
+                    std::swap(temp_rstick_entry.x, temp_rstick_entry.y);
+                    temp_lstick_entry.y *= -1;
+                } else if (controller_type == NPadControllerType::JoyRight) {
+                    state.x.Assign(pad_state.a.Value());
+                    state.a.Assign(pad_state.b.Value());
+                    state.b.Assign(pad_state.y.Value());
+                    state.y.Assign(pad_state.b.Value());
+
+                    state.l.Assign(pad_state.l.Value() | pad_state.sl.Value());
+                    state.r.Assign(pad_state.r.Value() | pad_state.sr.Value());
+                    state.zr.Assign(pad_state.zr.Value());
+                    state.plus.Assign(pad_state.plus.Value());
+
+                    temp_lstick_entry = lstick_entry;
+                    temp_rstick_entry = rstick_entry;
+                    std::swap(temp_lstick_entry.x, temp_lstick_entry.y);
+                    std::swap(temp_rstick_entry.x, temp_rstick_entry.y);
+                    temp_rstick_entry.x *= -1;
+                }
+                pad_state.raw = state.raw;
+                lstick_entry = temp_lstick_entry;
+                rstick_entry = temp_rstick_entry;
+            }
+        }
+
         auto& main_controller =
             npad.main_controller_states.npad[npad.main_controller_states.common.last_entry_index];
         auto& handheld_entry =
@@ -313,9 +369,19 @@ void Controller_NPad::SetSupportedNPadIdTypes(u8* data, std::size_t length) {
     supported_npad_id_types.clear();
     supported_npad_id_types.resize(length / sizeof(u32));
     std::memcpy(supported_npad_id_types.data(), data, length);
+    for (std::size_t i = 0; i < connected_controllers.size(); i++) {
+        auto& controller = connected_controllers[i];
+        if (!controller.is_connected) {
+            continue;
+        }
+        if (!IsControllerSupported(PREFERRED_CONTROLLER)) {
+            controller.type = DecideBestController(PREFERRED_CONTROLLER);
+            InitNewlyAddedControler(i);
+        }
+    }
 }
 
-const void Controller_NPad::GetSupportedNpadIdTypes(u32* data, std::size_t max_length) {
+void Controller_NPad::GetSupportedNpadIdTypes(u32* data, std::size_t max_length) {
     ASSERT(max_length < supported_npad_id_types.size());
     std::memcpy(data, supported_npad_id_types.data(), supported_npad_id_types.size());
 }
@@ -344,11 +410,11 @@ void Controller_NPad::VibrateController(const std::vector<u32>& controller_ids,
     for (std::size_t i = 0; i < controller_ids.size(); i++) {
         std::size_t controller_pos = i;
         // Handheld controller conversion
-        if (controller_pos == 32) {
+        if (controller_pos == NPAD_HANDHELD) {
             controller_pos = 8;
         }
         // Unknown controller conversion
-        if (controller_pos == 16) {
+        if (controller_pos == NPAD_UNKNOWN) {
             controller_pos = 9;
         }
         if (connected_controllers[controller_pos].is_connected) {
@@ -426,4 +492,128 @@ Controller_NPad::LedPattern Controller_NPad::GetLedPattern(u32 npad_id) {
 void Controller_NPad::SetVibrationEnabled(bool can_vibrate) {
     can_controllers_vibrate = can_vibrate;
 }
+
+bool Controller_NPad::IsControllerSupported(NPadControllerType controller) const {
+    const bool support_handheld =
+        std::find(supported_npad_id_types.begin(), supported_npad_id_types.end(), NPAD_HANDHELD) !=
+        supported_npad_id_types.end();
+    if (controller == NPadControllerType::Handheld) {
+        // Handheld is not even a supported type, lets stop here
+        if (!support_handheld) {
+            return false;
+        }
+        // Handheld should not be supported in docked mode
+        if (Settings::values.use_docked_mode) {
+            return false;
+        }
+
+        return true;
+    }
+    if (std::any_of(supported_npad_id_types.begin(), supported_npad_id_types.end(),
+                    [](u32 npad_id) { return npad_id <= MAX_NPAD_ID; })) {
+        switch (controller) {
+        case NPadControllerType::ProController:
+            return style.pro_controller;
+        case NPadControllerType::JoyDual:
+            return style.joycon_dual;
+        case NPadControllerType::JoyLeft:
+            return style.joycon_left;
+        case NPadControllerType::JoyRight:
+            return style.joycon_right;
+        case NPadControllerType::Pokeball:
+            return style.pokeball;
+        default:
+            return false;
+        }
+    }
+    return false;
+}
+
+Controller_NPad::NPadControllerType Controller_NPad::DecideBestController(
+    NPadControllerType priority) const {
+    if (IsControllerSupported(priority)) {
+        return priority;
+    }
+    const auto is_docked = Settings::values.use_docked_mode;
+    if (is_docked && priority == NPadControllerType::Handheld) {
+        priority = NPadControllerType::JoyDual;
+        if (IsControllerSupported(priority)) {
+            return priority;
+        }
+    }
+    std::vector<NPadControllerType> priority_list;
+    switch (priority) {
+    case NPadControllerType::ProController:
+        priority_list.push_back(NPadControllerType::JoyDual);
+        if (!is_docked) {
+            priority_list.push_back(NPadControllerType::Handheld);
+        }
+        priority_list.push_back(NPadControllerType::JoyLeft);
+        priority_list.push_back(NPadControllerType::JoyRight);
+        priority_list.push_back(NPadControllerType::Pokeball);
+        break;
+    case NPadControllerType::Handheld:
+        priority_list.push_back(NPadControllerType::JoyDual);
+        priority_list.push_back(NPadControllerType::ProController);
+        priority_list.push_back(NPadControllerType::JoyLeft);
+        priority_list.push_back(NPadControllerType::JoyRight);
+        priority_list.push_back(NPadControllerType::Pokeball);
+        break;
+    case NPadControllerType::JoyDual:
+        if (!is_docked) {
+            priority_list.push_back(NPadControllerType::Handheld);
+        }
+        priority_list.push_back(NPadControllerType::ProController);
+        priority_list.push_back(NPadControllerType::JoyLeft);
+        priority_list.push_back(NPadControllerType::JoyRight);
+        priority_list.push_back(NPadControllerType::Pokeball);
+        break;
+    case NPadControllerType::JoyLeft:
+        priority_list.push_back(NPadControllerType::JoyRight);
+        priority_list.push_back(NPadControllerType::JoyDual);
+        if (!is_docked) {
+            priority_list.push_back(NPadControllerType::Handheld);
+        }
+        priority_list.push_back(NPadControllerType::ProController);
+        priority_list.push_back(NPadControllerType::Pokeball);
+        break;
+    case NPadControllerType::JoyRight:
+        priority_list.push_back(NPadControllerType::JoyLeft);
+        priority_list.push_back(NPadControllerType::JoyDual);
+        if (!is_docked) {
+            priority_list.push_back(NPadControllerType::Handheld);
+        }
+        priority_list.push_back(NPadControllerType::ProController);
+        priority_list.push_back(NPadControllerType::Pokeball);
+        break;
+    case NPadControllerType::Pokeball:
+        priority_list.push_back(NPadControllerType::JoyLeft);
+        priority_list.push_back(NPadControllerType::JoyRight);
+        priority_list.push_back(NPadControllerType::JoyDual);
+        if (!is_docked) {
+            priority_list.push_back(NPadControllerType::Handheld);
+        }
+        priority_list.push_back(NPadControllerType::ProController);
+        break;
+    default:
+        priority_list.push_back(NPadControllerType::JoyDual);
+        if (!is_docked) {
+            priority_list.push_back(NPadControllerType::Handheld);
+        }
+        priority_list.push_back(NPadControllerType::ProController);
+        priority_list.push_back(NPadControllerType::JoyLeft);
+        priority_list.push_back(NPadControllerType::JoyRight);
+        priority_list.push_back(NPadControllerType::JoyDual);
+    }
+
+    const auto iter = std::find_if(priority_list.begin(), priority_list.end(),
+                                   [this](auto type) { return IsControllerSupported(type); });
+    if (iter == priority_list.end()) {
+        UNIMPLEMENTED_MSG("Could not find supported controller!");
+        return priority;
+    }
+
+    return *iter;
+}
+
 } // namespace Service::HID

src/core/hle/service/hid/controllers/npad.h

@@ -15,6 +15,7 @@ namespace Service::HID {
 class Controller_NPad final : public ControllerBase {
 public:
     Controller_NPad();
+    ~Controller_NPad() override;
 
     // Called when the controller is initialized
     void OnInit() override;
@@ -77,7 +78,7 @@ public:
             position1.Assign(light2);
             position1.Assign(light3);
             position1.Assign(light4);
-        };
+        }
         union {
             u64 raw{};
             BitField<0, 1, u64> position1;
@@ -91,7 +92,7 @@ public:
     NPadType GetSupportedStyleSet() const;
 
     void SetSupportedNPadIdTypes(u8* data, std::size_t length);
-    const void GetSupportedNpadIdTypes(u32* data, std::size_t max_length);
+    void GetSupportedNpadIdTypes(u32* data, std::size_t max_length);
     std::size_t GetSupportedNPadIdTypesSize() const;
 
     void SetHoldType(NpadHoldType joy_hold_type);
@@ -277,12 +278,12 @@ private:
     std::vector<u32> supported_npad_id_types{};
     NpadHoldType hold_type{NpadHoldType::Vertical};
     Kernel::SharedPtr<Kernel::Event> styleset_changed_event;
-    std::size_t dump_idx{};
     Vibration last_processed_vibration{};
-    static constexpr std::array<u32, 10> npad_id_list{0, 1, 2, 3, 4, 5, 6, 7, 32, 16};
     std::array<ControllerHolder, 10> connected_controllers{};
     bool can_controllers_vibrate{true};
 
     void InitNewlyAddedControler(std::size_t controller_idx);
+    bool IsControllerSupported(NPadControllerType controller) const;
+    NPadControllerType DecideBestController(NPadControllerType priority) const;
 };
 } // namespace Service::HID

src/core/hle/service/hid/controllers/stubbed.cpp

@@ -4,13 +4,13 @@
 
 #include <cstring>
 #include "common/common_types.h"
-#include "common/swap.h"
 #include "core/core_timing.h"
 #include "core/hle/service/hid/controllers/stubbed.h"
 
 namespace Service::HID {
 
 Controller_Stubbed::Controller_Stubbed() = default;
+Controller_Stubbed::~Controller_Stubbed() = default;
 
 void Controller_Stubbed::OnInit() {}
 

src/core/hle/service/hid/controllers/stubbed.h

@@ -11,6 +11,7 @@ namespace Service::HID {
 class Controller_Stubbed final : public ControllerBase {
 public:
     Controller_Stubbed();
+    ~Controller_Stubbed() override;
 
     // Called when the controller is initialized
     void OnInit() override;

src/core/hle/service/hid/controllers/touchscreen.cpp

@@ -4,7 +4,6 @@
 
 #include <cstring>
 #include "common/common_types.h"
-#include "common/swap.h"
 #include "core/core_timing.h"
 #include "core/frontend/emu_window.h"
 #include "core/frontend/input.h"
@@ -15,6 +14,7 @@ namespace Service::HID {
 constexpr std::size_t SHARED_MEMORY_OFFSET = 0x400;
 
 Controller_Touchscreen::Controller_Touchscreen() = default;
+Controller_Touchscreen::~Controller_Touchscreen() = default;
 
 void Controller_Touchscreen::OnInit() {}
 

src/core/hle/service/hid/controllers/touchscreen.h

@@ -14,6 +14,7 @@ namespace Service::HID {
 class Controller_Touchscreen final : public ControllerBase {
 public:
     Controller_Touchscreen();
+    ~Controller_Touchscreen() override;
 
     // Called when the controller is initialized
     void OnInit() override;

src/core/hle/service/hid/controllers/xpad.cpp

@@ -4,7 +4,6 @@
 
 #include <cstring>
 #include "common/common_types.h"
-#include "common/swap.h"
 #include "core/core_timing.h"
 #include "core/hle/service/hid/controllers/xpad.h"
 
@@ -12,6 +11,7 @@ namespace Service::HID {
 constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3C00;
 
 Controller_XPad::Controller_XPad() = default;
+Controller_XPad::~Controller_XPad() = default;
 
 void Controller_XPad::OnInit() {}
 

src/core/hle/service/hid/controllers/xpad.h

@@ -7,13 +7,13 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
-#include "core/frontend/input.h"
 #include "core/hle/service/hid/controllers/controller_base.h"
 
 namespace Service::HID {
 class Controller_XPad final : public ControllerBase {
 public:
     Controller_XPad();
+    ~Controller_XPad() override;
 
     // Called when the controller is initialized
     void OnInit() override;

src/core/hle/service/hid/hid.cpp

@@ -177,6 +177,7 @@ public:
             {11, &Hid::ActivateTouchScreen, "ActivateTouchScreen"},
             {21, &Hid::ActivateMouse, "ActivateMouse"},
             {31, &Hid::ActivateKeyboard, "ActivateKeyboard"},
+            {32, nullptr, "SendKeyboardLockKeyEvent"},
             {40, nullptr, "AcquireXpadIdEventHandle"},
             {41, nullptr, "ReleaseXpadIdEventHandle"},
             {51, &Hid::ActivateXpad, "ActivateXpad"},
@@ -207,6 +208,7 @@ public:
             {80, nullptr, "GetGyroscopeZeroDriftMode"},
             {81, nullptr, "ResetGyroscopeZeroDriftMode"},
             {82, &Hid::IsSixAxisSensorAtRest, "IsSixAxisSensorAtRest"},
+            {83, nullptr, "IsFirmwareUpdateAvailableForSixAxisSensor"},
             {91, &Hid::ActivateGesture, "ActivateGesture"},
             {100, &Hid::SetSupportedNpadStyleSet, "SetSupportedNpadStyleSet"},
             {101, &Hid::GetSupportedNpadStyleSet, "GetSupportedNpadStyleSet"},
@@ -252,6 +254,7 @@ public:
             {307, nullptr, "FinalizeSevenSixAxisSensor"},
             {308, nullptr, "SetSevenSixAxisSensorFusionStrength"},
             {309, nullptr, "GetSevenSixAxisSensorFusionStrength"},
+            {310, nullptr, "ResetSevenSixAxisSensorTimestamp"},
             {400, nullptr, "IsUsbFullKeyControllerEnabled"},
             {401, nullptr, "EnableUsbFullKeyController"},
             {402, nullptr, "IsUsbFullKeyControllerConnected"},
@@ -267,12 +270,24 @@ public:
             {505, nullptr, "SetPalmaFrModeType"},
             {506, nullptr, "ReadPalmaStep"},
             {507, nullptr, "EnablePalmaStep"},
-            {508, nullptr, "SuspendPalmaStep"},
-            {509, nullptr, "ResetPalmaStep"},
-            {510, nullptr, "ReadPalmaApplicationSection"},
-            {511, nullptr, "WritePalmaApplicationSection"},
-            {512, nullptr, "ReadPalmaUniqueCode"},
-            {513, nullptr, "SetPalmaUniqueCodeInvalid"},
+            {508, nullptr, "ResetPalmaStep"},
+            {509, nullptr, "ReadPalmaApplicationSection"},
+            {510, nullptr, "WritePalmaApplicationSection"},
+            {511, nullptr, "ReadPalmaUniqueCode"},
+            {512, nullptr, "SetPalmaUniqueCodeInvalid"},
+            {513, nullptr, "WritePalmaActivityEntry"},
+            {514, nullptr, "WritePalmaRgbLedPatternEntry"},
+            {515, nullptr, "WritePalmaWaveEntry"},
+            {516, nullptr, "SetPalmaDataBaseIdentificationVersion"},
+            {517, nullptr, "GetPalmaDataBaseIdentificationVersion"},
+            {518, nullptr, "SuspendPalmaFeature"},
+            {519, nullptr, "GetPalmaOperationResult"},
+            {520, nullptr, "ReadPalmaPlayLog"},
+            {521, nullptr, "ResetPalmaPlayLog"},
+            {522, nullptr, "SetIsPalmaAllConnectable"},
+            {523, nullptr, "SetIsPalmaPairedConnectable"},
+            {524, nullptr, "PairPalma"},
+            {525, nullptr, "SetPalmaBoostMode"},
             {1000, nullptr, "SetNpadCommunicationMode"},
             {1001, nullptr, "GetNpadCommunicationMode"},
         };
@@ -620,6 +635,7 @@ public:
             {140, nullptr, "DeactivateConsoleSixAxisSensor"},
             {141, nullptr, "GetConsoleSixAxisSensorSamplingFrequency"},
             {142, nullptr, "DeactivateSevenSixAxisSensor"},
+            {143, nullptr, "GetConsoleSixAxisSensorCountStates"},
             {201, nullptr, "ActivateFirmwareUpdate"},
             {202, nullptr, "DeactivateFirmwareUpdate"},
             {203, nullptr, "StartFirmwareUpdate"},
@@ -630,12 +646,23 @@ public:
             {208, nullptr, "StartFirmwareUpdateForRevert"},
             {209, nullptr, "GetAvailableFirmwareVersionForRevert"},
             {210, nullptr, "IsFirmwareUpdatingDevice"},
+            {211, nullptr, "StartFirmwareUpdateIndividual"},
+            {215, nullptr, "SetUsbFirmwareForceUpdateEnabled"},
+            {216, nullptr, "SetAllKuinaDevicesToFirmwareUpdateMode"},
             {221, nullptr, "UpdateControllerColor"},
             {222, nullptr, "ConnectUsbPadsAsync"},
             {223, nullptr, "DisconnectUsbPadsAsync"},
             {224, nullptr, "UpdateDesignInfo"},
             {225, nullptr, "GetUniquePadDriverState"},
             {226, nullptr, "GetSixAxisSensorDriverStates"},
+            {227, nullptr, "GetRxPacketHistory"},
+            {228, nullptr, "AcquireOperationEventHandle"},
+            {229, nullptr, "ReadSerialFlash"},
+            {230, nullptr, "WriteSerialFlash"},
+            {231, nullptr, "GetOperationResult"},
+            {232, nullptr, "EnableShipmentMode"},
+            {233, nullptr, "ClearPairingInfo"},
+            {234, nullptr, "GetUniquePadDeviceTypeSetInternal"},
             {301, nullptr, "GetAbstractedPadHandles"},
             {302, nullptr, "GetAbstractedPadState"},
             {303, nullptr, "GetAbstractedPadsState"},
@@ -643,6 +670,8 @@ public:
             {322, nullptr, "UnsetAutoPilotVirtualPadState"},
             {323, nullptr, "UnsetAllAutoPilotVirtualPadState"},
             {350, nullptr, "AddRegisteredDevice"},
+            {400, nullptr, "DisableExternalMcuOnNxDevice"},
+            {401, nullptr, "DisableRailDeviceFiltering"},
         };
         // clang-format on
 
@@ -678,7 +707,9 @@ public:
             {307, nullptr, "GetNpadSystemExtStyle"},
             {308, nullptr, "ApplyNpadSystemCommonPolicyFull"},
             {309, nullptr, "GetNpadFullKeyGripColor"},
+            {310, nullptr, "GetMaskedSupportedNpadStyleSet"},
             {311, nullptr, "SetNpadPlayerLedBlinkingDevice"},
+            {312, nullptr, "SetSupportedNpadStyleSetAll"},
             {321, nullptr, "GetUniquePadsFromNpad"},
             {322, nullptr, "GetIrSensorState"},
             {323, nullptr, "GetXcdHandleForNpadWithIrSensor"},
@@ -703,6 +734,7 @@ public:
             {546, nullptr, "AcquireDeviceRegisteredEventForControllerSupport"},
             {547, nullptr, "GetAllowedBluetoothLinksCount"},
             {548, nullptr, "GetRegisteredDevices"},
+            {549, nullptr, "GetConnectableRegisteredDevices"},
             {700, nullptr, "ActivateUniquePad"},
             {702, nullptr, "AcquireUniquePadConnectionEventHandle"},
             {703, nullptr, "GetUniquePadIds"},
@@ -731,6 +763,7 @@ public:
             {850, nullptr, "IsUsbFullKeyControllerEnabled"},
             {851, nullptr, "EnableUsbFullKeyController"},
             {852, nullptr, "IsUsbConnected"},
+            {870, nullptr, "IsHandheldButtonPressedOnConsoleMode"},
             {900, nullptr, "ActivateInputDetector"},
             {901, nullptr, "NotifyInputDetector"},
             {1000, nullptr, "InitializeFirmwareUpdate"},
@@ -750,6 +783,12 @@ public:
             {1052, nullptr, "CancelSixAxisSensorAccurateUserCalibration"},
             {1053, nullptr, "GetSixAxisSensorAccurateUserCalibrationState"},
             {1100, nullptr, "GetHidbusSystemServiceObject"},
+            {1120, nullptr, "SetFirmwareHotfixUpdateSkipEnabled"},
+            {1130, nullptr, "InitializeUsbFirmwareUpdate"},
+            {1131, nullptr, "FinalizeUsbFirmwareUpdate"},
+            {1132, nullptr, "CheckUsbFirmwareUpdateRequired"},
+            {1133, nullptr, "StartUsbFirmwareUpdate"},
+            {1134, nullptr, "GetUsbFirmwareUpdateState"},
         };
         // clang-format on
 
@@ -788,6 +827,7 @@ public:
             {11, nullptr, "EnableJoyPollingReceiveMode"},
             {12, nullptr, "DisableJoyPollingReceiveMode"},
             {13, nullptr, "GetPollingData"},
+            {14, nullptr, "SetStatusManagerType"},
         };
         // clang-format on
 

src/core/hle/service/lbl/lbl.cpp

@@ -18,35 +18,35 @@ public:
     explicit LBL() : ServiceFramework{"lbl"} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {0, nullptr, "Unknown1"},
-            {1, nullptr, "Unknown2"},
-            {2, nullptr, "Unknown3"},
-            {3, nullptr, "GetCurrentBacklightLevel"},
-            {4, nullptr, "Unknown4"},
-            {5, nullptr, "GetAlsComputedBacklightLevel"},
-            {6, nullptr, "TurnOffBacklight"},
-            {7, nullptr, "TurnOnBacklight"},
-            {8, nullptr, "GetBacklightStatus"},
-            {9, nullptr, "Unknown5"},
-            {10, nullptr, "Unknown6"},
-            {11, nullptr, "Unknown7"},
-            {12, nullptr, "Unknown8"},
-            {13, nullptr, "Unknown9"},
-            {14, nullptr, "Unknown10"},
-            {15, nullptr, "GetAutoBrightnessSetting"},
-            {16, nullptr, "ReadRawLightSensor"},
-            {17, nullptr, "Unknown11"},
-            {18, nullptr, "Unknown12"},
-            {19, nullptr, "Unknown13"},
-            {20, nullptr, "Unknown14"},
-            {21, nullptr, "Unknown15"},
-            {22, nullptr, "Unknown16"},
-            {23, nullptr, "Unknown17"},
-            {24, nullptr, "Unknown18"},
-            {25, nullptr, "Unknown19"},
+            {0, nullptr, "SaveCurrentSetting"},
+            {1, nullptr, "LoadCurrentSetting"},
+            {2, nullptr, "SetCurrentBrightnessSetting"},
+            {3, nullptr, "GetCurrentBrightnessSetting"},
+            {4, nullptr, "ApplyCurrentBrightnessSettingToBacklight"},
+            {5, nullptr, "GetBrightnessSettingAppliedToBacklight"},
+            {6, nullptr, "SwitchBacklightOn"},
+            {7, nullptr, "SwitchBacklightOff"},
+            {8, nullptr, "GetBacklightSwitchStatus"},
+            {9, nullptr, "EnableDimming"},
+            {10, nullptr, "DisableDimming"},
+            {11, nullptr, "IsDimmingEnabled"},
+            {12, nullptr, "EnableAutoBrightnessControl"},
+            {13, nullptr, "DisableAutoBrightnessControl"},
+            {14, nullptr, "IsAutoBrightnessControlEnabled"},
+            {15, nullptr, "SetAmbientLightSensorValue"},
+            {16, nullptr, "GetAmbientLightSensorValue"},
+            {17, nullptr, "SetBrightnessReflectionDelayLevel"},
+            {18, nullptr, "GetBrightnessReflectionDelayLevel"},
+            {19, nullptr, "SetCurrentBrightnessMapping"},
+            {20, nullptr, "GetCurrentBrightnessMapping"},
+            {21, nullptr, "SetCurrentAmbientLightSensorMapping"},
+            {22, nullptr, "GetCurrentAmbientLightSensorMapping"},
+            {23, nullptr, "IsAmbientLightSensorAvailable"},
+            {24, nullptr, "SetCurrentBrightnessSettingForVrMode"},
+            {25, nullptr, "GetCurrentBrightnessSettingForVrMode"},
             {26, &LBL::EnableVrMode, "EnableVrMode"},
             {27, &LBL::DisableVrMode, "DisableVrMode"},
-            {28, &LBL::GetVrMode, "GetVrMode"},
+            {28, &LBL::IsVrModeEnabled, "IsVrModeEnabled"},
         };
         // clang-format on
 
@@ -72,7 +72,7 @@ private:
         LOG_DEBUG(Service_LBL, "called");
     }
 
-    void GetVrMode(Kernel::HLERequestContext& ctx) {
+    void IsVrModeEnabled(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
         rb.Push(vr_mode_enabled);

src/core/hle/service/nifm/nifm.cpp

@@ -219,6 +219,7 @@ IGeneralService::IGeneralService() : ServiceFramework("IGeneralService") {
         {35, nullptr, "GetScanData"},
         {36, nullptr, "GetCurrentAccessPoint"},
         {37, nullptr, "Shutdown"},
+        {38, nullptr, "GetAllowedChannels"},
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/nim/nim.cpp

@@ -71,6 +71,22 @@ public:
     }
 };
 
+class NIM_ECA final : public ServiceFramework<NIM_ECA> {
+public:
+    explicit NIM_ECA() : ServiceFramework{"nim:eca"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "CreateServerInterface"},
+            {1, nullptr, "RefreshDebugAvailability"},
+            {2, nullptr, "ClearDebugResponse"},
+            {3, nullptr, "RegisterDebugResponse"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
 class NIM_SHP final : public ServiceFramework<NIM_SHP> {
 public:
     explicit NIM_SHP() : ServiceFramework{"nim:shp"} {
@@ -214,6 +230,7 @@ private:
 
 void InstallInterfaces(SM::ServiceManager& sm) {
     std::make_shared<NIM>()->InstallAsService(sm);
+    std::make_shared<NIM_ECA>()->InstallAsService(sm);
     std::make_shared<NIM_SHP>()->InstallAsService(sm);
     std::make_shared<NTC>()->InstallAsService(sm);
 }

src/core/hle/service/npns/npns.cpp

@@ -0,0 +1,88 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <memory>
+
+#include "core/hle/service/npns/npns.h"
+#include "core/hle/service/service.h"
+#include "core/hle/service/sm/sm.h"
+
+namespace Service::NPNS {
+
+class NPNS_S final : public ServiceFramework<NPNS_S> {
+public:
+    explicit NPNS_S() : ServiceFramework{"npns:s"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {1, nullptr, "ListenAll"},
+            {2, nullptr, "ListenTo"},
+            {3, nullptr, "Receive"},
+            {4, nullptr, "ReceiveRaw"},
+            {5, nullptr, "GetReceiveEvent"},
+            {6, nullptr, "ListenUndelivered"},
+            {7, nullptr, "GetStateChangeEVent"},
+            {11, nullptr, "SubscribeTopic"},
+            {12, nullptr, "UnsubscribeTopic"},
+            {13, nullptr, "QueryIsTopicExist"},
+            {21, nullptr, "CreateToken"},
+            {22, nullptr, "CreateTokenWithApplicationId"},
+            {23, nullptr, "DestroyToken"},
+            {24, nullptr, "DestroyTokenWithApplicationId"},
+            {25, nullptr, "QueryIsTokenValid"},
+            {31, nullptr, "UploadTokenToBaaS"},
+            {32, nullptr, "DestroyTokenForBaaS"},
+            {33, nullptr, "CreateTokenForBaaS"},
+            {34, nullptr, "SetBaaSDeviceAccountIdList"},
+            {101, nullptr, "Suspend"},
+            {102, nullptr, "Resume"},
+            {103, nullptr, "GetState"},
+            {104, nullptr, "GetStatistics"},
+            {105, nullptr, "GetPlayReportRequestEvent"},
+            {111, nullptr, "GetJid"},
+            {112, nullptr, "CreateJid"},
+            {113, nullptr, "DestroyJid"},
+            {114, nullptr, "AttachJid"},
+            {115, nullptr, "DetachJid"},
+            {201, nullptr, "RequestChangeStateForceTimed"},
+            {102, nullptr, "RequestChangeStateForceAsync"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class NPNS_U final : public ServiceFramework<NPNS_U> {
+public:
+    explicit NPNS_U() : ServiceFramework{"npns:u"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {1, nullptr, "ListenAll"},
+            {2, nullptr, "ListenTo"},
+            {3, nullptr, "Receive"},
+            {4, nullptr, "ReceiveRaw"},
+            {5, nullptr, "GetReceiveEvent"},
+            {7, nullptr, "GetStateChangeEVent"},
+            {21, nullptr, "CreateToken"},
+            {23, nullptr, "DestroyToken"},
+            {25, nullptr, "QueryIsTokenValid"},
+            {26, nullptr, "ListenToMyApplicationId"},
+            {101, nullptr, "Suspend"},
+            {102, nullptr, "Resume"},
+            {103, nullptr, "GetState"},
+            {104, nullptr, "GetStatistics"},
+            {111, nullptr, "GetJid"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+void InstallInterfaces(SM::ServiceManager& sm) {
+    std::make_shared<NPNS_S>()->InstallAsService(sm);
+    std::make_shared<NPNS_U>()->InstallAsService(sm);
+}
+
+} // namespace Service::NPNS

src/core/hle/service/npns/npns.h

@@ -0,0 +1,15 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+namespace Service::SM {
+class ServiceManager;
+}
+
+namespace Service::NPNS {
+
+void InstallInterfaces(SM::ServiceManager& sm);
+
+} // namespace Service::NPNS

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

@@ -93,13 +93,23 @@ public:
             {86, nullptr, "EnableApplicationCrashReport"},
             {87, nullptr, "IsApplicationCrashReportEnabled"},
             {90, nullptr, "BoostSystemMemoryResourceLimit"},
+            {91, nullptr, "Unknown1"},
+            {92, nullptr, "Unknown2"},
+            {93, nullptr, "GetMainApplicationProgramIndex"},
+            {94, nullptr, "LaunchApplication2"},
+            {95, nullptr, "GetApplicationLaunchInfo"},
+            {96, nullptr, "AcquireApplicationLaunchInfo"},
+            {97, nullptr, "GetMainApplicationProgramIndex2"},
+            {98, nullptr, "EnableApplicationAllThreadDumpOnCrash"},
             {100, nullptr, "ResetToFactorySettings"},
             {101, nullptr, "ResetToFactorySettingsWithoutUserSaveData"},
             {102, nullptr, "ResetToFactorySettingsForRefurbishment"},
             {200, nullptr, "CalculateUserSaveDataStatistics"},
             {201, nullptr, "DeleteUserSaveDataAll"},
             {210, nullptr, "DeleteUserSystemSaveData"},
+            {211, nullptr, "DeleteSaveData"},
             {220, nullptr, "UnregisterNetworkServiceAccount"},
+            {221, nullptr, "UnregisterNetworkServiceAccountWithUserSaveDataDeletion"},
             {300, nullptr, "GetApplicationShellEvent"},
             {301, nullptr, "PopApplicationShellEventInfo"},
             {302, nullptr, "LaunchLibraryApplet"},
@@ -114,6 +124,7 @@ public:
             {403, nullptr, "GetMaxApplicationControlCacheCount"},
             {404, nullptr, "InvalidateApplicationControlCache"},
             {405, nullptr, "ListApplicationControlCacheEntryInfo"},
+            {406, nullptr, "GetApplicationControlProperty"},
             {502, nullptr, "RequestCheckGameCardRegistration"},
             {503, nullptr, "RequestGameCardRegistrationGoldPoint"},
             {504, nullptr, "RequestRegisterGameCard"},
@@ -129,6 +140,7 @@ public:
             {604, nullptr, "RegisterContentsExternalKey"},
             {605, nullptr, "ListApplicationContentMetaStatusWithRightsCheck"},
             {606, nullptr, "GetContentMetaStorage"},
+            {607, nullptr, "ListAvailableAddOnContent"},
             {700, nullptr, "PushDownloadTaskList"},
             {701, nullptr, "ClearTaskStatusList"},
             {702, nullptr, "RequestDownloadTaskList"},
@@ -148,6 +160,9 @@ public:
             {907, nullptr, "WithdrawApplicationUpdateRequest"},
             {908, nullptr, "ListApplicationRecordInstalledContentMeta"},
             {909, nullptr, "WithdrawCleanupAddOnContentsWithNoRightsRecommendation"},
+            {910, nullptr, "Unknown3"},
+            {911, nullptr, "SetPreInstalledApplication"},
+            {912, nullptr, "ClearPreInstalledApplicationFlag"},
             {1000, nullptr, "RequestVerifyApplicationDeprecated"},
             {1001, nullptr, "CorruptApplicationForDebug"},
             {1002, nullptr, "RequestVerifyAddOnContentsRights"},
@@ -162,6 +177,8 @@ public:
             {1305, nullptr, "TryDeleteRunningApplicationEntity"},
             {1306, nullptr, "TryDeleteRunningApplicationCompletely"},
             {1307, nullptr, "TryDeleteRunningApplicationContentEntities"},
+            {1308, nullptr, "DeleteApplicationCompletelyForDebug"},
+            {1309, nullptr, "CleanupUnavailableAddOnContents"},
             {1400, nullptr, "PrepareShutdown"},
             {1500, nullptr, "FormatSdCard"},
             {1501, nullptr, "NeedsSystemUpdateToFormatSdCard"},
@@ -199,6 +216,28 @@ public:
             {2015, nullptr, "CompareSystemDeliveryInfo"},
             {2016, nullptr, "ListNotCommittedContentMeta"},
             {2017, nullptr, "CreateDownloadTask"},
+            {2018, nullptr, "Unknown4"},
+            {2050, nullptr, "Unknown5"},
+            {2100, nullptr, "Unknown6"},
+            {2101, nullptr, "Unknown7"},
+            {2150, nullptr, "CreateRightsEnvironment"},
+            {2151, nullptr, "DestroyRightsEnvironment"},
+            {2152, nullptr, "ActivateRightsEnvironment"},
+            {2153, nullptr, "DeactivateRightsEnvironment"},
+            {2154, nullptr, "ForceActivateRightsContextForExit"},
+            {2160, nullptr, "AddTargetApplicationToRightsEnvironment"},
+            {2161, nullptr, "SetUsersToRightsEnvironment"},
+            {2170, nullptr, "GetRightsEnvironmentStatus"},
+            {2171, nullptr, "GetRightsEnvironmentStatusChangedEvent"},
+            {2180, nullptr, "RequestExtendRightsInRightsEnvironment"},
+            {2181, nullptr, "GetLastResultOfExtendRightsInRightsEnvironment"},
+            {2182, nullptr, "SetActiveRightsContextUsingStateToRightsEnvironment"},
+            {2190, nullptr, "GetRightsEnvironmentHandleForApplication"},
+            {2199, nullptr, "GetRightsEnvironmentCountForDebug"},
+            {2200, nullptr, "Unknown8"},
+            {2201, nullptr, "Unknown9"},
+            {2250, nullptr, "Unknown10"},
+            {2300, nullptr, "Unknown11"},
         };
         // clang-format on
 
@@ -348,12 +387,15 @@ public:
             {0, nullptr, "LaunchProgram"},
             {1, nullptr, "TerminateProcess"},
             {2, nullptr, "TerminateProgram"},
-            {3, nullptr, "GetShellEventHandle"},
-            {4, nullptr, "GetShellEventInfo"},
-            {5, nullptr, "TerminateApplication"},
-            {6, nullptr, "PrepareLaunchProgramFromHost"},
-            {7, nullptr, "LaunchApplication"},
-            {8, nullptr, "LaunchApplicationWithStorageId"},
+            {4, nullptr, "GetShellEventHandle"},
+            {5, nullptr, "GetShellEventInfo"},
+            {6, nullptr, "TerminateApplication"},
+            {7, nullptr, "PrepareLaunchProgramFromHost"},
+            {8, nullptr, "LaunchApplication"},
+            {9, nullptr, "LaunchApplicationWithStorageId"},
+            {10, nullptr, "TerminateApplication2"},
+            {11, nullptr, "GetRunningApplicationProcessId"},
+            {12, nullptr, "SetCurrentApplicationRightsEnvironmentCanBeActive"},
         };
         // clang-format on
 
@@ -388,6 +430,7 @@ public:
             {19, nullptr, "GetReceivedEulaDataSize"},
             {20, nullptr, "GetReceivedEulaData"},
             {21, nullptr, "SetupToReceiveSystemUpdate"},
+            {22, nullptr, "RequestCheckLatestUpdateIncludesRebootlessUpdate"},
         };
         // clang-format on
 

src/core/hle/service/prepo/prepo.cpp

@@ -14,20 +14,24 @@ public:
     explicit PlayReport(const char* name) : ServiceFramework{name} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {10100, nullptr, "SaveReport"},
-            {10101, &PlayReport::SaveReportWithUser, "SaveReportWithUser"},
+            {10100, nullptr, "SaveReportOld"},
+            {10101, &PlayReport::SaveReportWithUserOld, "SaveReportWithUserOld"},
+            {10102, nullptr, "SaveReport"},
+            {10103, nullptr, "SaveReportWithUser"},
             {10200, nullptr, "RequestImmediateTransmission"},
             {10300, nullptr, "GetTransmissionStatus"},
             {20100, nullptr, "SaveSystemReport"},
-            {20200, nullptr, "SetOperationMode"},
             {20101, nullptr, "SaveSystemReportWithUser"},
+            {20200, nullptr, "SetOperationMode"},
             {30100, nullptr, "ClearStorage"},
+            {30200, nullptr, "ClearStatistics"},
+            {30300, nullptr, "GetStorageUsage"},
+            {30400, nullptr, "GetStatistics"},
+            {30401, nullptr, "GetThroughputHistory"},
+            {30500, nullptr, "GetLastUploadError"},
             {40100, nullptr, "IsUserAgreementCheckEnabled"},
             {40101, nullptr, "SetUserAgreementCheckEnabled"},
-            {90100, nullptr, "GetStorageUsage"},
-            {90200, nullptr, "GetStatistics"},
-            {90201, nullptr, "GetThroughputHistory"},
-            {90300, nullptr, "GetLastUploadError"},
+            {90100, nullptr, "ReadAllReportFiles"},
         };
         // clang-format on
 
@@ -35,7 +39,7 @@ public:
     }
 
 private:
-    void SaveReportWithUser(Kernel::HLERequestContext& ctx) {
+    void SaveReportWithUserOld(Kernel::HLERequestContext& ctx) {
         // TODO(ogniK): Do we want to add play report?
         LOG_WARNING(Service_PREPO, "(STUBBED) called");
 
@@ -46,6 +50,7 @@ private:
 
 void InstallInterfaces(SM::ServiceManager& service_manager) {
     std::make_shared<PlayReport>("prepo:a")->InstallAsService(service_manager);
+    std::make_shared<PlayReport>("prepo:a2")->InstallAsService(service_manager);
     std::make_shared<PlayReport>("prepo:m")->InstallAsService(service_manager);
     std::make_shared<PlayReport>("prepo:s")->InstallAsService(service_manager);
     std::make_shared<PlayReport>("prepo:u")->InstallAsService(service_manager);

src/core/hle/service/service.cpp

@@ -22,7 +22,7 @@
 #include "core/hle/service/apm/apm.h"
 #include "core/hle/service/arp/arp.h"
 #include "core/hle/service/audio/audio.h"
-#include "core/hle/service/bcat/bcat.h"
+#include "core/hle/service/bcat/module.h"
 #include "core/hle/service/bpc/bpc.h"
 #include "core/hle/service/btdrv/btdrv.h"
 #include "core/hle/service/btm/btm.h"
@@ -48,11 +48,12 @@
 #include "core/hle/service/nfp/nfp.h"
 #include "core/hle/service/nifm/nifm.h"
 #include "core/hle/service/nim/nim.h"
+#include "core/hle/service/npns/npns.h"
 #include "core/hle/service/ns/ns.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
 #include "core/hle/service/nvflinger/nvflinger.h"
 #include "core/hle/service/pcie/pcie.h"
-#include "core/hle/service/pctl/pctl.h"
+#include "core/hle/service/pctl/module.h"
 #include "core/hle/service/pcv/pcv.h"
 #include "core/hle/service/pm/pm.h"
 #include "core/hle/service/prepo/prepo.h"
@@ -236,6 +237,7 @@ void Init(std::shared_ptr<SM::ServiceManager>& sm, FileSys::VfsFilesystem& vfs)
     NFP::InstallInterfaces(*sm);
     NIFM::InstallInterfaces(*sm);
     NIM::InstallInterfaces(*sm);
+    NPNS::InstallInterfaces(*sm);
     NS::InstallInterfaces(*sm);
     Nvidia::InstallInterfaces(*sm, *nv_flinger);
     PCIe::InstallInterfaces(*sm);

src/core/hle/service/set/set_cal.cpp

@@ -39,7 +39,8 @@ SET_CAL::SET_CAL() : ServiceFramework("set:cal") {
         {29, nullptr, "GetAmiiboEcqvBlsKey"},
         {30, nullptr, "GetAmiiboEcqvBlsCertificate"},
         {31, nullptr, "GetAmiiboEcqvBlsRootCertificate"},
-        {32, nullptr, "GetUnknownId"},
+        {32, nullptr, "GetUsbTypeCPowerSourceCircuitVersion"},
+        {33, nullptr, "GetBatteryVersion"},
     };
     RegisterHandlers(functions);
 }

src/video_core/engines/fermi_2d.cpp

@@ -47,9 +47,12 @@ void Fermi2D::HandleSurfaceCopy() {
     u32 dst_bytes_per_pixel = RenderTargetBytesPerPixel(regs.dst.format);
 
     if (!rasterizer.AccelerateSurfaceCopy(regs.src, regs.dst)) {
-        // TODO(bunnei): The below implementation currently will not get hit, as
-        // AccelerateSurfaceCopy tries to always copy and will always return success. This should be
-        // changed once we properly support flushing.
+        rasterizer.FlushRegion(source_cpu, src_bytes_per_pixel * regs.src.width * regs.src.height);
+        // We have to invalidate the destination region to evict any outdated surfaces from the
+        // cache. We do this before actually writing the new data because the destination address
+        // might contain a dirty surface that will have to be written back to memory.
+        rasterizer.InvalidateRegion(dest_cpu,
+                                    dst_bytes_per_pixel * regs.dst.width * regs.dst.height);
 
         if (regs.src.linear == regs.dst.linear) {
             // If the input layout and the output layout are the same, just perform a raw copy.

src/video_core/engines/kepler_memory.cpp

@@ -5,10 +5,14 @@
 #include "common/logging/log.h"
 #include "core/memory.h"
 #include "video_core/engines/kepler_memory.h"
+#include "video_core/rasterizer_interface.h"
 
 namespace Tegra::Engines {
 
-KeplerMemory::KeplerMemory(MemoryManager& memory_manager) : memory_manager(memory_manager) {}
+KeplerMemory::KeplerMemory(VideoCore::RasterizerInterface& rasterizer,
+                           MemoryManager& memory_manager)
+    : memory_manager(memory_manager), rasterizer{rasterizer} {}
+
 KeplerMemory::~KeplerMemory() = default;
 
 void KeplerMemory::WriteReg(u32 method, u32 value) {
@@ -37,6 +41,11 @@ void KeplerMemory::ProcessData(u32 data) {
     VAddr dest_address =
         *memory_manager.GpuToCpuAddress(address + state.write_offset * sizeof(u32));
 
+    // We have to invalidate the destination region to evict any outdated surfaces from the cache.
+    // We do this before actually writing the new data because the destination address might contain
+    // a dirty surface that will have to be written back to memory.
+    rasterizer.InvalidateRegion(dest_address, sizeof(u32));
+
     Memory::Write32(dest_address, data);
 
     state.write_offset++;

src/video_core/engines/kepler_memory.h

@@ -11,6 +11,10 @@
 #include "common/common_types.h"
 #include "video_core/memory_manager.h"
 
+namespace VideoCore {
+class RasterizerInterface;
+}
+
 namespace Tegra::Engines {
 
 #define KEPLERMEMORY_REG_INDEX(field_name)                                                         \
@@ -18,7 +22,7 @@ namespace Tegra::Engines {
 
 class KeplerMemory final {
 public:
-    KeplerMemory(MemoryManager& memory_manager);
+    KeplerMemory(VideoCore::RasterizerInterface& rasterizer, MemoryManager& memory_manager);
     ~KeplerMemory();
 
     /// Write the value to the register identified by method.
@@ -72,6 +76,7 @@ public:
 
 private:
     MemoryManager& memory_manager;
+    VideoCore::RasterizerInterface& rasterizer;
 
     void ProcessData(u32 data);
 };

src/video_core/engines/maxwell_dma.cpp

@@ -4,12 +4,14 @@
 
 #include "core/memory.h"
 #include "video_core/engines/maxwell_dma.h"
+#include "video_core/rasterizer_interface.h"
 #include "video_core/textures/decoders.h"
 
 namespace Tegra {
 namespace Engines {
 
-MaxwellDMA::MaxwellDMA(MemoryManager& memory_manager) : memory_manager(memory_manager) {}
+MaxwellDMA::MaxwellDMA(VideoCore::RasterizerInterface& rasterizer, MemoryManager& memory_manager)
+    : memory_manager(memory_manager), rasterizer{rasterizer} {}
 
 void MaxwellDMA::WriteReg(u32 method, u32 value) {
     ASSERT_MSG(method < Regs::NUM_REGS,
@@ -44,38 +46,79 @@ void MaxwellDMA::HandleCopy() {
     ASSERT(regs.exec.query_mode == Regs::QueryMode::None);
     ASSERT(regs.exec.query_intr == Regs::QueryIntr::None);
     ASSERT(regs.exec.copy_mode == Regs::CopyMode::Unk2);
-    ASSERT(regs.src_params.pos_x == 0);
-    ASSERT(regs.src_params.pos_y == 0);
     ASSERT(regs.dst_params.pos_x == 0);
     ASSERT(regs.dst_params.pos_y == 0);
 
-    if (regs.exec.is_dst_linear == regs.exec.is_src_linear) {
-        std::size_t copy_size = regs.x_count;
+    if (!regs.exec.is_dst_linear && !regs.exec.is_src_linear) {
+        // If both the source and the destination are in block layout, assert.
+        UNREACHABLE_MSG("Tiled->Tiled DMA transfers are not yet implemented");
+        return;
+    }
 
+    if (regs.exec.is_dst_linear && regs.exec.is_src_linear) {
         // When the enable_2d bit is disabled, the copy is performed as if we were copying a 1D
-        // buffer of length `x_count`, otherwise we copy a 2D buffer of size (x_count, y_count).
-        if (regs.exec.enable_2d) {
-            copy_size = copy_size * regs.y_count;
+        // buffer of length `x_count`, otherwise we copy a 2D image of dimensions (x_count,
+        // y_count).
+        if (!regs.exec.enable_2d) {
+            Memory::CopyBlock(dest_cpu, source_cpu, regs.x_count);
+            return;
         }
 
-        Memory::CopyBlock(dest_cpu, source_cpu, copy_size);
+        // If both the source and the destination are in linear layout, perform a line-by-line
+        // copy. We're going to take a subrect of size (x_count, y_count) from the source
+        // rectangle. There is no need to manually flush/invalidate the regions because
+        // CopyBlock does that for us.
+        for (u32 line = 0; line < regs.y_count; ++line) {
+            const VAddr source_line = source_cpu + line * regs.src_pitch;
+            const VAddr dest_line = dest_cpu + line * regs.dst_pitch;
+            Memory::CopyBlock(dest_line, source_line, regs.x_count);
+        }
         return;
     }
 
     ASSERT(regs.exec.enable_2d == 1);
+
+    std::size_t copy_size = regs.x_count * regs.y_count;
+
+    const auto FlushAndInvalidate = [&](u32 src_size, u32 dst_size) {
+        // TODO(Subv): For now, manually flush the regions until we implement GPU-accelerated
+        // copying.
+        rasterizer.FlushRegion(source_cpu, src_size);
+
+        // We have to invalidate the destination region to evict any outdated surfaces from the
+        // cache. We do this before actually writing the new data because the destination address
+        // might contain a dirty surface that will have to be written back to memory.
+        rasterizer.InvalidateRegion(dest_cpu, dst_size);
+    };
+
     u8* src_buffer = Memory::GetPointer(source_cpu);
     u8* dst_buffer = Memory::GetPointer(dest_cpu);
 
     if (regs.exec.is_dst_linear && !regs.exec.is_src_linear) {
+        ASSERT(regs.src_params.size_z == 1);
         // If the input is tiled and the output is linear, deswizzle the input and copy it over.
-        Texture::CopySwizzledData(regs.src_params.size_x, regs.src_params.size_y,
-                                  regs.src_params.size_z, 1, 1, src_buffer, dst_buffer, true,
-                                  regs.src_params.BlockHeight(), regs.src_params.BlockDepth());
+
+        u32 src_bytes_per_pixel = regs.src_pitch / regs.src_params.size_x;
+
+        FlushAndInvalidate(regs.src_pitch * regs.src_params.size_y,
+                           copy_size * src_bytes_per_pixel);
+
+        Texture::UnswizzleSubrect(regs.x_count, regs.y_count, regs.dst_pitch,
+                                  regs.src_params.size_x, src_bytes_per_pixel, source_cpu, dest_cpu,
+                                  regs.src_params.BlockHeight(), regs.src_params.pos_x,
+                                  regs.src_params.pos_y);
     } else {
+        ASSERT(regs.dst_params.size_z == 1);
+        ASSERT(regs.src_pitch == regs.x_count);
+
+        u32 src_bpp = regs.src_pitch / regs.x_count;
+
+        FlushAndInvalidate(regs.src_pitch * regs.y_count,
+                           regs.dst_params.size_x * regs.dst_params.size_y * src_bpp);
+
         // If the input is linear and the output is tiled, swizzle the input and copy it over.
-        Texture::CopySwizzledData(regs.dst_params.size_x, regs.dst_params.size_y,
-                                  regs.dst_params.size_z, 1, 1, dst_buffer, src_buffer, false,
-                                  regs.dst_params.BlockHeight(), regs.dst_params.BlockDepth());
+        Texture::SwizzleSubrect(regs.x_count, regs.y_count, regs.src_pitch, regs.dst_params.size_x,
+                                src_bpp, dest_cpu, source_cpu, regs.dst_params.BlockHeight());
     }
 }
 

src/video_core/engines/maxwell_dma.h

@@ -12,11 +12,15 @@
 #include "video_core/gpu.h"
 #include "video_core/memory_manager.h"
 
+namespace VideoCore {
+class RasterizerInterface;
+}
+
 namespace Tegra::Engines {
 
 class MaxwellDMA final {
 public:
-    explicit MaxwellDMA(MemoryManager& memory_manager);
+    explicit MaxwellDMA(VideoCore::RasterizerInterface& rasterizer, MemoryManager& memory_manager);
     ~MaxwellDMA() = default;
 
     /// Write the value to the register identified by method.
@@ -133,6 +137,8 @@ public:
     MemoryManager& memory_manager;
 
 private:
+    VideoCore::RasterizerInterface& rasterizer;
+
     /// Performs the copy from the source buffer to the destination buffer as configured in the
     /// registers.
     void HandleCopy();

src/video_core/engines/shader_bytecode.h

@@ -335,6 +335,26 @@ enum class IsberdMode : u64 {
 
 enum class IsberdShift : u64 { None = 0, U16 = 1, B32 = 2 };
 
+enum class HalfType : u64 {
+    H0_H1 = 0,
+    F32 = 1,
+    H0_H0 = 2,
+    H1_H1 = 3,
+};
+
+enum class HalfMerge : u64 {
+    H0_H1 = 0,
+    F32 = 1,
+    Mrg_H0 = 2,
+    Mrg_H1 = 3,
+};
+
+enum class HalfPrecision : u64 {
+    None = 0,
+    FTZ = 1,
+    FMZ = 2,
+};
+
 enum class IpaInterpMode : u64 {
     Linear = 0,
     Perspective = 1,
@@ -543,6 +563,10 @@ union Instruction {
         BitField<48, 1, u64> negate_b;
     } fmul;
 
+    union {
+        BitField<55, 1, u64> saturate;
+    } fmul32;
+
     union {
         BitField<48, 1, u64> is_signed;
     } shift;
@@ -553,6 +577,70 @@ union Instruction {
         BitField<49, 1, u64> negate_a;
     } alu_integer;
 
+    union {
+        BitField<39, 1, u64> ftz;
+        BitField<32, 1, u64> saturate;
+        BitField<49, 2, HalfMerge> merge;
+
+        BitField<43, 1, u64> negate_a;
+        BitField<44, 1, u64> abs_a;
+        BitField<47, 2, HalfType> type_a;
+
+        BitField<31, 1, u64> negate_b;
+        BitField<30, 1, u64> abs_b;
+        BitField<47, 2, HalfType> type_b;
+
+        BitField<35, 2, HalfType> type_c;
+    } alu_half;
+
+    union {
+        BitField<39, 2, HalfPrecision> precision;
+        BitField<39, 1, u64> ftz;
+        BitField<52, 1, u64> saturate;
+        BitField<49, 2, HalfMerge> merge;
+
+        BitField<43, 1, u64> negate_a;
+        BitField<44, 1, u64> abs_a;
+        BitField<47, 2, HalfType> type_a;
+    } alu_half_imm;
+
+    union {
+        BitField<29, 1, u64> first_negate;
+        BitField<20, 9, u64> first;
+
+        BitField<56, 1, u64> second_negate;
+        BitField<30, 9, u64> second;
+
+        u32 PackImmediates() const {
+            // Immediates are half floats shifted.
+            constexpr u32 imm_shift = 6;
+            return static_cast<u32>((first << imm_shift) | (second << (16 + imm_shift)));
+        }
+    } half_imm;
+
+    union {
+        union {
+            BitField<37, 2, HalfPrecision> precision;
+            BitField<32, 1, u64> saturate;
+
+            BitField<30, 1, u64> negate_c;
+            BitField<35, 2, HalfType> type_c;
+        } rr;
+
+        BitField<57, 2, HalfPrecision> precision;
+        BitField<52, 1, u64> saturate;
+
+        BitField<49, 2, HalfMerge> merge;
+
+        BitField<47, 2, HalfType> type_a;
+
+        BitField<56, 1, u64> negate_b;
+        BitField<28, 2, HalfType> type_b;
+
+        BitField<51, 1, u64> negate_c;
+        BitField<53, 2, HalfType> type_reg39;
+    } hfma2;
+
     union {
         BitField<40, 1, u64> invert;
     } popc;
@@ -669,7 +757,6 @@ union Instruction {
         BitField<45, 2, PredOperation> op;
         BitField<47, 1, u64> ftz;
         BitField<48, 4, PredCondition> cond;
-        BitField<56, 1, u64> neg_b;
     } fsetp;
 
     union {
@@ -716,6 +803,23 @@ union Instruction {
         BitField<45, 4, PredOperation> op; // op with pred39
     } csetp;
 
+    union {
+        BitField<35, 4, PredCondition> cond;
+        BitField<49, 1, u64> h_and;
+        BitField<6, 1, u64> ftz;
+        BitField<45, 2, PredOperation> op;
+        BitField<3, 3, u64> pred3;
+        BitField<0, 3, u64> pred0;
+        BitField<43, 1, u64> negate_a;
+        BitField<44, 1, u64> abs_a;
+        BitField<47, 2, HalfType> type_a;
+        BitField<31, 1, u64> negate_b;
+        BitField<30, 1, u64> abs_b;
+        BitField<28, 2, HalfType> type_b;
+        BitField<42, 1, u64> neg_pred;
+        BitField<39, 3, u64> pred39;
+    } hsetp2;
+
     union {
         BitField<39, 3, u64> pred39;
         BitField<42, 1, u64> neg_pred;
@@ -727,9 +831,23 @@ union Instruction {
         BitField<53, 1, u64> neg_b;
         BitField<54, 1, u64> abs_a;
         BitField<55, 1, u64> ftz;
-        BitField<56, 1, u64> neg_imm;
     } fset;
 
+    union {
+        BitField<49, 1, u64> bf;
+        BitField<35, 3, PredCondition> cond;
+        BitField<50, 1, u64> ftz;
+        BitField<45, 2, PredOperation> op;
+        BitField<43, 1, u64> negate_a;
+        BitField<44, 1, u64> abs_a;
+        BitField<47, 2, HalfType> type_a;
+        BitField<31, 1, u64> negate_b;
+        BitField<30, 1, u64> abs_b;
+        BitField<28, 2, HalfType> type_b;
+        BitField<42, 1, u64> neg_pred;
+        BitField<39, 3, u64> pred39;
+    } hset2;
+
     union {
         BitField<39, 3, u64> pred39;
         BitField<42, 1, u64> neg_pred;
@@ -1145,6 +1263,18 @@ public:
         LEA_RZ,
         LEA_IMM,
         LEA_HI,
+        HADD2_C,
+        HADD2_R,
+        HADD2_IMM,
+        HMUL2_C,
+        HMUL2_R,
+        HMUL2_IMM,
+        HFMA2_CR,
+        HFMA2_RC,
+        HFMA2_RR,
+        HFMA2_IMM_R,
+        HSETP2_R,
+        HSET2_R,
         POPC_C,
         POPC_R,
         POPC_IMM,
@@ -1218,9 +1348,12 @@ public:
         ArithmeticImmediate,
         ArithmeticInteger,
         ArithmeticIntegerImmediate,
+        ArithmeticHalf,
+        ArithmeticHalfImmediate,
         Bfe,
         Shift,
         Ffma,
+        Hfma2,
         Flow,
         Synch,
         Memory,
@@ -1228,6 +1361,8 @@ public:
         FloatSetPredicate,
         IntegerSet,
         IntegerSetPredicate,
+        HalfSet,
+        HalfSetPredicate,
         PredicateSetPredicate,
         PredicateSetRegister,
         Conversion,
@@ -1389,6 +1524,18 @@ private:
             INST("001101101101----", Id::LEA_IMM, Type::ArithmeticInteger, "LEA_IMM"),
             INST("010010111101----", Id::LEA_RZ, Type::ArithmeticInteger, "LEA_RZ"),
             INST("00011000--------", Id::LEA_HI, Type::ArithmeticInteger, "LEA_HI"),
+            INST("0111101-1-------", Id::HADD2_C, Type::ArithmeticHalf, "HADD2_C"),
+            INST("0101110100010---", Id::HADD2_R, Type::ArithmeticHalf, "HADD2_R"),
+            INST("0111101-0-------", Id::HADD2_IMM, Type::ArithmeticHalfImmediate, "HADD2_IMM"),
+            INST("0111100-1-------", Id::HMUL2_C, Type::ArithmeticHalf, "HMUL2_C"),
+            INST("0101110100001---", Id::HMUL2_R, Type::ArithmeticHalf, "HMUL2_R"),
+            INST("0111100-0-------", Id::HMUL2_IMM, Type::ArithmeticHalfImmediate, "HMUL2_IMM"),
+            INST("01110---1-------", Id::HFMA2_CR, Type::Hfma2, "HFMA2_CR"),
+            INST("01100---1-------", Id::HFMA2_RC, Type::Hfma2, "HFMA2_RC"),
+            INST("0101110100000---", Id::HFMA2_RR, Type::Hfma2, "HFMA2_RR"),
+            INST("01110---0-------", Id::HFMA2_IMM_R, Type::Hfma2, "HFMA2_R_IMM"),
+            INST("0101110100100---", Id::HSETP2_R, Type::HalfSetPredicate, "HSETP_R"),
+            INST("0101110100011---", Id::HSET2_R, Type::HalfSet, "HSET2_R"),
             INST("0101000010000---", Id::MUFU, Type::Arithmetic, "MUFU"),
             INST("0100110010010---", Id::RRO_C, Type::Arithmetic, "RRO_C"),
             INST("0101110010010---", Id::RRO_R, Type::Arithmetic, "RRO_R"),

src/video_core/gpu.cpp

@@ -27,8 +27,8 @@ GPU::GPU(VideoCore::RasterizerInterface& rasterizer) {
     maxwell_3d = std::make_unique<Engines::Maxwell3D>(rasterizer, *memory_manager);
     fermi_2d = std::make_unique<Engines::Fermi2D>(rasterizer, *memory_manager);
     maxwell_compute = std::make_unique<Engines::MaxwellCompute>();
-    maxwell_dma = std::make_unique<Engines::MaxwellDMA>(*memory_manager);
-    kepler_memory = std::make_unique<Engines::KeplerMemory>(*memory_manager);
+    maxwell_dma = std::make_unique<Engines::MaxwellDMA>(rasterizer, *memory_manager);
+    kepler_memory = std::make_unique<Engines::KeplerMemory>(rasterizer, *memory_manager);
 }
 
 GPU::~GPU() = default;

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -659,6 +659,12 @@ void RasterizerOpenGL::FlushAndInvalidateRegion(VAddr addr, u64 size) {
 bool RasterizerOpenGL::AccelerateSurfaceCopy(const Tegra::Engines::Fermi2D::Regs::Surface& src,
                                              const Tegra::Engines::Fermi2D::Regs::Surface& dst) {
     MICROPROFILE_SCOPE(OpenGL_Blits);
+
+    if (Settings::values.use_accurate_gpu_emulation) {
+        // Skip the accelerated copy and perform a slow but more accurate copy
+        return false;
+    }
+
     res_cache.FermiCopySurface(src, dst);
     return true;
 }

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -30,8 +30,6 @@ using Tegra::Shader::SubOp;
 constexpr u32 PROGRAM_END = MAX_PROGRAM_CODE_LENGTH;
 constexpr u32 PROGRAM_HEADER_SIZE = sizeof(Tegra::Shader::Header);
 
-enum : u32 { POSITION_VARYING_LOCATION = 0, GENERIC_VARYING_START_LOCATION = 1 };
-
 constexpr u32 MAX_GEOMETRY_BUFFERS = 6;
 constexpr u32 MAX_ATTRIBUTES = 0x100; // Size in vec4s, this value is untested
 
@@ -375,6 +373,49 @@ public:
         }
     }
 
+    /**
+     * Writes code that does a register assignment to a half float value operation.
+     * @param reg The destination register to use.
+     * @param elem The element to use for the operation.
+     * @param value The code representing the value to assign. Type has to be half float.
+     * @param type Half float kind of assignment.
+     * @param dest_num_components Number of components in the destionation.
+     * @param value_num_components Number of components in the value.
+     * @param is_saturated Optional, when True, saturates the provided value.
+     * @param dest_elem Optional, the destination element to use for the operation.
+     */
+    void SetRegisterToHalfFloat(const Register& reg, u64 elem, const std::string& value,
+                                Tegra::Shader::HalfMerge merge, u64 dest_num_components,
+                                u64 value_num_components, bool is_saturated = false,
+                                u64 dest_elem = 0) {
+        ASSERT_MSG(!is_saturated, "Unimplemented");
+
+        const std::string result = [&]() {
+            switch (merge) {
+            case Tegra::Shader::HalfMerge::H0_H1:
+                return "uintBitsToFloat(packHalf2x16(" + value + "))";
+            case Tegra::Shader::HalfMerge::F32:
+                // Half float instructions take the first component when doing a float cast.
+                return "float(" + value + ".x)";
+            case Tegra::Shader::HalfMerge::Mrg_H0:
+                // TODO(Rodrigo): I guess Mrg_H0 and Mrg_H1 take their respective component from the
+                // pack. I couldn't test this on hardware but it shouldn't really matter since most
+                // of the time when a Mrg_* flag is used both components will be mirrored. That
+                // being said, it deserves a test.
+                return "((" + GetRegisterAsInteger(reg, 0, false) +
+                       " & 0xffff0000) | (packHalf2x16(" + value + ") & 0x0000ffff))";
+            case Tegra::Shader::HalfMerge::Mrg_H1:
+                return "((" + GetRegisterAsInteger(reg, 0, false) +
+                       " & 0x0000ffff) | (packHalf2x16(" + value + ") & 0xffff0000))";
+            default:
+                UNREACHABLE();
+                return std::string("0");
+            }
+        }();
+
+        SetRegister(reg, elem, result, dest_num_components, value_num_components, dest_elem);
+    }
+
     /**
      * Writes code that does a register assignment to input attribute operation. Input attributes
      * are stored as floats, so this may require conversion.
@@ -548,13 +589,6 @@ private:
 
     /// Generates declarations for input attributes.
     void GenerateInputAttrs() {
-        if (stage != Maxwell3D::Regs::ShaderStage::Vertex) {
-            const std::string attr =
-                stage == Maxwell3D::Regs::ShaderStage::Geometry ? "gs_position[]" : "position";
-            declarations.AddLine("layout (location = " + std::to_string(POSITION_VARYING_LOCATION) +
-                                 ") in vec4 " + attr + ';');
-        }
-
         for (const auto element : declr_input_attribute) {
             // TODO(bunnei): Use proper number of elements for these
             u32 idx =
@@ -577,10 +611,6 @@ private:
 
     /// Generates declarations for output attributes.
     void GenerateOutputAttrs() {
-        if (stage != Maxwell3D::Regs::ShaderStage::Fragment) {
-            declarations.AddLine("layout (location = " + std::to_string(POSITION_VARYING_LOCATION) +
-                                 ") out vec4 position;");
-        }
         for (const auto& index : declr_output_attribute) {
             // TODO(bunnei): Use proper number of elements for these
             const u32 idx = static_cast<u32>(index) -
@@ -877,6 +907,19 @@ private:
         return fmt::format("uintBitsToFloat({})", instr.alu.GetImm20_32());
     }
 
+    /// Generates code representing a vec2 pair unpacked from a half float immediate
+    static std::string UnpackHalfImmediate(const Instruction& instr, bool negate) {
+        const std::string immediate = GetHalfFloat(std::to_string(instr.half_imm.PackImmediates()));
+        if (!negate) {
+            return immediate;
+        }
+        const std::string negate_first = instr.half_imm.first_negate != 0 ? "-" : "";
+        const std::string negate_second = instr.half_imm.second_negate != 0 ? "-" : "";
+        const std::string negate_vec = "vec2(" + negate_first + "1, " + negate_second + "1)";
+
+        return '(' + immediate + " * " + negate_vec + ')';
+    }
+
     /// Generates code representing a texture sampler.
     std::string GetSampler(const Sampler& sampler, Tegra::Shader::TextureType type, bool is_array,
                            bool is_shadow) {
@@ -1012,6 +1055,41 @@ private:
         return result;
     }
 
+    /*
+     * Transforms the input string GLSL operand into an unpacked half float pair.
+     * @note This function returns a float type pair instead of a half float pair. This is because
+     * real half floats are not standarized in GLSL but unpackHalf2x16 (which returns a vec2) is.
+     * @param operand Input operand. It has to be an unsigned integer.
+     * @param type How to unpack the unsigned integer to a half float pair.
+     * @param abs Get the absolute value of unpacked half floats.
+     * @param neg Get the negative value of unpacked half floats.
+     * @returns String corresponding to a half float pair.
+     */
+    static std::string GetHalfFloat(const std::string& operand,
+                                    Tegra::Shader::HalfType type = Tegra::Shader::HalfType::H0_H1,
+                                    bool abs = false, bool neg = false) {
+        // "vec2" calls emitted in this function are intended to alias components.
+        const std::string value = [&]() {
+            switch (type) {
+            case Tegra::Shader::HalfType::H0_H1:
+                return "unpackHalf2x16(" + operand + ')';
+            case Tegra::Shader::HalfType::F32:
+                return "vec2(uintBitsToFloat(" + operand + "))";
+            case Tegra::Shader::HalfType::H0_H0:
+            case Tegra::Shader::HalfType::H1_H1: {
+                const bool high = type == Tegra::Shader::HalfType::H1_H1;
+                const char unpack_index = "xy"[high ? 1 : 0];
+                return "vec2(unpackHalf2x16(" + operand + ")." + unpack_index + ')';
+            }
+            default:
+                UNREACHABLE();
+                return std::string("vec2(0)");
+            }
+        }();
+
+        return GetOperandAbsNeg(value, abs, neg);
+    }
+
     /*
      * Returns whether the instruction at the specified offset is a 'sched' instruction.
      * Sched instructions always appear before a sequence of 3 instructions.
@@ -1381,9 +1459,10 @@ private:
                 break;
             }
             case OpCode::Id::FMUL32_IMM: {
-                regs.SetRegisterToFloat(
-                    instr.gpr0, 0,
-                    regs.GetRegisterAsFloat(instr.gpr8) + " * " + GetImmediate32(instr), 1, 1);
+                regs.SetRegisterToFloat(instr.gpr0, 0,
+                                        regs.GetRegisterAsFloat(instr.gpr8) + " * " +
+                                            GetImmediate32(instr),
+                                        1, 1, instr.fmul32.saturate);
                 break;
             }
             case OpCode::Id::FADD32I: {
@@ -1748,6 +1827,86 @@ private:
 
             break;
         }
+        case OpCode::Type::ArithmeticHalf: {
+            if (opcode->GetId() == OpCode::Id::HADD2_C || opcode->GetId() == OpCode::Id::HADD2_R) {
+                ASSERT_MSG(instr.alu_half.ftz == 0, "Unimplemented");
+            }
+            const bool negate_a =
+                opcode->GetId() != OpCode::Id::HMUL2_R && instr.alu_half.negate_a != 0;
+            const bool negate_b =
+                opcode->GetId() != OpCode::Id::HMUL2_C && instr.alu_half.negate_b != 0;
+
+            const std::string op_a =
+                GetHalfFloat(regs.GetRegisterAsInteger(instr.gpr8, 0, false), instr.alu_half.type_a,
+                             instr.alu_half.abs_a != 0, negate_a);
+
+            std::string op_b;
+            switch (opcode->GetId()) {
+            case OpCode::Id::HADD2_C:
+            case OpCode::Id::HMUL2_C:
+                op_b = regs.GetUniform(instr.cbuf34.index, instr.cbuf34.offset,
+                                       GLSLRegister::Type::UnsignedInteger);
+                break;
+            case OpCode::Id::HADD2_R:
+            case OpCode::Id::HMUL2_R:
+                op_b = regs.GetRegisterAsInteger(instr.gpr20, 0, false);
+                break;
+            default:
+                UNREACHABLE();
+                op_b = "0";
+                break;
+            }
+            op_b = GetHalfFloat(op_b, instr.alu_half.type_b, instr.alu_half.abs_b != 0, negate_b);
+
+            const std::string result = [&]() {
+                switch (opcode->GetId()) {
+                case OpCode::Id::HADD2_C:
+                case OpCode::Id::HADD2_R:
+                    return '(' + op_a + " + " + op_b + ')';
+                case OpCode::Id::HMUL2_C:
+                case OpCode::Id::HMUL2_R:
+                    return '(' + op_a + " * " + op_b + ')';
+                default:
+                    LOG_CRITICAL(HW_GPU, "Unhandled half float instruction: {}", opcode->GetName());
+                    UNREACHABLE();
+                    return std::string("0");
+                }
+            }();
+
+            regs.SetRegisterToHalfFloat(instr.gpr0, 0, result, instr.alu_half.merge, 1, 1,
+                                        instr.alu_half.saturate != 0);
+            break;
+        }
+        case OpCode::Type::ArithmeticHalfImmediate: {
+            if (opcode->GetId() == OpCode::Id::HADD2_IMM) {
+                ASSERT_MSG(instr.alu_half_imm.ftz == 0, "Unimplemented");
+            } else {
+                ASSERT_MSG(instr.alu_half_imm.precision == Tegra::Shader::HalfPrecision::None,
+                           "Unimplemented");
+            }
+
+            const std::string op_a = GetHalfFloat(
+                regs.GetRegisterAsInteger(instr.gpr8, 0, false), instr.alu_half_imm.type_a,
+                instr.alu_half_imm.abs_a != 0, instr.alu_half_imm.negate_a != 0);
+
+            const std::string op_b = UnpackHalfImmediate(instr, true);
+
+            const std::string result = [&]() {
+                switch (opcode->GetId()) {
+                case OpCode::Id::HADD2_IMM:
+                    return op_a + " + " + op_b;
+                case OpCode::Id::HMUL2_IMM:
+                    return op_a + " * " + op_b;
+                default:
+                    UNREACHABLE();
+                    return std::string("0");
+                }
+            }();
+
+            regs.SetRegisterToHalfFloat(instr.gpr0, 0, result, instr.alu_half_imm.merge, 1, 1,
+                                        instr.alu_half_imm.saturate != 0);
+            break;
+        }
         case OpCode::Type::Ffma: {
             const std::string op_a = regs.GetRegisterAsFloat(instr.gpr8);
             std::string op_b = instr.ffma.negate_b ? "-" : "";
@@ -1792,6 +1951,59 @@ private:
                                     instr.alu.saturate_d);
             break;
         }
+        case OpCode::Type::Hfma2: {
+            if (opcode->GetId() == OpCode::Id::HFMA2_RR) {
+                ASSERT_MSG(instr.hfma2.rr.precision == Tegra::Shader::HalfPrecision::None,
+                           "Unimplemented");
+            } else {
+                ASSERT_MSG(instr.hfma2.precision == Tegra::Shader::HalfPrecision::None,
+                           "Unimplemented");
+            }
+            const bool saturate = opcode->GetId() == OpCode::Id::HFMA2_RR
+                                      ? instr.hfma2.rr.saturate != 0
+                                      : instr.hfma2.saturate != 0;
+
+            const std::string op_a =
+                GetHalfFloat(regs.GetRegisterAsInteger(instr.gpr8, 0, false), instr.hfma2.type_a);
+            std::string op_b, op_c;
+
+            switch (opcode->GetId()) {
+            case OpCode::Id::HFMA2_CR:
+                op_b = GetHalfFloat(regs.GetUniform(instr.cbuf34.index, instr.cbuf34.offset,
+                                                    GLSLRegister::Type::UnsignedInteger),
+                                    instr.hfma2.type_b, false, instr.hfma2.negate_b);
+                op_c = GetHalfFloat(regs.GetRegisterAsInteger(instr.gpr39, 0, false),
+                                    instr.hfma2.type_reg39, false, instr.hfma2.negate_c);
+                break;
+            case OpCode::Id::HFMA2_RC:
+                op_b = GetHalfFloat(regs.GetRegisterAsInteger(instr.gpr39, 0, false),
+                                    instr.hfma2.type_reg39, false, instr.hfma2.negate_b);
+                op_c = GetHalfFloat(regs.GetUniform(instr.cbuf34.index, instr.cbuf34.offset,
+                                                    GLSLRegister::Type::UnsignedInteger),
+                                    instr.hfma2.type_b, false, instr.hfma2.negate_c);
+                break;
+            case OpCode::Id::HFMA2_RR:
+                op_b = GetHalfFloat(regs.GetRegisterAsInteger(instr.gpr20, 0, false),
+                                    instr.hfma2.type_b, false, instr.hfma2.negate_b);
+                op_c = GetHalfFloat(regs.GetRegisterAsInteger(instr.gpr39, 0, false),
+                                    instr.hfma2.rr.type_c, false, instr.hfma2.rr.negate_c);
+                break;
+            case OpCode::Id::HFMA2_IMM_R:
+                op_b = UnpackHalfImmediate(instr, true);
+                op_c = GetHalfFloat(regs.GetRegisterAsInteger(instr.gpr39, 0, false),
+                                    instr.hfma2.type_reg39, false, instr.hfma2.negate_c);
+                break;
+            default:
+                UNREACHABLE();
+                op_c = op_b = "vec2(0)";
+                break;
+            }
+
+            const std::string result = '(' + op_a + " * " + op_b + " + " + op_c + ')';
+
+            regs.SetRegisterToHalfFloat(instr.gpr0, 0, result, instr.hfma2.merge, 1, 1, saturate);
+            break;
+        }
         case OpCode::Type::Conversion: {
             switch (opcode->GetId()) {
             case OpCode::Id::I2I_R: {
@@ -2525,20 +2737,13 @@ private:
             break;
         }
         case OpCode::Type::FloatSetPredicate: {
-            std::string op_a = instr.fsetp.neg_a ? "-" : "";
-            op_a += regs.GetRegisterAsFloat(instr.gpr8);
+            const std::string op_a =
+                GetOperandAbsNeg(regs.GetRegisterAsFloat(instr.gpr8), instr.fsetp.abs_a != 0,
+                                 instr.fsetp.neg_a != 0);
 
-            if (instr.fsetp.abs_a) {
-                op_a = "abs(" + op_a + ')';
-            }
-
-            std::string op_b{};
+            std::string op_b;
 
             if (instr.is_b_imm) {
-                if (instr.fsetp.neg_b) {
-                    // Only the immediate version of fsetp has a neg_b bit.
-                    op_b += '-';
-                }
                 op_b += '(' + GetImmediate19(instr) + ')';
             } else {
                 if (instr.is_b_gpr) {
@@ -2611,6 +2816,51 @@ private:
             }
             break;
         }
+        case OpCode::Type::HalfSetPredicate: {
+            ASSERT_MSG(instr.hsetp2.ftz == 0, "Unimplemented");
+
+            const std::string op_a =
+                GetHalfFloat(regs.GetRegisterAsInteger(instr.gpr8, 0, false), instr.hsetp2.type_a,
+                             instr.hsetp2.abs_a, instr.hsetp2.negate_a);
+
+            const std::string op_b = [&]() {
+                switch (opcode->GetId()) {
+                case OpCode::Id::HSETP2_R:
+                    return GetHalfFloat(regs.GetRegisterAsInteger(instr.gpr20, 0, false),
+                                        instr.hsetp2.type_b, instr.hsetp2.abs_a,
+                                        instr.hsetp2.negate_b);
+                default:
+                    UNREACHABLE();
+                    return std::string("vec2(0)");
+                }
+            }();
+
+            // We can't use the constant predicate as destination.
+            ASSERT(instr.hsetp2.pred3 != static_cast<u64>(Pred::UnusedIndex));
+
+            const std::string second_pred =
+                GetPredicateCondition(instr.hsetp2.pred39, instr.hsetp2.neg_pred != 0);
+
+            const std::string combiner = GetPredicateCombiner(instr.hsetp2.op);
+
+            const std::string component_combiner = instr.hsetp2.h_and ? "&&" : "||";
+            const std::string predicate =
+                '(' + GetPredicateComparison(instr.hsetp2.cond, op_a + ".x", op_b + ".x") + ' ' +
+                component_combiner + ' ' +
+                GetPredicateComparison(instr.hsetp2.cond, op_a + ".y", op_b + ".y") + ')';
+
+            // Set the primary predicate to the result of Predicate OP SecondPredicate
+            SetPredicate(instr.hsetp2.pred3,
+                         '(' + predicate + ") " + combiner + " (" + second_pred + ')');
+
+            if (instr.hsetp2.pred0 != static_cast<u64>(Pred::UnusedIndex)) {
+                // Set the secondary predicate to the result of !Predicate OP SecondPredicate,
+                // if enabled
+                SetPredicate(instr.hsetp2.pred0,
+                             "!(" + predicate + ") " + combiner + " (" + second_pred + ')');
+            }
+            break;
+        }
         case OpCode::Type::PredicateSetRegister: {
             const std::string op_a =
                 GetPredicateCondition(instr.pset.pred12, instr.pset.neg_pred12 != 0);
@@ -2689,33 +2939,24 @@ private:
             break;
         }
         case OpCode::Type::FloatSet: {
-            std::string op_a = instr.fset.neg_a ? "-" : "";
-            op_a += regs.GetRegisterAsFloat(instr.gpr8);
+            const std::string op_a = GetOperandAbsNeg(regs.GetRegisterAsFloat(instr.gpr8),
+                                                      instr.fset.abs_a != 0, instr.fset.neg_a != 0);
 
-            if (instr.fset.abs_a) {
-                op_a = "abs(" + op_a + ')';
-            }
-
-            std::string op_b = instr.fset.neg_b ? "-" : "";
+            std::string op_b;
 
             if (instr.is_b_imm) {
                 const std::string imm = GetImmediate19(instr);
-                if (instr.fset.neg_imm)
-                    op_b += "(-" + imm + ')';
-                else
-                    op_b += imm;
+                op_b = imm;
             } else {
                 if (instr.is_b_gpr) {
-                    op_b += regs.GetRegisterAsFloat(instr.gpr20);
+                    op_b = regs.GetRegisterAsFloat(instr.gpr20);
                 } else {
-                    op_b += regs.GetUniform(instr.cbuf34.index, instr.cbuf34.offset,
-                                            GLSLRegister::Type::Float);
+                    op_b = regs.GetUniform(instr.cbuf34.index, instr.cbuf34.offset,
+                                           GLSLRegister::Type::Float);
                 }
             }
 
-            if (instr.fset.abs_b) {
-                op_b = "abs(" + op_b + ')';
-            }
+            op_b = GetOperandAbsNeg(op_b, instr.fset.abs_b != 0, instr.fset.neg_b != 0);
 
             // The fset instruction sets a register to 1.0 or -1 (depending on the bf bit) if the
             // condition is true, and to 0 otherwise.
@@ -2771,6 +3012,50 @@ private:
             }
             break;
         }
+        case OpCode::Type::HalfSet: {
+            ASSERT_MSG(instr.hset2.ftz == 0, "Unimplemented");
+
+            const std::string op_a =
+                GetHalfFloat(regs.GetRegisterAsInteger(instr.gpr8, 0, false), instr.hset2.type_a,
+                             instr.hset2.abs_a != 0, instr.hset2.negate_a != 0);
+
+            const std::string op_b = [&]() {
+                switch (opcode->GetId()) {
+                case OpCode::Id::HSET2_R:
+                    return GetHalfFloat(regs.GetRegisterAsInteger(instr.gpr20, 0, false),
+                                        instr.hset2.type_b, instr.hset2.abs_b != 0,
+                                        instr.hset2.negate_b != 0);
+                default:
+                    UNREACHABLE();
+                    return std::string("vec2(0)");
+                }
+            }();
+
+            const std::string second_pred =
+                GetPredicateCondition(instr.hset2.pred39, instr.hset2.neg_pred != 0);
+
+            const std::string combiner = GetPredicateCombiner(instr.hset2.op);
+
+            // HSET2 operates on each half float in the pack.
+            std::string result;
+            for (int i = 0; i < 2; ++i) {
+                const std::string float_value = i == 0 ? "0x00003c00" : "0x3c000000";
+                const std::string integer_value = i == 0 ? "0x0000ffff" : "0xffff0000";
+                const std::string value = instr.hset2.bf == 1 ? float_value : integer_value;
+
+                const std::string comp = std::string(".") + "xy"[i];
+                const std::string predicate =
+                    "((" + GetPredicateComparison(instr.hset2.cond, op_a + comp, op_b + comp) +
+                    ") " + combiner + " (" + second_pred + "))";
+
+                result += '(' + predicate + " ? " + value + " : 0)";
+                if (i == 0) {
+                    result += " | ";
+                }
+            }
+            regs.SetRegisterToInteger(instr.gpr0, false, 0, '(' + result + ')', 1, 1);
+            break;
+        }
         case OpCode::Type::Xmad: {
             ASSERT_MSG(!instr.xmad.sign_a, "Unimplemented");
             ASSERT_MSG(!instr.xmad.sign_b, "Unimplemented");

src/video_core/renderer_opengl/gl_shader_gen.cpp

@@ -23,6 +23,8 @@ out gl_PerVertex {
     vec4 gl_Position;
 };
 
+layout (location = 0) out vec4 position;
+
 layout(std140) uniform vs_config {
     vec4 viewport_flip;
     uvec4 instance_id;
@@ -96,6 +98,9 @@ out gl_PerVertex {
     vec4 gl_Position;
 };
 
+layout (location = 0) in vec4 gs_position[];
+layout (location = 0) out vec4 position;
+
 layout (std140) uniform gs_config {
     vec4 viewport_flip;
     uvec4 instance_id;
@@ -131,6 +136,8 @@ layout(location = 5) out vec4 FragColor5;
 layout(location = 6) out vec4 FragColor6;
 layout(location = 7) out vec4 FragColor7;
 
+layout (location = 0) in vec4 position;
+
 layout (std140) uniform fs_config {
     vec4 viewport_flip;
     uvec4 instance_id;

src/video_core/renderer_opengl/gl_shader_gen.h

@@ -16,6 +16,8 @@ namespace OpenGL::GLShader {
 constexpr std::size_t MAX_PROGRAM_CODE_LENGTH{0x1000};
 using ProgramCode = std::vector<u64>;
 
+enum : u32 { POSITION_VARYING_LOCATION = 0, GENERIC_VARYING_START_LOCATION = 1 };
+
 class ConstBufferEntry {
     using Maxwell = Tegra::Engines::Maxwell3D::Regs;
 

src/video_core/renderer_opengl/maxwell_to_gl.h

@@ -82,8 +82,20 @@ inline GLenum VertexType(Maxwell::VertexAttribute attrib) {
         return {};
     }
 
-    case Maxwell::VertexAttribute::Type::Float:
-        return GL_FLOAT;
+    case Maxwell::VertexAttribute::Type::Float: {
+        switch (attrib.size) {
+        case Maxwell::VertexAttribute::Size::Size_16:
+        case Maxwell::VertexAttribute::Size::Size_16_16:
+        case Maxwell::VertexAttribute::Size::Size_16_16_16:
+        case Maxwell::VertexAttribute::Size::Size_16_16_16_16:
+            return GL_HALF_FLOAT;
+        case Maxwell::VertexAttribute::Size::Size_32:
+        case Maxwell::VertexAttribute::Size::Size_32_32:
+        case Maxwell::VertexAttribute::Size::Size_32_32_32:
+        case Maxwell::VertexAttribute::Size::Size_32_32_32_32:
+            return GL_FLOAT;
+        }
+    }
     }
 
     LOG_CRITICAL(Render_OpenGL, "Unimplemented vertex type={}", attrib.TypeString());

src/video_core/textures/decoders.cpp

@@ -237,6 +237,46 @@ std::vector<u8> UnswizzleTexture(VAddr address, u32 tile_size, u32 bytes_per_pix
     return unswizzled_data;
 }
 
+void SwizzleSubrect(u32 subrect_width, u32 subrect_height, u32 source_pitch, u32 swizzled_width,
+                    u32 bytes_per_pixel, VAddr swizzled_data, VAddr unswizzled_data,
+                    u32 block_height) {
+    const u32 image_width_in_gobs{(swizzled_width * bytes_per_pixel + 63) / 64};
+    for (u32 line = 0; line < subrect_height; ++line) {
+        const u32 gob_address_y =
+            (line / (8 * block_height)) * 512 * block_height * image_width_in_gobs +
+            (line % (8 * block_height) / 8) * 512;
+        const auto& table = legacy_swizzle_table[line % 8];
+        for (u32 x = 0; x < subrect_width; ++x) {
+            const u32 gob_address = gob_address_y + (x * bytes_per_pixel / 64) * 512 * block_height;
+            const u32 swizzled_offset = gob_address + table[(x * bytes_per_pixel) % 64];
+            const VAddr source_line = unswizzled_data + line * source_pitch + x * bytes_per_pixel;
+            const VAddr dest_addr = swizzled_data + swizzled_offset;
+
+            Memory::CopyBlock(dest_addr, source_line, bytes_per_pixel);
+        }
+    }
+}
+
+void UnswizzleSubrect(u32 subrect_width, u32 subrect_height, u32 dest_pitch, u32 swizzled_width,
+                      u32 bytes_per_pixel, VAddr swizzled_data, VAddr unswizzled_data,
+                      u32 block_height, u32 offset_x, u32 offset_y) {
+    for (u32 line = 0; line < subrect_height; ++line) {
+        const u32 y2 = line + offset_y;
+        const u32 gob_address_y =
+            (y2 / (8 * block_height)) * 512 * block_height + (y2 % (8 * block_height) / 8) * 512;
+        const auto& table = legacy_swizzle_table[y2 % 8];
+        for (u32 x = 0; x < subrect_width; ++x) {
+            const u32 x2 = (x + offset_x) * bytes_per_pixel;
+            const u32 gob_address = gob_address_y + (x2 / 64) * 512 * block_height;
+            const u32 swizzled_offset = gob_address + table[x2 % 64];
+            const VAddr dest_line = unswizzled_data + line * dest_pitch + x * bytes_per_pixel;
+            const VAddr source_addr = swizzled_data + swizzled_offset;
+
+            Memory::CopyBlock(dest_line, source_addr, bytes_per_pixel);
+        }
+    }
+}
+
 std::vector<u8> DecodeTexture(const std::vector<u8>& texture_data, TextureFormat format, u32 width,
                               u32 height) {
     std::vector<u8> rgba_data;

src/video_core/textures/decoders.h

@@ -35,4 +35,13 @@ std::vector<u8> DecodeTexture(const std::vector<u8>& texture_data, TextureFormat
 std::size_t CalculateSize(bool tiled, u32 bytes_per_pixel, u32 width, u32 height, u32 depth,
                           u32 block_height, u32 block_depth);
 
+/// Copies an untiled subrectangle into a tiled surface.
+void SwizzleSubrect(u32 subrect_width, u32 subrect_height, u32 source_pitch, u32 swizzled_width,
+                    u32 bytes_per_pixel, VAddr swizzled_data, VAddr unswizzled_data,
+                    u32 block_height);
+/// Copies a tiled subrectangle into a linear surface.
+void UnswizzleSubrect(u32 subrect_width, u32 subrect_height, u32 dest_pitch, u32 swizzled_width,
+                      u32 bytes_per_pixel, VAddr swizzled_data, VAddr unswizzled_data,
+                      u32 block_height, u32 offset_x, u32 offset_y);
+
 } // namespace Tegra::Texture

src/web_service/CMakeLists.txt

@@ -12,5 +12,5 @@ create_target_directory_groups(web_service)
 get_directory_property(OPENSSL_LIBS
         DIRECTORY ${CMAKE_SOURCE_DIR}/externals/libressl
         DEFINITION OPENSSL_LIBS)
-target_compile_definitions(web_service PUBLIC -DCPPHTTPLIB_OPENSSL_SUPPORT)
+target_compile_definitions(web_service PRIVATE -DCPPHTTPLIB_OPENSSL_SUPPORT)
 target_link_libraries(web_service PRIVATE common json-headers ${OPENSSL_LIBS} httplib lurlparser)

src/yuzu/main.ui

@@ -97,18 +97,24 @@
     <addaction name="action_Show_Status_Bar"/>
     <addaction name="menu_View_Debugging"/>
    </widget>
+   <widget class ="QMenu" name="menu_Tools">
+    <property name="title">
+     <string>Tools</string>
+    </property>
+    <addaction name="action_Rederive" />
+   </widget>
    <widget class="QMenu" name="menu_Help">
     <property name="title">
      <string>&amp;Help</string>
     </property>
     <addaction name="action_Report_Compatibility"/>
     <addaction name="separator"/>
-     <addaction name="action_Rederive"/>
     <addaction name="action_About"/>
    </widget>
    <addaction name="menu_File"/>
    <addaction name="menu_Emulation"/>
    <addaction name="menu_View"/>
+   <addaction name="menu_Tools" />
    <addaction name="menu_Help"/>
   </widget>
    <action name="action_Install_File_NAND">