Merge pull request #13135 from german77/hid-interface

service: hid: Migrate HidServer to new IPC

src/common/settings.h

@@ -140,7 +140,7 @@ struct Values {
                                                Category::LibraryApplet};
     Setting<AppletMode> data_erase_applet_mode{linkage, AppletMode::HLE, "data_erase_applet_mode",
                                                Category::LibraryApplet};
-    Setting<AppletMode> error_applet_mode{linkage, AppletMode::HLE, "error_applet_mode",
+    Setting<AppletMode> error_applet_mode{linkage, AppletMode::LLE, "error_applet_mode",
                                           Category::LibraryApplet};
     Setting<AppletMode> net_connect_applet_mode{linkage, AppletMode::HLE, "net_connect_applet_mode",
                                                 Category::LibraryApplet};
@@ -435,8 +435,6 @@ struct Values {
         linkage, false, "disable_shader_loop_safety_checks", Category::RendererDebug};
     Setting<bool> enable_renderdoc_hotkey{linkage, false, "renderdoc_hotkey",
                                           Category::RendererDebug};
-    // TODO: remove this once AMDVLK supports VK_EXT_depth_bias_control
-    bool renderer_amdvlk_depth_bias_workaround{};
     Setting<bool> disable_buffer_reorder{linkage, false, "disable_buffer_reorder",
                                          Category::RendererDebug};
 

src/core/CMakeLists.txt

@@ -668,6 +668,10 @@ add_library(core STATIC
     hle/service/glue/time/worker.h
     hle/service/grc/grc.cpp
     hle/service/grc/grc.h
+    hle/service/hid/active_vibration_device_list.cpp
+    hle/service/hid/active_vibration_device_list.h
+    hle/service/hid/applet_resource.cpp
+    hle/service/hid/applet_resource.h
     hle/service/hid/hid.cpp
     hle/service/hid/hid.h
     hle/service/hid/hid_debug_server.cpp
@@ -1047,9 +1051,12 @@ add_library(core STATIC
     hle/service/spl/spl_module.h
     hle/service/spl/spl_results.h
     hle/service/spl/spl_types.h
+    hle/service/ssl/cert_store.cpp
+    hle/service/ssl/cert_store.h
     hle/service/ssl/ssl.cpp
     hle/service/ssl/ssl.h
     hle/service/ssl/ssl_backend.h
+    hle/service/ssl/ssl_types.h
     hle/service/usb/usb.cpp
     hle/service/usb/usb.h
     hle/service/vi/application_display_service.cpp

src/core/core.cpp

@@ -425,11 +425,6 @@ struct System::Impl {
             room_member->SendGameInfo(game_info);
         }
 
-        // Workarounds:
-        // Activate this in Super Smash Brothers Ultimate, it only affects AMD cards using AMDVLK
-        Settings::values.renderer_amdvlk_depth_bias_workaround =
-            params.program_id == 0x1006A800016E000ULL;
-
         status = SystemResultStatus::Success;
         return status;
     }
@@ -489,9 +484,6 @@ struct System::Impl {
             room_member->SendGameInfo(game_info);
         }
 
-        // Workarounds
-        Settings::values.renderer_amdvlk_depth_bias_workaround = false;
-
         LOG_DEBUG(Core, "Shutdown OK");
     }
 

src/core/file_sys/fssystem/fssystem_aes_xts_storage.cpp

@@ -31,8 +31,8 @@ AesXtsStorage::AesXtsStorage(VirtualFile base, const void* key1, const void* key
     ASSERT(iv_size == IvSize);
     ASSERT(Common::IsAligned(m_block_size, AesBlockSize));
 
-    std::memcpy(m_key.data() + 0, key1, KeySize);
+    std::memcpy(m_key.data() + 0, key1, KeySize / 2);
-    std::memcpy(m_key.data() + 0x10, key2, KeySize);
+    std::memcpy(m_key.data() + 0x10, key2, KeySize / 2);
     std::memcpy(m_iv.data(), iv, IvSize);
 
     m_cipher.emplace(m_key, Core::Crypto::Mode::XTS);

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

@@ -25,8 +25,8 @@
 #include "core/hle/service/acc/async_context.h"
 #include "core/hle/service/acc/errors.h"
 #include "core/hle/service/acc/profile_manager.h"
+#include "core/hle/service/cmif_serialization.h"
 #include "core/hle/service/glue/glue_manager.h"
-#include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/server_manager.h"
 #include "core/loader/loader.h"
 
@@ -74,12 +74,12 @@ static void SanitizeJPEGImageSize(std::vector<u8>& image) {
 
 class IManagerForSystemService final : public ServiceFramework<IManagerForSystemService> {
 public:
-    explicit IManagerForSystemService(Core::System& system_, Common::UUID)
+    explicit IManagerForSystemService(Core::System& system_, Common::UUID uuid)
-        : ServiceFramework{system_, "IManagerForSystemService"} {
+        : ServiceFramework{system_, "IManagerForSystemService"}, account_id{uuid} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {0, &IManagerForSystemService::CheckAvailability, "CheckAvailability"},
+            {0, D<&IManagerForSystemService::CheckAvailability>, "CheckAvailability"},
-            {1, nullptr, "GetAccountId"},
+            {1, D<&IManagerForSystemService::GetAccountId>, "GetAccountId"},
             {2, nullptr, "EnsureIdTokenCacheAsync"},
             {3, nullptr, "LoadIdTokenCache"},
             {100, nullptr, "SetSystemProgramIdentification"},
@@ -109,11 +109,18 @@ public:
     }
 
 private:
-    void CheckAvailability(HLERequestContext& ctx) {
+    Result CheckAvailability() {
         LOG_WARNING(Service_ACC, "(STUBBED) called");
-        IPC::ResponseBuilder rb{ctx, 2};
+        R_SUCCEED();
-        rb.Push(ResultSuccess);
     }
+
+    Result GetAccountId(Out<u64> out_account_id) {
+        LOG_WARNING(Service_ACC, "(STUBBED) called");
+        *out_account_id = account_id.Hash();
+        R_SUCCEED();
+    }
+
+    Common::UUID account_id;
 };
 
 // 3.0.0+

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

@@ -23,7 +23,7 @@ ACC_U1::ACC_U1(std::shared_ptr<Module> module_, std::shared_ptr<ProfileManager>
         {99, nullptr, "DebugActivateOpenContextRetention"},
         {100, nullptr, "GetUserRegistrationNotifier"},
         {101, nullptr, "GetUserStateChangeNotifier"},
-        {102, nullptr, "GetBaasAccountManagerForSystemService"},
+        {102, &ACC_U1::GetBaasAccountManagerForSystemService, "GetBaasAccountManagerForSystemService"},
         {103, nullptr, "GetBaasUserAvailabilityChangeNotifier"},
         {104, nullptr, "GetProfileUpdateNotifier"},
         {105, nullptr, "CheckNetworkServiceAvailabilityAsync"},

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

@@ -48,11 +48,6 @@ enum class SystemButtonType {
     CaptureButtonLongPressing,
 };
 
-enum class SysPlatformRegion : s32 {
-    Global = 1,
-    Terra = 2,
-};
-
 struct AppletProcessLaunchReason {
     u8 flag;
     INSERT_PADDING_BYTES(3);

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

@@ -260,9 +260,9 @@ Result ICommonStateGetter::GetAppletLaunchedHistory(
 }
 
 Result ICommonStateGetter::GetSettingsPlatformRegion(
-    Out<SysPlatformRegion> out_settings_platform_region) {
+    Out<Set::PlatformRegion> out_settings_platform_region) {
     LOG_INFO(Service_AM, "called");
-    *out_settings_platform_region = SysPlatformRegion::Global;
+    *out_settings_platform_region = Set::PlatformRegion::Global;
     R_SUCCEED();
 }
 

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

@@ -8,6 +8,7 @@
 #include "core/hle/service/cmif_types.h"
 #include "core/hle/service/pm/pm.h"
 #include "core/hle/service/service.h"
+#include "core/hle/service/set/settings_types.h"
 
 namespace Kernel {
 class KReadableEvent;
@@ -50,7 +51,7 @@ private:
     Result GetOperationModeSystemInfo(Out<u32> out_operation_mode_system_info);
     Result GetAppletLaunchedHistory(Out<s32> out_count,
                                     OutArray<AppletId, BufferAttr_HipcMapAlias> out_applet_ids);
-    Result GetSettingsPlatformRegion(Out<SysPlatformRegion> out_settings_platform_region);
+    Result GetSettingsPlatformRegion(Out<Set::PlatformRegion> out_settings_platform_region);
     Result SetRequestExitToLibraryAppletAtExecuteNextProgramEnabled();
 
     void SetCpuBoostMode(HLERequestContext& ctx);

src/core/hle/service/erpt/erpt.cpp

@@ -18,7 +18,7 @@ public:
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, C<&ErrorReportContext::SubmitContext>, "SubmitContext"},
-            {1, nullptr, "CreateReportV0"},
+            {1, C<&ErrorReportContext::CreateReportV0>, "CreateReportV0"},
             {2, nullptr, "SetInitialLaunchSettingsCompletionTime"},
             {3, nullptr, "ClearInitialLaunchSettingsCompletionTime"},
             {4, nullptr, "UpdatePowerOnTime"},
@@ -28,7 +28,8 @@ public:
             {8, nullptr, "ClearApplicationLaunchTime"},
             {9, nullptr, "SubmitAttachment"},
             {10, nullptr, "CreateReportWithAttachments"},
-            {11, nullptr, "CreateReport"},
+            {11, C<&ErrorReportContext::CreateReportV1>, "CreateReportV1"},
+            {12, C<&ErrorReportContext::CreateReport>, "CreateReport"},
             {20, nullptr, "RegisterRunningApplet"},
             {21, nullptr, "UnregisterRunningApplet"},
             {22, nullptr, "UpdateAppletSuspendedDuration"},
@@ -40,10 +41,37 @@ public:
     }
 
 private:
-    Result SubmitContext(InBuffer<BufferAttr_HipcMapAlias> buffer_a,
+    Result SubmitContext(InBuffer<BufferAttr_HipcMapAlias> context_entry,
-                         InBuffer<BufferAttr_HipcMapAlias> buffer_b) {
+                         InBuffer<BufferAttr_HipcMapAlias> field_list) {
-        LOG_WARNING(Service_SET, "(STUBBED) called, buffer_a_size={}, buffer_b_size={}",
+        LOG_WARNING(Service_SET, "(STUBBED) called, context_entry_size={}, field_list_size={}",
-                    buffer_a.size(), buffer_b.size());
+                    context_entry.size(), field_list.size());
+        R_SUCCEED();
+    }
+
+    Result CreateReportV0(u32 report_type, InBuffer<BufferAttr_HipcMapAlias> context_entry,
+                          InBuffer<BufferAttr_HipcMapAlias> report_list,
+                          InBuffer<BufferAttr_HipcMapAlias> report_meta_data) {
+        LOG_WARNING(Service_SET, "(STUBBED) called, report_type={:#x}", report_type);
+        R_SUCCEED();
+    }
+
+    Result CreateReportV1(u32 report_type, u32 unknown,
+                          InBuffer<BufferAttr_HipcMapAlias> context_entry,
+                          InBuffer<BufferAttr_HipcMapAlias> report_list,
+                          InBuffer<BufferAttr_HipcMapAlias> report_meta_data) {
+        LOG_WARNING(Service_SET, "(STUBBED) called, report_type={:#x}, unknown={:#x}", report_type,
+                    unknown);
+        R_SUCCEED();
+    }
+
+    Result CreateReport(u32 report_type, u32 unknown, u32 create_report_option_flag,
+                        InBuffer<BufferAttr_HipcMapAlias> context_entry,
+                        InBuffer<BufferAttr_HipcMapAlias> report_list,
+                        InBuffer<BufferAttr_HipcMapAlias> report_meta_data) {
+        LOG_WARNING(
+            Service_SET,
+            "(STUBBED) called, report_type={:#x}, unknown={:#x}, create_report_option_flag={:#x}",
+            report_type, unknown, create_report_option_flag);
         R_SUCCEED();
     }
 };

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

@@ -71,7 +71,7 @@ FSP_SRV::FSP_SRV(Core::System& system_)
         {28, nullptr, "DeleteSaveDataFileSystemBySaveDataAttribute"},
         {30, nullptr, "OpenGameCardStorage"},
         {31, nullptr, "OpenGameCardFileSystem"},
-        {32, nullptr, "ExtendSaveDataFileSystem"},
+        {32, D<&FSP_SRV::ExtendSaveDataFileSystem>, "ExtendSaveDataFileSystem"},
         {33, nullptr, "DeleteCacheStorage"},
         {34, D<&FSP_SRV::GetCacheStorageSize>, "GetCacheStorageSize"},
         {35, nullptr, "CreateSaveDataFileSystemByHashSalt"},
@@ -79,9 +79,9 @@ FSP_SRV::FSP_SRV(Core::System& system_)
         {51, D<&FSP_SRV::OpenSaveDataFileSystem>, "OpenSaveDataFileSystem"},
         {52, D<&FSP_SRV::OpenSaveDataFileSystemBySystemSaveDataId>, "OpenSaveDataFileSystemBySystemSaveDataId"},
         {53, D<&FSP_SRV::OpenReadOnlySaveDataFileSystem>, "OpenReadOnlySaveDataFileSystem"},
-        {57, nullptr, "ReadSaveDataFileSystemExtraDataBySaveDataSpaceId"},
+        {57, D<&FSP_SRV::ReadSaveDataFileSystemExtraDataBySaveDataSpaceId>, "ReadSaveDataFileSystemExtraDataBySaveDataSpaceId"},
-        {58, nullptr, "ReadSaveDataFileSystemExtraData"},
+        {58, D<&FSP_SRV::ReadSaveDataFileSystemExtraData>, "ReadSaveDataFileSystemExtraData"},
-        {59, nullptr, "WriteSaveDataFileSystemExtraData"},
+        {59, D<&FSP_SRV::WriteSaveDataFileSystemExtraData>, "WriteSaveDataFileSystemExtraData"},
         {60, nullptr, "OpenSaveDataInfoReader"},
         {61, D<&FSP_SRV::OpenSaveDataInfoReaderBySaveDataSpaceId>, "OpenSaveDataInfoReaderBySaveDataSpaceId"},
         {62, D<&FSP_SRV::OpenSaveDataInfoReaderOnlyCacheStorage>, "OpenSaveDataInfoReaderOnlyCacheStorage"},
@@ -90,8 +90,8 @@ FSP_SRV::FSP_SRV(Core::System& system_)
         {66, nullptr, "WriteSaveDataFileSystemExtraData2"},
         {67, D<&FSP_SRV::FindSaveDataWithFilter>, "FindSaveDataWithFilter"},
         {68, nullptr, "OpenSaveDataInfoReaderBySaveDataFilter"},
-        {69, nullptr, "ReadSaveDataFileSystemExtraDataBySaveDataAttribute"},
+        {69, D<&FSP_SRV::ReadSaveDataFileSystemExtraDataBySaveDataAttribute>, "ReadSaveDataFileSystemExtraDataBySaveDataAttribute"},
-        {70, D<&FSP_SRV::WriteSaveDataFileSystemExtraDataBySaveDataAttribute>, "WriteSaveDataFileSystemExtraDataBySaveDataAttribute"},
+        {70, D<&FSP_SRV::WriteSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute>, "WriteSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute"},
         {71, D<&FSP_SRV::ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute>, "ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute"},
         {80, nullptr, "OpenSaveDataMetaFile"},
         {81, nullptr, "OpenSaveDataTransferManager"},
@@ -317,9 +317,23 @@ Result FSP_SRV::FindSaveDataWithFilter(Out<s64> out_count,
     R_THROW(FileSys::ResultTargetNotFound);
 }
 
-Result FSP_SRV::WriteSaveDataFileSystemExtraDataBySaveDataAttribute() {
+Result FSP_SRV::WriteSaveDataFileSystemExtraData(InBuffer<BufferAttr_HipcMapAlias> buffer,
-    LOG_WARNING(Service_FS, "(STUBBED) called.");
+                                                 FileSys::SaveDataSpaceId space_id,
+                                                 u64 save_data_id) {
+    LOG_WARNING(Service_FS, "(STUBBED) called, space_id={}, save_data_id={:016X}", space_id,
+                save_data_id);
+    R_SUCCEED();
+}
 
+Result FSP_SRV::WriteSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute(
+    InBuffer<BufferAttr_HipcMapAlias> buffer, InBuffer<BufferAttr_HipcMapAlias> mask_buffer,
+    FileSys::SaveDataSpaceId space_id, FileSys::SaveDataAttribute attribute) {
+    LOG_WARNING(Service_FS,
+                "(STUBBED) called, space_id={}, attribute.program_id={:016X}\n"
+                "attribute.user_id={:016X}{:016X}, attribute.save_id={:016X}\n"
+                "attribute.type={}, attribute.rank={}, attribute.index={}",
+                space_id, attribute.program_id, attribute.user_id[1], attribute.user_id[0],
+                attribute.system_save_data_id, attribute.type, attribute.rank, attribute.index);
     R_SUCCEED();
 }
 
@@ -341,6 +355,38 @@ Result FSP_SRV::ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute(
     R_SUCCEED();
 }
 
+Result FSP_SRV::ReadSaveDataFileSystemExtraData(OutBuffer<BufferAttr_HipcMapAlias> out_buffer,
+                                                u64 save_data_id) {
+    // Stub, backend needs an impl to read/write the SaveDataExtraData
+    LOG_WARNING(Service_FS, "(STUBBED) called, save_data_id={:016X}", save_data_id);
+    std::memset(out_buffer.data(), 0, out_buffer.size());
+    R_SUCCEED();
+}
+
+Result FSP_SRV::ReadSaveDataFileSystemExtraDataBySaveDataAttribute(
+    OutBuffer<BufferAttr_HipcMapAlias> out_buffer, FileSys::SaveDataSpaceId space_id,
+    FileSys::SaveDataAttribute attribute) {
+    // Stub, backend needs an impl to read/write the SaveDataExtraData
+    LOG_WARNING(Service_FS,
+                "(STUBBED) called, space_id={}, attribute.program_id={:016X}\n"
+                "attribute.user_id={:016X}{:016X}, attribute.save_id={:016X}\n"
+                "attribute.type={}, attribute.rank={}, attribute.index={}",
+                space_id, attribute.program_id, attribute.user_id[1], attribute.user_id[0],
+                attribute.system_save_data_id, attribute.type, attribute.rank, attribute.index);
+    std::memset(out_buffer.data(), 0, out_buffer.size());
+    R_SUCCEED();
+}
+
+Result FSP_SRV::ReadSaveDataFileSystemExtraDataBySaveDataSpaceId(
+    OutBuffer<BufferAttr_HipcMapAlias> out_buffer, FileSys::SaveDataSpaceId space_id,
+    u64 save_data_id) {
+    // Stub, backend needs an impl to read/write the SaveDataExtraData
+    LOG_WARNING(Service_FS, "(STUBBED) called, space_id={}, save_data_id={:016X}", space_id,
+                save_data_id);
+    std::memset(out_buffer.data(), 0, out_buffer.size());
+    R_SUCCEED();
+}
+
 Result FSP_SRV::OpenSaveDataTransferProhibiter(
     OutInterface<ISaveDataTransferProhibiter> out_prohibiter, u64 id) {
     LOG_WARNING(Service_FS, "(STUBBED) called, id={:016X}", id);
@@ -476,6 +522,16 @@ Result FSP_SRV::FlushAccessLogOnSdCard() {
     R_SUCCEED();
 }
 
+Result FSP_SRV::ExtendSaveDataFileSystem(FileSys::SaveDataSpaceId space_id, u64 save_data_id,
+                                         s64 available_size, s64 journal_size) {
+    // We don't have an index of save data ids, so we can't implement this.
+    LOG_WARNING(Service_FS,
+                "(STUBBED) called, space_id={}, save_data_id={:016X}, available_size={:#x}, "
+                "journal_size={:#x}",
+                space_id, save_data_id, available_size, journal_size);
+    R_SUCCEED();
+}
+
 Result FSP_SRV::GetCacheStorageSize(s32 index, Out<s64> out_data_size, Out<s64> out_journal_size) {
     LOG_WARNING(Service_FS, "(STUBBED) called with index={}", index);
 

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

@@ -70,7 +70,19 @@ private:
     Result FindSaveDataWithFilter(Out<s64> out_count, OutBuffer<BufferAttr_HipcMapAlias> out_buffer,
                                   FileSys::SaveDataSpaceId space_id,
                                   FileSys::SaveDataFilter filter);
-    Result WriteSaveDataFileSystemExtraDataBySaveDataAttribute();
+    Result WriteSaveDataFileSystemExtraData(InBuffer<BufferAttr_HipcMapAlias> buffer,
+                                            FileSys::SaveDataSpaceId space_id, u64 save_data_id);
+    Result WriteSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute(
+        InBuffer<BufferAttr_HipcMapAlias> buffer, InBuffer<BufferAttr_HipcMapAlias> mask_buffer,
+        FileSys::SaveDataSpaceId space_id, FileSys::SaveDataAttribute attribute);
+    Result ReadSaveDataFileSystemExtraData(OutBuffer<BufferAttr_HipcMapAlias> out_buffer,
+                                           u64 save_data_id);
+    Result ReadSaveDataFileSystemExtraDataBySaveDataAttribute(
+        OutBuffer<BufferAttr_HipcMapAlias> out_buffer, FileSys::SaveDataSpaceId space_id,
+        FileSys::SaveDataAttribute attribute);
+    Result ReadSaveDataFileSystemExtraDataBySaveDataSpaceId(
+        OutBuffer<BufferAttr_HipcMapAlias> out_buffer, FileSys::SaveDataSpaceId space_id,
+        u64 save_data_id);
     Result ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute(
         FileSys::SaveDataSpaceId space_id, FileSys::SaveDataAttribute attribute,
         InBuffer<BufferAttr_HipcMapAlias> mask_buffer,
@@ -91,6 +103,8 @@ private:
     Result GetProgramIndexForAccessLog(Out<AccessLogVersion> out_access_log_version,
                                        Out<u32> out_access_log_program_index);
     Result OpenMultiCommitManager(OutInterface<IMultiCommitManager> out_interface);
+    Result ExtendSaveDataFileSystem(FileSys::SaveDataSpaceId space_id, u64 save_data_id,
+                                    s64 available_size, s64 journal_size);
     Result GetCacheStorageSize(s32 index, Out<s64> out_data_size, Out<s64> out_journal_size);
 
     FileSystemController& fsc;

src/core/hle/service/glue/time/manager.cpp

@@ -51,16 +51,17 @@ s64 CalendarTimeToEpoch(Service::PSC::Time::CalendarTime calendar) {
 }
 
 s64 GetEpochTimeFromInitialYear(std::shared_ptr<Service::Set::ISystemSettingsServer>& set_sys) {
+    s32 year{2000};
+    set_sys->GetSettingsItemValueImpl(year, "time", "standard_user_clock_initial_year");
+
     Service::PSC::Time::CalendarTime calendar{
-        .year = 2000,
+        .year = static_cast<s16>(year),
         .month = 1,
         .day = 1,
         .hour = 0,
         .minute = 0,
         .second = 0,
     };
-    set_sys->GetSettingsItemValueImpl<s16>(calendar.year, "time",
-                                           "standard_user_clock_initial_year");
     return CalendarTimeToEpoch(calendar);
 }
 

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

@@ -0,0 +1,53 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "common/logging/log.h"
+#include "core/hle/service/cmif_serialization.h"
+#include "core/hle/service/hid/active_vibration_device_list.h"
+#include "hid_core/hid_result.h"
+#include "hid_core/hid_util.h"
+#include "hid_core/resource_manager.h"
+#include "hid_core/resources/vibration/vibration_device.h"
+
+namespace Service::HID {
+
+IActiveVibrationDeviceList::IActiveVibrationDeviceList(Core::System& system_,
+                                                       std::shared_ptr<ResourceManager> resource)
+    : ServiceFramework{system_, "IActiveVibrationDeviceList"}, resource_manager(resource) {
+    // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, C<&IActiveVibrationDeviceList::ActivateVibrationDevice>, "ActivateVibrationDevice"},
+        };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+IActiveVibrationDeviceList::~IActiveVibrationDeviceList() = default;
+
+Result IActiveVibrationDeviceList::ActivateVibrationDevice(
+    Core::HID::VibrationDeviceHandle vibration_device_handle) {
+    LOG_DEBUG(Service_HID, "called, npad_type={}, npad_id={}, device_index={}",
+              vibration_device_handle.npad_type, vibration_device_handle.npad_id,
+              vibration_device_handle.device_index);
+
+    std::scoped_lock lock{mutex};
+
+    R_TRY(IsVibrationHandleValid(vibration_device_handle));
+
+    for (std::size_t i = 0; i < list_size; i++) {
+        if (vibration_device_handle.device_index == vibration_device_list[i].device_index &&
+            vibration_device_handle.npad_id == vibration_device_list[i].npad_id &&
+            vibration_device_handle.npad_type == vibration_device_list[i].npad_type) {
+            R_SUCCEED();
+        }
+    }
+
+    R_UNLESS(list_size < MaxVibrationDevicesHandles, ResultVibrationDeviceIndexOutOfRange);
+    R_TRY(resource_manager->GetVibrationDevice(vibration_device_handle)->Activate());
+
+    vibration_device_list[list_size++] = vibration_device_handle;
+    R_SUCCEED();
+}
+
+} // namespace Service::HID

src/core/hle/service/hid/active_vibration_device_list.h

@@ -0,0 +1,39 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <array>
+#include <memory>
+#include <mutex>
+
+#include "core/hle/service/cmif_types.h"
+#include "core/hle/service/service.h"
+#include "hid_core/hid_types.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::HID {
+class ResourceManager;
+
+class IActiveVibrationDeviceList final : public ServiceFramework<IActiveVibrationDeviceList> {
+public:
+    explicit IActiveVibrationDeviceList(Core::System& system_,
+                                        std::shared_ptr<ResourceManager> resource);
+    ~IActiveVibrationDeviceList() override;
+
+private:
+    static constexpr std::size_t MaxVibrationDevicesHandles{0x100};
+
+    Result ActivateVibrationDevice(Core::HID::VibrationDeviceHandle vibration_device_handle);
+
+    mutable std::mutex mutex;
+    std::size_t list_size{};
+    std::array<Core::HID::VibrationDeviceHandle, MaxVibrationDevicesHandles>
+        vibration_device_list{};
+    std::shared_ptr<ResourceManager> resource_manager;
+};
+
+} // namespace Service::HID

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

@@ -0,0 +1,34 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "common/logging/log.h"
+#include "core/hle/kernel/k_shared_memory.h"
+#include "core/hle/service/cmif_serialization.h"
+#include "core/hle/service/hid/applet_resource.h"
+#include "hid_core/resource_manager.h"
+
+namespace Service::HID {
+
+IAppletResource::IAppletResource(Core::System& system_, std::shared_ptr<ResourceManager> resource,
+                                 u64 applet_resource_user_id)
+    : ServiceFramework{system_, "IAppletResource"}, aruid{applet_resource_user_id},
+      resource_manager{resource} {
+    static const FunctionInfo functions[] = {
+        {0, C<&IAppletResource::GetSharedMemoryHandle>, "GetSharedMemoryHandle"},
+    };
+    RegisterHandlers(functions);
+}
+
+IAppletResource::~IAppletResource() {
+    resource_manager->FreeAppletResourceId(aruid);
+}
+
+Result IAppletResource::GetSharedMemoryHandle(
+    OutCopyHandle<Kernel::KSharedMemory> out_shared_memory_handle) {
+    const auto result = resource_manager->GetSharedMemoryHandle(out_shared_memory_handle, aruid);
+
+    LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}, result=0x{:X}", aruid, result.raw);
+    R_RETURN(result);
+}
+
+} // namespace Service::HID

src/core/hle/service/hid/applet_resource.h

@@ -0,0 +1,36 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <memory>
+
+#include "common/common_types.h"
+#include "core/hle/service/cmif_types.h"
+#include "core/hle/service/service.h"
+
+namespace Core {
+class System;
+}
+
+namespace Kernel {
+class KSharedMemory;
+}
+
+namespace Service::HID {
+class ResourceManager;
+
+class IAppletResource final : public ServiceFramework<IAppletResource> {
+public:
+    explicit IAppletResource(Core::System& system_, std::shared_ptr<ResourceManager> resource,
+                             u64 applet_resource_user_id);
+    ~IAppletResource() override;
+
+private:
+    Result GetSharedMemoryHandle(OutCopyHandle<Kernel::KSharedMemory> out_shared_memory_handle);
+
+    u64 aruid{};
+    std::shared_ptr<ResourceManager> resource_manager;
+};
+
+} // namespace Service::HID

src/core/hle/service/hid/hid_server.h

@@ -6,12 +6,20 @@
 #include "core/hle/service/cmif_types.h"
 #include "core/hle/service/service.h"
 #include "hid_core/hid_types.h"
+#include "hid_core/resources/npad/npad_types.h"
+#include "hid_core/resources/palma/palma.h"
 
 namespace Core {
 class System;
 }
 
+namespace Kernel {
+class KReadableEvent;
+}
+
 namespace Service::HID {
+class IActiveVibrationDeviceList;
+class IAppletResource;
 class ResourceManager;
 class HidFirmwareSettings;
 
@@ -24,128 +32,232 @@ public:
     std::shared_ptr<ResourceManager> GetResourceManager();
 
 private:
-    void CreateAppletResource(HLERequestContext& ctx);
+    Result CreateAppletResource(OutInterface<IAppletResource> out_applet_resource,
-    void ActivateDebugPad(HLERequestContext& ctx);
+                                ClientAppletResourceUserId aruid);
-    void ActivateTouchScreen(HLERequestContext& ctx);
+    Result ActivateDebugPad(ClientAppletResourceUserId aruid);
-    void ActivateMouse(HLERequestContext& ctx);
+    Result ActivateTouchScreen(ClientAppletResourceUserId aruid);
-    void ActivateKeyboard(HLERequestContext& ctx);
+    Result ActivateMouse(ClientAppletResourceUserId aruid);
-    void SendKeyboardLockKeyEvent(HLERequestContext& ctx);
+    Result ActivateKeyboard(ClientAppletResourceUserId aruid);
-    void AcquireXpadIdEventHandle(HLERequestContext& ctx);
+    Result SendKeyboardLockKeyEvent(u32 flags);
-    void ReleaseXpadIdEventHandle(HLERequestContext& ctx);
+    Result AcquireXpadIdEventHandle(OutCopyHandle<Kernel::KReadableEvent> out_event,
-    void ActivateXpad(HLERequestContext& ctx);
+                                    ClientAppletResourceUserId aruid);
-    void GetXpadIds(HLERequestContext& ctx);
+    Result ReleaseXpadIdEventHandle(ClientAppletResourceUserId aruid);
-    void ActivateJoyXpad(HLERequestContext& ctx);
+    Result ActivateXpad(u32 basic_xpad_id, ClientAppletResourceUserId aruid);
-    void GetJoyXpadLifoHandle(HLERequestContext& ctx);
+    Result GetXpadIds(Out<u64> out_count, OutArray<u32, BufferAttr_HipcPointer> out_basic_pad_ids);
-    void GetJoyXpadIds(HLERequestContext& ctx);
+    Result ActivateJoyXpad(u32 joy_xpad_id);
-    void ActivateSixAxisSensor(HLERequestContext& ctx);
+    Result GetJoyXpadLifoHandle(OutCopyHandle<Kernel::KSharedMemory> out_shared_memory_handle,
-    void DeactivateSixAxisSensor(HLERequestContext& ctx);
+                                u32 joy_xpad_id);
-    void GetSixAxisSensorLifoHandle(HLERequestContext& ctx);
+    Result GetJoyXpadIds(Out<s64> out_basic_xpad_id_count);
-    void ActivateJoySixAxisSensor(HLERequestContext& ctx);
+    Result ActivateSixAxisSensor(u32 joy_xpad_id);
-    void DeactivateJoySixAxisSensor(HLERequestContext& ctx);
+    Result DeactivateSixAxisSensor(u32 joy_xpad_id);
-    void GetJoySixAxisSensorLifoHandle(HLERequestContext& ctx);
+    Result GetSixAxisSensorLifoHandle(OutCopyHandle<Kernel::KSharedMemory> out_shared_memory_handle,
-    void StartSixAxisSensor(HLERequestContext& ctx);
+                                      u32 joy_xpad_id);
-    void StopSixAxisSensor(HLERequestContext& ctx);
+    Result ActivateJoySixAxisSensor(u32 joy_xpad_id);
-    void IsSixAxisSensorFusionEnabled(HLERequestContext& ctx);
+    Result DeactivateJoySixAxisSensor(u32 joy_xpad_id);
-    void EnableSixAxisSensorFusion(HLERequestContext& ctx);
+    Result GetJoySixAxisSensorLifoHandle(
-    void SetSixAxisSensorFusionParameters(HLERequestContext& ctx);
+        OutCopyHandle<Kernel::KSharedMemory> out_shared_memory_handle, u32 joy_xpad_id);
-    void GetSixAxisSensorFusionParameters(HLERequestContext& ctx);
+    Result StartSixAxisSensor(Core::HID::SixAxisSensorHandle sixaxis_handle,
-    void ResetSixAxisSensorFusionParameters(HLERequestContext& ctx);
+                              ClientAppletResourceUserId aruid);
-    void SetGyroscopeZeroDriftMode(HLERequestContext& ctx);
+    Result StopSixAxisSensor(Core::HID::SixAxisSensorHandle sixaxis_handle,
-    void GetGyroscopeZeroDriftMode(HLERequestContext& ctx);
+                             ClientAppletResourceUserId aruid);
-    void ResetGyroscopeZeroDriftMode(HLERequestContext& ctx);
+    Result IsSixAxisSensorFusionEnabled(Out<bool> out_is_enabled,
-    void IsSixAxisSensorAtRest(HLERequestContext& ctx);
+                                        Core::HID::SixAxisSensorHandle sixaxis_handle,
-    void IsFirmwareUpdateAvailableForSixAxisSensor(HLERequestContext& ctx);
+                                        ClientAppletResourceUserId aruid);
-    void EnableSixAxisSensorUnalteredPassthrough(HLERequestContext& ctx);
+    Result EnableSixAxisSensorFusion(bool is_enabled, Core::HID::SixAxisSensorHandle sixaxis_handle,
-    void IsSixAxisSensorUnalteredPassthroughEnabled(HLERequestContext& ctx);
+                                     ClientAppletResourceUserId aruid);
-    void LoadSixAxisSensorCalibrationParameter(HLERequestContext& ctx);
+    Result SetSixAxisSensorFusionParameters(Core::HID::SixAxisSensorHandle sixaxis_handle,
-    void GetSixAxisSensorIcInformation(HLERequestContext& ctx);
+                                            Core::HID::SixAxisSensorFusionParameters sixaxis_fusion,
-    void ResetIsSixAxisSensorDeviceNewlyAssigned(HLERequestContext& ctx);
+                                            ClientAppletResourceUserId aruid);
-    void ActivateGesture(HLERequestContext& ctx);
+    Result GetSixAxisSensorFusionParameters(
-    void SetSupportedNpadStyleSet(HLERequestContext& ctx);
+        Out<Core::HID::SixAxisSensorFusionParameters> out_fusion_parameters,
-    void GetSupportedNpadStyleSet(HLERequestContext& ctx);
+        Core::HID::SixAxisSensorHandle sixaxis_handle, ClientAppletResourceUserId aruid);
-    void SetSupportedNpadIdType(HLERequestContext& ctx);
+    Result ResetSixAxisSensorFusionParameters(Core::HID::SixAxisSensorHandle sixaxis_handle,
-    void ActivateNpad(HLERequestContext& ctx);
+                                              ClientAppletResourceUserId aruid);
-    void DeactivateNpad(HLERequestContext& ctx);
+    Result SetGyroscopeZeroDriftMode(Core::HID::SixAxisSensorHandle sixaxis_handle,
-    void AcquireNpadStyleSetUpdateEventHandle(HLERequestContext& ctx);
+                                     Core::HID::GyroscopeZeroDriftMode drift_mode,
-    void DisconnectNpad(HLERequestContext& ctx);
+                                     ClientAppletResourceUserId aruid);
+    Result GetGyroscopeZeroDriftMode(Out<Core::HID::GyroscopeZeroDriftMode> out_drift_mode,
+                                     Core::HID::SixAxisSensorHandle sixaxis_handle,
+                                     ClientAppletResourceUserId aruid);
+    Result ResetGyroscopeZeroDriftMode(Core::HID::SixAxisSensorHandle sixaxis_handle,
+                                       ClientAppletResourceUserId aruid);
+    Result IsSixAxisSensorAtRest(Out<bool> out_is_at_rest,
+                                 Core::HID::SixAxisSensorHandle sixaxis_handle,
+                                 ClientAppletResourceUserId aruid);
+    Result IsFirmwareUpdateAvailableForSixAxisSensor(Out<bool> out_is_firmware_available,
+                                                     Core::HID::SixAxisSensorHandle sixaxis_handle,
+                                                     ClientAppletResourceUserId aruid);
+    Result EnableSixAxisSensorUnalteredPassthrough(bool is_enabled,
+                                                   Core::HID::SixAxisSensorHandle sixaxis_handle,
+                                                   ClientAppletResourceUserId aruid);
+    Result IsSixAxisSensorUnalteredPassthroughEnabled(Out<bool> out_is_enabled,
+                                                      Core::HID::SixAxisSensorHandle sixaxis_handle,
+                                                      ClientAppletResourceUserId aruid);
+    Result LoadSixAxisSensorCalibrationParameter(
+        OutLargeData<Core::HID::SixAxisSensorCalibrationParameter, BufferAttr_HipcMapAlias>
+            out_calibration,
+        Core::HID::SixAxisSensorHandle sixaxis_handle, ClientAppletResourceUserId aruid);
+    Result GetSixAxisSensorIcInformation(
+        OutLargeData<Core::HID::SixAxisSensorIcInformation, BufferAttr_HipcPointer>
+            out_ic_information,
+        Core::HID::SixAxisSensorHandle sixaxis_handle, ClientAppletResourceUserId aruid);
+    Result ResetIsSixAxisSensorDeviceNewlyAssigned(Core::HID::SixAxisSensorHandle sixaxis_handle,
+                                                   ClientAppletResourceUserId aruid);
+    Result ActivateGesture(u32 basic_gesture_id, ClientAppletResourceUserId aruid);
+    Result SetSupportedNpadStyleSet(Core::HID::NpadStyleSet supported_style_set,
+                                    ClientAppletResourceUserId aruid);
+    Result GetSupportedNpadStyleSet(Out<Core::HID::NpadStyleSet> out_supported_style_set,
+                                    ClientAppletResourceUserId aruid);
+    Result SetSupportedNpadIdType(
+        ClientAppletResourceUserId aruid,
+        InArray<Core::HID::NpadIdType, BufferAttr_HipcPointer> supported_npad_list);
+    Result ActivateNpad(ClientAppletResourceUserId aruid);
+    Result DeactivateNpad(ClientAppletResourceUserId aruid);
+    Result AcquireNpadStyleSetUpdateEventHandle(OutCopyHandle<Kernel::KReadableEvent> out_event,
+                                                Core::HID::NpadIdType npad_id,
+                                                ClientAppletResourceUserId aruid, u64 unknown);
+    Result DisconnectNpad(Core::HID::NpadIdType npad_id, ClientAppletResourceUserId aruid);
     Result GetPlayerLedPattern(Out<Core::HID::LedPattern> out_led_pattern,
                                Core::HID::NpadIdType npad_id);
-    void ActivateNpadWithRevision(HLERequestContext& ctx);
+    Result ActivateNpadWithRevision(NpadRevision revision, ClientAppletResourceUserId aruid);
-    void SetNpadJoyHoldType(HLERequestContext& ctx);
+    Result SetNpadJoyHoldType(ClientAppletResourceUserId aruid, NpadJoyHoldType hold_type);
-    void GetNpadJoyHoldType(HLERequestContext& ctx);
+    Result GetNpadJoyHoldType(Out<NpadJoyHoldType> out_hold_type, ClientAppletResourceUserId aruid);
-    void SetNpadJoyAssignmentModeSingleByDefault(HLERequestContext& ctx);
+    Result SetNpadJoyAssignmentModeSingleByDefault(Core::HID::NpadIdType npad_id,
-    void SetNpadJoyAssignmentModeSingle(HLERequestContext& ctx);
+                                                   ClientAppletResourceUserId aruid);
-    void SetNpadJoyAssignmentModeDual(HLERequestContext& ctx);
+    Result SetNpadJoyAssignmentModeSingle(Core::HID::NpadIdType npad_id,
-    void MergeSingleJoyAsDualJoy(HLERequestContext& ctx);
+                                          ClientAppletResourceUserId aruid,
-    void StartLrAssignmentMode(HLERequestContext& ctx);
+                                          NpadJoyDeviceType npad_joy_device_type);
-    void StopLrAssignmentMode(HLERequestContext& ctx);
+    Result SetNpadJoyAssignmentModeDual(Core::HID::NpadIdType npad_id,
-    void SetNpadHandheldActivationMode(HLERequestContext& ctx);
+                                        ClientAppletResourceUserId aruid);
-    void GetNpadHandheldActivationMode(HLERequestContext& ctx);
+    Result MergeSingleJoyAsDualJoy(Core::HID::NpadIdType npad_id_1, Core::HID::NpadIdType npad_id_2,
-    void SwapNpadAssignment(HLERequestContext& ctx);
+                                   ClientAppletResourceUserId aruid);
-    void IsUnintendedHomeButtonInputProtectionEnabled(HLERequestContext& ctx);
+    Result StartLrAssignmentMode(ClientAppletResourceUserId aruid);
-    void EnableUnintendedHomeButtonInputProtection(HLERequestContext& ctx);
+    Result StopLrAssignmentMode(ClientAppletResourceUserId aruid);
-    void SetNpadJoyAssignmentModeSingleWithDestination(HLERequestContext& ctx);
+    Result SetNpadHandheldActivationMode(ClientAppletResourceUserId aruid,
-    void SetNpadAnalogStickUseCenterClamp(HLERequestContext& ctx);
+                                         NpadHandheldActivationMode activation_mode);
-    void SetNpadCaptureButtonAssignment(HLERequestContext& ctx);
+    Result GetNpadHandheldActivationMode(Out<NpadHandheldActivationMode> out_activation_mode,
-    void ClearNpadCaptureButtonAssignment(HLERequestContext& ctx);
+                                         ClientAppletResourceUserId aruid);
-    void GetVibrationDeviceInfo(HLERequestContext& ctx);
+    Result SwapNpadAssignment(Core::HID::NpadIdType npad_id_1, Core::HID::NpadIdType npad_id_2,
-    void SendVibrationValue(HLERequestContext& ctx);
+                              ClientAppletResourceUserId aruid);
-    void GetActualVibrationValue(HLERequestContext& ctx);
+    Result IsUnintendedHomeButtonInputProtectionEnabled(Out<bool> out_is_enabled,
-    void CreateActiveVibrationDeviceList(HLERequestContext& ctx);
+                                                        Core::HID::NpadIdType npad_id,
-    void PermitVibration(HLERequestContext& ctx);
+                                                        ClientAppletResourceUserId aruid);
-    void IsVibrationPermitted(HLERequestContext& ctx);
+    Result EnableUnintendedHomeButtonInputProtection(bool is_enabled, Core::HID::NpadIdType npad_id,
-    void SendVibrationValues(HLERequestContext& ctx);
+                                                     ClientAppletResourceUserId aruid);
-    void SendVibrationGcErmCommand(HLERequestContext& ctx);
+    Result SetNpadJoyAssignmentModeSingleWithDestination(Out<bool> out_is_reassigned,
-    void GetActualVibrationGcErmCommand(HLERequestContext& ctx);
+                                                         Out<Core::HID::NpadIdType> out_new_npad_id,
-    void BeginPermitVibrationSession(HLERequestContext& ctx);
+                                                         Core::HID::NpadIdType npad_id,
-    void EndPermitVibrationSession(HLERequestContext& ctx);
+                                                         ClientAppletResourceUserId aruid,
-    void IsVibrationDeviceMounted(HLERequestContext& ctx);
+                                                         NpadJoyDeviceType npad_joy_device_type);
-    void SendVibrationValueInBool(HLERequestContext& ctx);
+    Result SetNpadAnalogStickUseCenterClamp(bool use_center_clamp,
-    void ActivateConsoleSixAxisSensor(HLERequestContext& ctx);
+                                            ClientAppletResourceUserId aruid);
-    void StartConsoleSixAxisSensor(HLERequestContext& ctx);
+    Result SetNpadCaptureButtonAssignment(Core::HID::NpadStyleSet npad_styleset,
-    void StopConsoleSixAxisSensor(HLERequestContext& ctx);
+                                          ClientAppletResourceUserId aruid,
-    void ActivateSevenSixAxisSensor(HLERequestContext& ctx);
+                                          Core::HID::NpadButton button);
-    void StartSevenSixAxisSensor(HLERequestContext& ctx);
+    Result ClearNpadCaptureButtonAssignment(ClientAppletResourceUserId aruid);
-    void StopSevenSixAxisSensor(HLERequestContext& ctx);
+    Result GetVibrationDeviceInfo(Out<Core::HID::VibrationDeviceInfo> out_vibration_device_info,
-    void InitializeSevenSixAxisSensor(HLERequestContext& ctx);
+                                  Core::HID::VibrationDeviceHandle vibration_device_handle);
-    void FinalizeSevenSixAxisSensor(HLERequestContext& ctx);
+    Result SendVibrationValue(Core::HID::VibrationDeviceHandle vibration_device_handle,
-    void ResetSevenSixAxisSensorTimestamp(HLERequestContext& ctx);
+                              Core::HID::VibrationValue vibration_value,
-    void IsUsbFullKeyControllerEnabled(HLERequestContext& ctx);
+                              ClientAppletResourceUserId aruid);
-    void GetPalmaConnectionHandle(HLERequestContext& ctx);
+    Result GetActualVibrationValue(Out<Core::HID::VibrationValue> out_vibration_value,
-    void InitializePalma(HLERequestContext& ctx);
+                                   Core::HID::VibrationDeviceHandle vibration_device_handle,
-    void AcquirePalmaOperationCompleteEvent(HLERequestContext& ctx);
+                                   ClientAppletResourceUserId aruid);
-    void GetPalmaOperationInfo(HLERequestContext& ctx);
+    Result CreateActiveVibrationDeviceList(OutInterface<IActiveVibrationDeviceList> out_interface);
-    void PlayPalmaActivity(HLERequestContext& ctx);
+    Result PermitVibration(bool can_vibrate);
-    void SetPalmaFrModeType(HLERequestContext& ctx);
+    Result IsVibrationPermitted(Out<bool> out_is_permitted);
-    void ReadPalmaStep(HLERequestContext& ctx);
+    Result SendVibrationValues(
-    void EnablePalmaStep(HLERequestContext& ctx);
+        ClientAppletResourceUserId aruid,
-    void ResetPalmaStep(HLERequestContext& ctx);
+        InArray<Core::HID::VibrationDeviceHandle, BufferAttr_HipcPointer> vibration_handles,
-    void ReadPalmaApplicationSection(HLERequestContext& ctx);
+        InArray<Core::HID::VibrationValue, BufferAttr_HipcPointer> vibration_values);
-    void WritePalmaApplicationSection(HLERequestContext& ctx);
+    Result SendVibrationGcErmCommand(Core::HID::VibrationDeviceHandle vibration_device_handle,
-    void ReadPalmaUniqueCode(HLERequestContext& ctx);
+                                     ClientAppletResourceUserId aruid,
-    void SetPalmaUniqueCodeInvalid(HLERequestContext& ctx);
+                                     Core::HID::VibrationGcErmCommand gc_erm_command);
-    void WritePalmaActivityEntry(HLERequestContext& ctx);
+    Result GetActualVibrationGcErmCommand(Out<Core::HID::VibrationGcErmCommand> out_gc_erm_command,
-    void WritePalmaRgbLedPatternEntry(HLERequestContext& ctx);
+                                          Core::HID::VibrationDeviceHandle vibration_device_handle,
-    void WritePalmaWaveEntry(HLERequestContext& ctx);
+                                          ClientAppletResourceUserId aruid);
-    void SetPalmaDataBaseIdentificationVersion(HLERequestContext& ctx);
+    Result BeginPermitVibrationSession(ClientAppletResourceUserId aruid);
-    void GetPalmaDataBaseIdentificationVersion(HLERequestContext& ctx);
+    Result EndPermitVibrationSession(ClientAppletResourceUserId aruid);
-    void SuspendPalmaFeature(HLERequestContext& ctx);
+    Result IsVibrationDeviceMounted(Out<bool> out_is_mounted,
-    void GetPalmaOperationResult(HLERequestContext& ctx);
+                                    Core::HID::VibrationDeviceHandle vibration_device_handle,
-    void ReadPalmaPlayLog(HLERequestContext& ctx);
+                                    ClientAppletResourceUserId aruid);
-    void ResetPalmaPlayLog(HLERequestContext& ctx);
+    Result SendVibrationValueInBool(bool is_vibrating,
-    void SetIsPalmaAllConnectable(HLERequestContext& ctx);
+                                    Core::HID::VibrationDeviceHandle vibration_device_handle,
-    void SetIsPalmaPairedConnectable(HLERequestContext& ctx);
+                                    ClientAppletResourceUserId aruid);
-    void PairPalma(HLERequestContext& ctx);
+    Result ActivateConsoleSixAxisSensor(ClientAppletResourceUserId aruid);
-    void SetPalmaBoostMode(HLERequestContext& ctx);
+    Result StartConsoleSixAxisSensor(Core::HID::ConsoleSixAxisSensorHandle console_sixaxis_handle,
-    void CancelWritePalmaWaveEntry(HLERequestContext& ctx);
+                                     ClientAppletResourceUserId aruid);
-    void EnablePalmaBoostMode(HLERequestContext& ctx);
+    Result StopConsoleSixAxisSensor(Core::HID::ConsoleSixAxisSensorHandle console_sixaxis_handle,
-    void GetPalmaBluetoothAddress(HLERequestContext& ctx);
+                                    ClientAppletResourceUserId aruid);
-    void SetDisallowedPalmaConnection(HLERequestContext& ctx);
+    Result ActivateSevenSixAxisSensor(ClientAppletResourceUserId aruid);
-    void SetNpadCommunicationMode(HLERequestContext& ctx);
+    Result StartSevenSixAxisSensor(ClientAppletResourceUserId aruid);
-    void GetNpadCommunicationMode(HLERequestContext& ctx);
+    Result StopSevenSixAxisSensor(ClientAppletResourceUserId aruid);
-    void SetTouchScreenConfiguration(HLERequestContext& ctx);
+    Result InitializeSevenSixAxisSensor(ClientAppletResourceUserId aruid, u64 t_mem_1_size,
-    void IsFirmwareUpdateNeededForNotification(HLERequestContext& ctx);
+                                        u64 t_mem_2_size,
-    void SetTouchScreenResolution(HLERequestContext& ctx);
+                                        InCopyHandle<Kernel::KTransferMemory> t_mem_1,
+                                        InCopyHandle<Kernel::KTransferMemory> t_mem_2);
+    Result FinalizeSevenSixAxisSensor(ClientAppletResourceUserId aruid);
+    Result ResetSevenSixAxisSensorTimestamp(ClientAppletResourceUserId aruid);
+    Result IsUsbFullKeyControllerEnabled(Out<bool> out_is_enabled,
+                                         ClientAppletResourceUserId aruid);
+    Result GetPalmaConnectionHandle(Out<Palma::PalmaConnectionHandle> out_handle,
+                                    Core::HID::NpadIdType npad_id,
+                                    ClientAppletResourceUserId aruid);
+    Result InitializePalma(Palma::PalmaConnectionHandle connection_handle);
+    Result AcquirePalmaOperationCompleteEvent(OutCopyHandle<Kernel::KReadableEvent> out_event,
+                                              Palma::PalmaConnectionHandle connection_handle);
+    Result GetPalmaOperationInfo(Out<Palma::PalmaOperationType> out_operation_type,
+                                 Palma::PalmaConnectionHandle connection_handle,
+                                 OutBuffer<BufferAttr_HipcMapAlias> out_data);
+    Result PlayPalmaActivity(Palma::PalmaConnectionHandle connection_handle, u64 palma_activity);
+    Result SetPalmaFrModeType(Palma::PalmaConnectionHandle connection_handle,
+                              Palma::PalmaFrModeType fr_mode);
+    Result ReadPalmaStep(Palma::PalmaConnectionHandle connection_handle);
+    Result EnablePalmaStep(bool is_enabled, Palma::PalmaConnectionHandle connection_handle);
+    Result ResetPalmaStep(Palma::PalmaConnectionHandle connection_handle);
+    Result ReadPalmaApplicationSection(Palma::PalmaConnectionHandle connection_handle, u64 offset,
+                                       u64 size);
+    Result WritePalmaApplicationSection(
+        Palma::PalmaConnectionHandle connection_handle, u64 offset, u64 size,
+        InLargeData<Palma::PalmaApplicationSection, BufferAttr_HipcPointer> data);
+    Result ReadPalmaUniqueCode(Palma::PalmaConnectionHandle connection_handle);
+    Result SetPalmaUniqueCodeInvalid(Palma::PalmaConnectionHandle connection_handle);
+    Result WritePalmaActivityEntry(Palma::PalmaConnectionHandle connection_handle,
+                                   Palma::PalmaActivityEntry activity_entry);
+    Result WritePalmaRgbLedPatternEntry(Palma::PalmaConnectionHandle connection_handle, u64 unknown,
+                                        InBuffer<BufferAttr_HipcMapAlias> led_pattern);
+    Result WritePalmaWaveEntry(Palma::PalmaConnectionHandle connection_handle,
+                               Palma::PalmaWaveSet wave_set, u64 unknown, u64 t_mem_size, u64 size,
+                               InCopyHandle<Kernel::KTransferMemory> t_mem);
+    Result SetPalmaDataBaseIdentificationVersion(s32 database_id_version,
+                                                 Palma::PalmaConnectionHandle connection_handle);
+    Result GetPalmaDataBaseIdentificationVersion(Palma::PalmaConnectionHandle connection_handle);
+    Result SuspendPalmaFeature(Palma::PalmaFeature feature,
+                               Palma::PalmaConnectionHandle connection_handle);
+    Result GetPalmaOperationResult(Palma::PalmaConnectionHandle connection_handle);
+    Result ReadPalmaPlayLog(u16 unknown, Palma::PalmaConnectionHandle connection_handle);
+    Result ResetPalmaPlayLog(u16 unknown, Palma::PalmaConnectionHandle connection_handle);
+    Result SetIsPalmaAllConnectable(bool is_palma_all_connectable, ClientAppletResourceUserId arui);
+    Result SetIsPalmaPairedConnectable(bool is_palma_paired_connectable,
+                                       ClientAppletResourceUserId aruid);
+    Result PairPalma(Palma::PalmaConnectionHandle connection_handle);
+    Result SetPalmaBoostMode(bool is_enabled);
+    Result CancelWritePalmaWaveEntry(Palma::PalmaConnectionHandle connection_handle);
+    Result EnablePalmaBoostMode(bool is_enabled, ClientAppletResourceUserId aruid);
+    Result GetPalmaBluetoothAddress(Out<Palma::Address> out_bt_address,
+                                    Palma::PalmaConnectionHandle connection_handle);
+    Result SetDisallowedPalmaConnection(
+        ClientAppletResourceUserId aruid,
+        InArray<Palma::Address, BufferAttr_HipcPointer> disallowed_address);
+    Result SetNpadCommunicationMode(ClientAppletResourceUserId aruid,
+                                    NpadCommunicationMode communication_mode);
+    Result GetNpadCommunicationMode(Out<NpadCommunicationMode> out_communication_mode,
+                                    ClientAppletResourceUserId aruid);
+    Result SetTouchScreenConfiguration(Core::HID::TouchScreenConfigurationForNx touchscreen_config,
+                                       ClientAppletResourceUserId aruid);
+    Result IsFirmwareUpdateNeededForNotification(Out<bool> out_is_firmware_update_needed,
+                                                 s32 unknown, ClientAppletResourceUserId aruid);
+    Result SetTouchScreenResolution(u32 width, u32 height, ClientAppletResourceUserId aruid);
 
     std::shared_ptr<ResourceManager> resource_manager;
     std::shared_ptr<HidFirmwareSettings> firmware_settings;

src/core/hle/service/ldn/monitor_service.cpp

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 #include "core/hle/service/cmif_serialization.h"
+#include "core/hle/service/ldn/ldn_results.h"
 #include "core/hle/service/ldn/monitor_service.h"
 
 namespace Service::LDN {
@@ -17,7 +18,7 @@ IMonitorService::IMonitorService(Core::System& system_)
         {4, nullptr, "GetSecurityParameterForMonitor"},
         {5, nullptr, "GetNetworkConfigForMonitor"},
         {100, C<&IMonitorService::InitializeMonitor>, "InitializeMonitor"},
-        {101, nullptr, "FinalizeMonitor"},
+        {101, C<&IMonitorService::FinalizeMonitor>, "FinalizeMonitor"},
     };
     // clang-format on
 
@@ -27,16 +28,18 @@ IMonitorService::IMonitorService(Core::System& system_)
 IMonitorService::~IMonitorService() = default;
 
 Result IMonitorService::GetStateForMonitor(Out<State> out_state) {
-    LOG_INFO(Service_LDN, "called");
+    LOG_WARNING(Service_LDN, "(STUBBED) called");
-
+    *out_state = State::None;
-    *out_state = state;
     R_SUCCEED();
 }
 
 Result IMonitorService::InitializeMonitor() {
     LOG_INFO(Service_LDN, "called");
+    R_SUCCEED();
+}
 
-    state = State::Initialized;
+Result IMonitorService::FinalizeMonitor() {
+    LOG_INFO(Service_LDN, "called");
     R_SUCCEED();
 }
 

src/core/hle/service/ldn/monitor_service.h

@@ -21,6 +21,7 @@ public:
 private:
     Result GetStateForMonitor(Out<State> out_state);
     Result InitializeMonitor();
+    Result FinalizeMonitor();
 
     State state{State::None};
 };

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

@@ -5,6 +5,7 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/core.h"
+#include "core/hle/kernel/k_process.h"
 #include "core/hle/service/nvdrv/core/container.h"
 #include "core/hle/service/nvdrv/core/nvmap.h"
 #include "core/hle/service/nvdrv/core/syncpoint_manager.h"
@@ -75,7 +76,7 @@ NvResult nvhost_gpu::Ioctl1(DeviceFD fd, Ioctl command, std::span<const u8> inpu
         case 0xd:
             return WrapFixed(this, &nvhost_gpu::SetChannelPriority, input, output);
         case 0x1a:
-            return WrapFixed(this, &nvhost_gpu::AllocGPFIFOEx2, input, output);
+            return WrapFixed(this, &nvhost_gpu::AllocGPFIFOEx2, input, output, fd);
         case 0x1b:
             return WrapFixedVariable(this, &nvhost_gpu::SubmitGPFIFOBase1, input, output, true);
         case 0x1d:
@@ -120,8 +121,13 @@ NvResult nvhost_gpu::Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> inpu
     return NvResult::NotImplemented;
 }
 
-void nvhost_gpu::OnOpen(NvCore::SessionId session_id, DeviceFD fd) {}
+void nvhost_gpu::OnOpen(NvCore::SessionId session_id, DeviceFD fd) {
-void nvhost_gpu::OnClose(DeviceFD fd) {}
+    sessions[fd] = session_id;
+}
+
+void nvhost_gpu::OnClose(DeviceFD fd) {
+    sessions.erase(fd);
+}
 
 NvResult nvhost_gpu::SetNVMAPfd(IoctlSetNvmapFD& params) {
     LOG_DEBUG(Service_NVDRV, "called, fd={}", params.nvmap_fd);
@@ -161,7 +167,7 @@ NvResult nvhost_gpu::SetChannelPriority(IoctlChannelSetPriority& params) {
     return NvResult::Success;
 }
 
-NvResult nvhost_gpu::AllocGPFIFOEx2(IoctlAllocGpfifoEx2& params) {
+NvResult nvhost_gpu::AllocGPFIFOEx2(IoctlAllocGpfifoEx2& params, DeviceFD fd) {
     LOG_WARNING(Service_NVDRV,
                 "(STUBBED) called, num_entries={:X}, flags={:X}, unk0={:X}, "
                 "unk1={:X}, unk2={:X}, unk3={:X}",
@@ -173,7 +179,12 @@ NvResult nvhost_gpu::AllocGPFIFOEx2(IoctlAllocGpfifoEx2& params) {
         return NvResult::AlreadyAllocated;
     }
 
-    system.GPU().InitChannel(*channel_state);
+    u64 program_id{};
+    if (auto* const session = core.GetSession(sessions[fd]); session != nullptr) {
+        program_id = session->process->GetProgramId();
+    }
+
+    system.GPU().InitChannel(*channel_state, program_id);
 
     params.fence_out = syncpoint_manager.GetSyncpointFence(channel_syncpoint);
 

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

@@ -192,7 +192,7 @@ private:
     NvResult ZCullBind(IoctlZCullBind& params);
     NvResult SetErrorNotifier(IoctlSetErrorNotifier& params);
     NvResult SetChannelPriority(IoctlChannelSetPriority& params);
-    NvResult AllocGPFIFOEx2(IoctlAllocGpfifoEx2& params);
+    NvResult AllocGPFIFOEx2(IoctlAllocGpfifoEx2& params, DeviceFD fd);
     NvResult AllocateObjectContext(IoctlAllocObjCtx& params);
 
     NvResult SubmitGPFIFOImpl(IoctlSubmitGpfifo& params, Tegra::CommandList&& entries);
@@ -210,6 +210,7 @@ private:
     NvCore::SyncpointManager& syncpoint_manager;
     NvCore::NvMap& nvmap;
     std::shared_ptr<Tegra::Control::ChannelState> channel_state;
+    std::unordered_map<DeviceFD, NvCore::SessionId> sessions;
     u32 channel_syncpoint;
     std::mutex channel_mutex;
 

src/core/hle/service/server_manager.cpp

@@ -93,13 +93,19 @@ ServerManager::~ServerManager() {
     m_threads.clear();
 
     // Clean up ports.
-    for (auto it = m_servers.begin(); it != m_servers.end(); it = m_servers.erase(it)) {
+    auto port_it = m_servers.begin();
-        delete std::addressof(*it);
+    while (port_it != m_servers.end()) {
+        auto* const port = std::addressof(*port_it);
+        port_it = m_servers.erase(port_it);
+        delete port;
     }
 
     // Clean up sessions.
-    for (auto it = m_sessions.begin(); it != m_sessions.end(); it = m_sessions.erase(it)) {
+    auto session_it = m_sessions.begin();
-        delete std::addressof(*it);
+    while (session_it != m_sessions.end()) {
+        auto* const session = std::addressof(*session_it);
+        session_it = m_sessions.erase(session_it);
+        delete session;
     }
 
     // Close wakeup event.

src/core/hle/service/set/settings_types.h

@@ -243,6 +243,11 @@ enum class TvResolution : u32 {
     Resolution480p,
 };
 
+enum class PlatformRegion : s32 {
+    Global = 1,
+    Terra = 2,
+};
+
 constexpr std::array<LanguageCode, 18> available_language_codes = {{
     LanguageCode::JA,
     LanguageCode::EN_US,

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

@@ -272,8 +272,8 @@ ISystemSettingsServer::ISystemSettingsServer(Core::System& system_)
         {180, nullptr, "SetZoomFlag"},
         {181, nullptr, "GetT"},
         {182, nullptr, "SetT"},
-        {183, nullptr, "GetPlatformRegion"},
+        {183, C<&ISystemSettingsServer::GetPlatformRegion>, "GetPlatformRegion"},
-        {184, nullptr, "SetPlatformRegion"},
+        {184, C<&ISystemSettingsServer::SetPlatformRegion>, "SetPlatformRegion"},
         {185, C<&ISystemSettingsServer::GetHomeMenuSchemeModel>, "GetHomeMenuSchemeModel"},
         {186, nullptr, "GetMemoryUsageRateFlag"},
         {187, C<&ISystemSettingsServer::GetTouchScreenMode>, "GetTouchScreenMode"},
@@ -1250,6 +1250,18 @@ Result ISystemSettingsServer::GetHomeMenuScheme(Out<HomeMenuScheme> out_home_men
     R_SUCCEED();
 }
 
+Result ISystemSettingsServer::GetPlatformRegion(Out<PlatformRegion> out_platform_region) {
+    LOG_WARNING(Service_SET, "(STUBBED) called");
+
+    *out_platform_region = PlatformRegion::Global;
+    R_SUCCEED();
+}
+
+Result ISystemSettingsServer::SetPlatformRegion(PlatformRegion platform_region) {
+    LOG_WARNING(Service_SET, "(STUBBED) called");
+    R_SUCCEED();
+}
+
 Result ISystemSettingsServer::GetHomeMenuSchemeModel(Out<u32> out_home_menu_scheme_model) {
     LOG_WARNING(Service_SET, "(STUBBED) called");
 

src/core/hle/service/set/system_settings_server.h

@@ -149,6 +149,8 @@ public:
     Result GetHomeMenuScheme(Out<HomeMenuScheme> out_home_menu_scheme);
     Result GetHomeMenuSchemeModel(Out<u32> out_home_menu_scheme_model);
     Result GetTouchScreenMode(Out<TouchScreenMode> out_touch_screen_mode);
+    Result GetPlatformRegion(Out<PlatformRegion> out_platform_region);
+    Result SetPlatformRegion(PlatformRegion platform_region);
     Result SetTouchScreenMode(TouchScreenMode touch_screen_mode);
     Result GetFieldTestingFlag(Out<bool> out_field_testing_flag);
     Result GetPanelCrcMode(Out<s32> out_panel_crc_mode);

src/core/hle/service/ssl/cert_store.cpp

@@ -0,0 +1,156 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/alignment.h"
+#include "core/core.h"
+#include "core/file_sys/content_archive.h"
+#include "core/file_sys/nca_metadata.h"
+#include "core/file_sys/registered_cache.h"
+#include "core/file_sys/romfs.h"
+#include "core/hle/service/filesystem/filesystem.h"
+#include "core/hle/service/ssl/cert_store.h"
+
+namespace Service::SSL {
+
+// https://switchbrew.org/wiki/SSL_services#CertStore
+
+CertStore::CertStore(Core::System& system) {
+    constexpr u64 CertStoreDataId = 0x0100000000000800ULL;
+
+    auto& fsc = system.GetFileSystemController();
+
+    // Attempt to load certificate data from storage
+    const auto nca =
+        fsc.GetSystemNANDContents()->GetEntry(CertStoreDataId, FileSys::ContentRecordType::Data);
+    if (!nca) {
+        return;
+    }
+    const auto romfs = nca->GetRomFS();
+    if (!romfs) {
+        return;
+    }
+    const auto extracted = FileSys::ExtractRomFS(romfs);
+    if (!extracted) {
+        LOG_ERROR(Service_SSL, "CertStore could not be extracted, corrupt RomFS?");
+        return;
+    }
+    const auto cert_store_file = extracted->GetFile("ssl_TrustedCerts.bdf");
+    if (!cert_store_file) {
+        LOG_ERROR(Service_SSL, "Failed to find trusted certificates in CertStore");
+        return;
+    }
+
+    // Read and verify the header.
+    CertStoreHeader header;
+    cert_store_file->ReadObject(std::addressof(header));
+
+    if (header.magic != Common::MakeMagic('s', 's', 'l', 'T')) {
+        LOG_ERROR(Service_SSL, "Invalid certificate store magic");
+        return;
+    }
+
+    // Ensure the file can contains the number of entries it says it does.
+    const u64 expected_size = sizeof(header) + sizeof(CertStoreEntry) * header.num_entries;
+    const u64 actual_size = cert_store_file->GetSize();
+    if (actual_size < expected_size) {
+        LOG_ERROR(Service_SSL, "Size mismatch, expected at least {} bytes, got {}", expected_size,
+                  actual_size);
+        return;
+    }
+
+    // Read entries.
+    std::vector<CertStoreEntry> entries(header.num_entries);
+    cert_store_file->ReadArray(entries.data(), header.num_entries, sizeof(header));
+
+    // Insert into memory store.
+    for (const auto& entry : entries) {
+        m_certs.emplace(entry.certificate_id,
+                        Certificate{
+                            .status = entry.certificate_status,
+                            .der_data = cert_store_file->ReadBytes(
+                                entry.der_size, entry.der_offset + sizeof(header)),
+                        });
+    }
+}
+
+CertStore::~CertStore() = default;
+
+template <typename F>
+void CertStore::ForEachCertificate(std::span<const CaCertificateId> certificate_ids, F&& f) {
+    if (certificate_ids.size() == 1 && certificate_ids.front() == CaCertificateId::All) {
+        for (const auto& entry : m_certs) {
+            f(entry);
+        }
+    } else {
+        for (const auto certificate_id : certificate_ids) {
+            const auto entry = m_certs.find(certificate_id);
+            if (entry == m_certs.end()) {
+                continue;
+            }
+            f(*entry);
+        }
+    }
+}
+
+Result CertStore::GetCertificates(u32* out_num_entries, std::span<u8> out_data,
+                                  std::span<const CaCertificateId> certificate_ids) {
+    // Ensure the buffer is large enough to hold the output.
+    u32 required_size;
+    R_TRY(this->GetCertificateBufSize(std::addressof(required_size), out_num_entries,
+                                      certificate_ids));
+    R_UNLESS(out_data.size_bytes() >= required_size, ResultUnknown);
+
+    // Make parallel arrays.
+    std::vector<BuiltInCertificateInfo> cert_infos;
+    std::vector<u8> der_datas;
+
+    const u32 der_data_offset = (*out_num_entries + 1) * sizeof(BuiltInCertificateInfo);
+    u32 cur_der_offset = der_data_offset;
+
+    // Fill output.
+    this->ForEachCertificate(certificate_ids, [&](auto& entry) {
+        const auto& [status, cur_der_data] = entry.second;
+        BuiltInCertificateInfo cert_info{
+            .cert_id = entry.first,
+            .status = status,
+            .der_size = cur_der_data.size(),
+            .der_offset = cur_der_offset,
+        };
+
+        cert_infos.push_back(cert_info);
+        der_datas.insert(der_datas.end(), cur_der_data.begin(), cur_der_data.end());
+        cur_der_offset += static_cast<u32>(cur_der_data.size());
+    });
+
+    // Append terminator entry.
+    cert_infos.push_back(BuiltInCertificateInfo{
+        .cert_id = CaCertificateId::All,
+        .status = TrustedCertStatus::Invalid,
+        .der_size = 0,
+        .der_offset = 0,
+    });
+
+    // Write to output span.
+    std::memcpy(out_data.data(), cert_infos.data(),
+                cert_infos.size() * sizeof(BuiltInCertificateInfo));
+    std::memcpy(out_data.data() + der_data_offset, der_datas.data(), der_datas.size());
+
+    R_SUCCEED();
+}
+
+Result CertStore::GetCertificateBufSize(u32* out_size, u32* out_num_entries,
+                                        std::span<const CaCertificateId> certificate_ids) {
+    // Output size is at least the size of the terminator entry.
+    *out_size = sizeof(BuiltInCertificateInfo);
+    *out_num_entries = 0;
+
+    this->ForEachCertificate(certificate_ids, [&](auto& entry) {
+        *out_size += sizeof(BuiltInCertificateInfo);
+        *out_size += Common::AlignUp(static_cast<u32>(entry.second.der_data.size()), 4);
+        (*out_num_entries)++;
+    });
+
+    R_SUCCEED();
+}
+
+} // namespace Service::SSL

src/core/hle/service/ssl/cert_store.h

@@ -0,0 +1,42 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <map>
+#include <span>
+#include <vector>
+
+#include "core/hle/result.h"
+#include "core/hle/service/ssl/ssl_types.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::SSL {
+
+class CertStore {
+public:
+    explicit CertStore(Core::System& system);
+    ~CertStore();
+
+    Result GetCertificates(u32* out_num_entries, std::span<u8> out_data,
+                           std::span<const CaCertificateId> certificate_ids);
+    Result GetCertificateBufSize(u32* out_size, u32* out_num_entries,
+                                 std::span<const CaCertificateId> certificate_ids);
+
+private:
+    template <typename F>
+    void ForEachCertificate(std::span<const CaCertificateId> certs, F&& f);
+
+private:
+    struct Certificate {
+        TrustedCertStatus status;
+        std::vector<u8> der_data;
+    };
+
+    std::map<CaCertificateId, Certificate> m_certs;
+};
+
+} // namespace Service::SSL

src/core/hle/service/ssl/ssl.cpp

@@ -5,11 +5,13 @@
 
 #include "core/core.h"
 #include "core/hle/result.h"
+#include "core/hle/service/cmif_serialization.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
 #include "core/hle/service/sockets/bsd.h"
+#include "core/hle/service/ssl/cert_store.h"
 #include "core/hle/service/ssl/ssl.h"
 #include "core/hle/service/ssl/ssl_backend.h"
 #include "core/internal_network/network.h"
@@ -492,13 +494,14 @@ private:
 
 class ISslService final : public ServiceFramework<ISslService> {
 public:
-    explicit ISslService(Core::System& system_) : ServiceFramework{system_, "ssl"} {
+    explicit ISslService(Core::System& system_)
+        : ServiceFramework{system_, "ssl"}, cert_store{system} {
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, &ISslService::CreateContext, "CreateContext"},
             {1, nullptr, "GetContextCount"},
-            {2, nullptr, "GetCertificates"},
+            {2, D<&ISslService::GetCertificates>, "GetCertificates"},
-            {3, nullptr, "GetCertificateBufSize"},
+            {3, D<&ISslService::GetCertificateBufSize>, "GetCertificateBufSize"},
             {4, nullptr, "DebugIoctl"},
             {5, &ISslService::SetInterfaceVersion, "SetInterfaceVersion"},
             {6, nullptr, "FlushSessionCache"},
@@ -540,6 +543,22 @@ private:
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(ResultSuccess);
     }
+
+    Result GetCertificateBufSize(
+        Out<u32> out_size, InArray<CaCertificateId, BufferAttr_HipcMapAlias> certificate_ids) {
+        LOG_INFO(Service_SSL, "called");
+        u32 num_entries;
+        R_RETURN(cert_store.GetCertificateBufSize(out_size, &num_entries, certificate_ids));
+    }
+
+    Result GetCertificates(Out<u32> out_num_entries, OutBuffer<BufferAttr_HipcMapAlias> out_buffer,
+                           InArray<CaCertificateId, BufferAttr_HipcMapAlias> certificate_ids) {
+        LOG_INFO(Service_SSL, "called");
+        R_RETURN(cert_store.GetCertificates(out_num_entries, out_buffer, certificate_ids));
+    }
+
+private:
+    CertStore cert_store;
 };
 
 void LoopProcess(Core::System& system) {

src/core/hle/service/ssl/ssl_types.h

@@ -0,0 +1,107 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/common_types.h"
+
+namespace Service::SSL {
+
+enum class CaCertificateId : s32 {
+    All = -1,
+    NintendoCAG3 = 1,
+    NintendoClass2CAG3 = 2,
+    NintendoRootCAG4 = 3,
+    AmazonRootCA1 = 1000,
+    StarfieldServicesRootCertificateAuthorityG2 = 1001,
+    AddTrustExternalCARoot = 1002,
+    COMODOCertificationAuthority = 1003,
+    UTNDATACorpSGC = 1004,
+    UTNUSERFirstHardware = 1005,
+    BaltimoreCyberTrustRoot = 1006,
+    CybertrustGlobalRoot = 1007,
+    VerizonGlobalRootCA = 1008,
+    DigiCertAssuredIDRootCA = 1009,
+    DigiCertAssuredIDRootG2 = 1010,
+    DigiCertGlobalRootCA = 1011,
+    DigiCertGlobalRootG2 = 1012,
+    DigiCertHighAssuranceEVRootCA = 1013,
+    EntrustnetCertificationAuthority2048 = 1014,
+    EntrustRootCertificationAuthority = 1015,
+    EntrustRootCertificationAuthorityG2 = 1016,
+    GeoTrustGlobalCA2 = 1017,
+    GeoTrustGlobalCA = 1018,
+    GeoTrustPrimaryCertificationAuthorityG3 = 1019,
+    GeoTrustPrimaryCertificationAuthority = 1020,
+    GlobalSignRootCA = 1021,
+    GlobalSignRootCAR2 = 1022,
+    GlobalSignRootCAR3 = 1023,
+    GoDaddyClass2CertificationAuthority = 1024,
+    GoDaddyRootCertificateAuthorityG2 = 1025,
+    StarfieldClass2CertificationAuthority = 1026,
+    StarfieldRootCertificateAuthorityG2 = 1027,
+    thawtePrimaryRootCAG3 = 1028,
+    thawtePrimaryRootCA = 1029,
+    VeriSignClass3PublicPrimaryCertificationAuthorityG3 = 1030,
+    VeriSignClass3PublicPrimaryCertificationAuthorityG5 = 1031,
+    VeriSignUniversalRootCertificationAuthority = 1032,
+    DSTRootCAX3 = 1033,
+    USERTrustRsaCertificationAuthority = 1034,
+    ISRGRootX10 = 1035,
+    USERTrustEccCertificationAuthority = 1036,
+    COMODORsaCertificationAuthority = 1037,
+    COMODOEccCertificationAuthority = 1038,
+    AmazonRootCA2 = 1039,
+    AmazonRootCA3 = 1040,
+    AmazonRootCA4 = 1041,
+    DigiCertAssuredIDRootG3 = 1042,
+    DigiCertGlobalRootG3 = 1043,
+    DigiCertTrustedRootG4 = 1044,
+    EntrustRootCertificationAuthorityEC1 = 1045,
+    EntrustRootCertificationAuthorityG4 = 1046,
+    GlobalSignECCRootCAR4 = 1047,
+    GlobalSignECCRootCAR5 = 1048,
+    GlobalSignECCRootCAR6 = 1049,
+    GTSRootR1 = 1050,
+    GTSRootR2 = 1051,
+    GTSRootR3 = 1052,
+    GTSRootR4 = 1053,
+    SecurityCommunicationRootCA = 1054,
+    GlobalSignRootE4 = 1055,
+    GlobalSignRootR4 = 1056,
+    TTeleSecGlobalRootClass2 = 1057,
+    DigiCertTLSECCP384RootG5 = 1058,
+    DigiCertTLSRSA4096RootG5 = 1059,
+};
+
+enum class TrustedCertStatus : s32 {
+    Invalid = -1,
+    Removed = 0,
+    EnabledTrusted = 1,
+    EnabledNotTrusted = 2,
+    Revoked = 3,
+};
+
+struct BuiltInCertificateInfo {
+    CaCertificateId cert_id;
+    TrustedCertStatus status;
+    u64 der_size;
+    u64 der_offset;
+};
+static_assert(sizeof(BuiltInCertificateInfo) == 0x18, "BuiltInCertificateInfo has incorrect size.");
+
+struct CertStoreHeader {
+    u32 magic;
+    u32 num_entries;
+};
+static_assert(sizeof(CertStoreHeader) == 0x8, "CertStoreHeader has incorrect size.");
+
+struct CertStoreEntry {
+    CaCertificateId certificate_id;
+    TrustedCertStatus certificate_status;
+    u32 der_size;
+    u32 der_offset;
+};
+static_assert(sizeof(CertStoreEntry) == 0x10, "CertStoreEntry has incorrect size.");
+
+} // namespace Service::SSL

src/hid_core/frontend/emulated_controller.cpp

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <algorithm>
+#include <chrono>
 #include <common/scope_exit.h>
 
 #include "common/polyfill_ranges.h"
@@ -175,10 +176,9 @@ void EmulatedController::LoadDevices() {
     if (npad_id_type == NpadIdType::Player1 || npad_id_type == NpadIdType::Handheld) {
         camera_params[1] = Common::ParamPackage{"engine:camera,camera:1"};
         nfc_params[0] = Common::ParamPackage{"engine:virtual_amiibo,nfc:1"};
-#ifdef HAVE_LIBUSB
+#ifndef ANDROID
         ring_params[1] = Common::ParamPackage{"engine:joycon,axis_x:100,axis_y:101"};
-#endif
+#else
-#ifdef ANDROID
         android_params = Common::ParamPackage{"engine:android,port:100"};
 #endif
     }
@@ -1287,6 +1287,22 @@ bool EmulatedController::SetVibration(DeviceIndex device_index, const VibrationV
         return false;
     }
 
+    if (!Settings::values.enable_accurate_vibrations.GetValue()) {
+        using std::chrono::duration_cast;
+        using std::chrono::milliseconds;
+        using std::chrono::steady_clock;
+
+        const auto now = steady_clock::now();
+
+        // Filter out non-zero vibrations that are within 15ms of each other.
+        if ((vibration.low_amplitude != 0.0f || vibration.high_amplitude != 0.0f) &&
+            duration_cast<milliseconds>(now - last_vibration_timepoint[index]) < milliseconds(15)) {
+            return false;
+        }
+
+        last_vibration_timepoint[index] = now;
+    }
+
     // Exponential amplification is too strong at low amplitudes. Switch to a linear
     // amplification if strength is set below 0.7f
     const Common::Input::VibrationAmplificationType type =

src/hid_core/frontend/emulated_controller.h

@@ -583,6 +583,7 @@ private:
     std::size_t nfc_handles{0};
     std::array<VibrationValue, 2> last_vibration_value{DEFAULT_VIBRATION_VALUE,
                                                        DEFAULT_VIBRATION_VALUE};
+    std::array<std::chrono::steady_clock::time_point, 2> last_vibration_timepoint{};
 
     // Temporary values to avoid doing changes while the controller is in configuring mode
     NpadStyleIndex tmp_npad_type{NpadStyleIndex::None};

src/hid_core/hid_types.h

@@ -565,36 +565,28 @@ static_assert(sizeof(SixAxisSensorProperties) == 1, "SixAxisSensorProperties is
 
 // This is nn::hid::SixAxisSensorCalibrationParameter
 struct SixAxisSensorCalibrationParameter {
-    std::array<u8, 0x744> unknown_data{};
+    std::array<u8, 0x744> unknown_data;
 };
 static_assert(sizeof(SixAxisSensorCalibrationParameter) == 0x744,
               "SixAxisSensorCalibrationParameter is an invalid size");
+static_assert(std::is_trivial_v<SixAxisSensorCalibrationParameter>,
+              "SixAxisSensorCalibrationParameter must be trivial.");
 
 // This is nn::hid::SixAxisSensorIcInformation
 struct SixAxisSensorIcInformation {
-    f32 angular_rate{2000.0f}; // dps
+    f32 angular_rate;                      // dps
-    std::array<f32, 6> unknown_gyro_data1{
+    std::array<f32, 6> unknown_gyro_data1; // dps
-        -10.0f, -10.0f, -10.0f, 10.0f, 10.0f, 10.0f,
+    std::array<f32, 9> unknown_gyro_data2;
-    }; // dps
+    std::array<f32, 9> unknown_gyro_data3;
-    std::array<f32, 9> unknown_gyro_data2{
+    f32 acceleration_range;                 // g force
-        0.95f, -0.003f, -0.003f, -0.003f, 0.95f, -0.003f, -0.003f, -0.003f, 0.95f,
+    std::array<f32, 6> unknown_accel_data1; // g force
-    };
+    std::array<f32, 9> unknown_accel_data2;
-    std::array<f32, 9> unknown_gyro_data3{
+    std::array<f32, 9> unknown_accel_data3;
-        1.05f, 0.003f, 0.003f, 0.003f, 1.05f, 0.003f, 0.003f, 0.003f, 1.05f,
-    };
-    f32 acceleration_range{8.0f}; // g force
-    std::array<f32, 6> unknown_accel_data1{
-        -0.0612f, -0.0612f, -0.0612f, 0.0612f, 0.0612f, 0.0612f,
-    }; // g force
-    std::array<f32, 9> unknown_accel_data2{
-        0.95f, -0.003f, -0.003f, -0.003f, 0.95f, -0.003f, -0.003f, -0.003f, 0.95f,
-    };
-    std::array<f32, 9> unknown_accel_data3{
-        1.05f, 0.003f, 0.003f, 0.003f, 1.05f, 0.003f, 0.003f, 0.003f, 1.05f,
-    };
 };
 static_assert(sizeof(SixAxisSensorIcInformation) == 0xC8,
               "SixAxisSensorIcInformation is an invalid size");
+static_assert(std::is_trivial_v<SixAxisSensorIcInformation>,
+              "SixAxisSensorIcInformation must be trivial.");
 
 // This is nn::hid::SixAxisSensorAttribute
 struct SixAxisSensorAttribute {
@@ -638,7 +630,11 @@ struct VibrationValue {
         if (low_amplitude != b.low_amplitude || high_amplitude != b.high_amplitude) {
             return false;
         }
-        if (low_frequency != b.low_amplitude || high_frequency != b.high_frequency) {
+        // Changes in frequency without amplitude don't have any effect
+        if (low_amplitude == 0 && high_amplitude == 0) {
+            return true;
+        }
+        if (low_frequency != b.low_frequency || high_frequency != b.high_frequency) {
             return false;
         }
         return true;

src/hid_core/resource_manager.cpp

@@ -4,7 +4,6 @@
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/core_timing.h"
-#include "core/hle/kernel/k_shared_memory.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/set/system_settings_server.h"
 #include "core/hle/service/sm/sm.h"
@@ -501,29 +500,4 @@ void ResourceManager::UpdateMotion(std::chrono::nanoseconds ns_late) {
     console_six_axis->OnUpdate(core_timing);
 }
 
-IAppletResource::IAppletResource(Core::System& system_, std::shared_ptr<ResourceManager> resource,
-                                 u64 applet_resource_user_id)
-    : ServiceFramework{system_, "IAppletResource"}, aruid{applet_resource_user_id},
-      resource_manager{resource} {
-    static const FunctionInfo functions[] = {
-        {0, &IAppletResource::GetSharedMemoryHandle, "GetSharedMemoryHandle"},
-    };
-    RegisterHandlers(functions);
-}
-
-IAppletResource::~IAppletResource() {
-    resource_manager->FreeAppletResourceId(aruid);
-}
-
-void IAppletResource::GetSharedMemoryHandle(HLERequestContext& ctx) {
-    Kernel::KSharedMemory* handle;
-    const auto result = resource_manager->GetSharedMemoryHandle(&handle, aruid);
-
-    LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}, result=0x{:X}", aruid, result.raw);
-
-    IPC::ResponseBuilder rb{ctx, 2, 1};
-    rb.Push(result);
-    rb.PushCopyObjects(handle);
-}
-
 } // namespace Service::HID

src/hid_core/resource_manager.h

@@ -174,17 +174,4 @@ private:
     KernelHelpers::ServiceContext service_context;
 };
 
-class IAppletResource final : public ServiceFramework<IAppletResource> {
-public:
-    explicit IAppletResource(Core::System& system_, std::shared_ptr<ResourceManager> resource,
-                             u64 applet_resource_user_id);
-    ~IAppletResource() override;
-
-private:
-    void GetSharedMemoryHandle(HLERequestContext& ctx);
-
-    u64 aruid{};
-    std::shared_ptr<ResourceManager> resource_manager;
-};
-
 } // namespace Service::HID

src/hid_core/resources/npad/npad.cpp

@@ -3,7 +3,6 @@
 
 #include <algorithm>
 #include <array>
-#include <chrono>
 #include <cstring>
 
 #include "common/assert.h"

src/hid_core/resources/palma/palma.cpp

@@ -56,12 +56,14 @@ Kernel::KReadableEvent& Palma::AcquirePalmaOperationCompleteEvent(
 
 Result Palma::GetPalmaOperationInfo(const PalmaConnectionHandle& handle,
                                     PalmaOperationType& operation_type,
-                                    PalmaOperationData& data) const {
+                                    std::span<u8> out_data) const {
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
-    operation_type = operation.operation;
+    operation_type = static_cast<PalmaOperationType>(operation.operation);
-    data = operation.data;
+    std::memcpy(out_data.data(), operation.data.data(),
+                std::min(out_data.size(), operation.data.size()));
+
     return ResultSuccess;
 }
 
@@ -69,7 +71,7 @@ Result Palma::PlayPalmaActivity(const PalmaConnectionHandle& handle, u64 palma_a
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
-    operation.operation = PalmaOperationType::PlayActivity;
+    operation.operation = PackedPalmaOperationType::PlayActivity;
     operation.result = PalmaResultSuccess;
     operation.data = {};
     operation_complete_event->Signal();
@@ -88,7 +90,7 @@ Result Palma::ReadPalmaStep(const PalmaConnectionHandle& handle) {
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
-    operation.operation = PalmaOperationType::ReadStep;
+    operation.operation = PackedPalmaOperationType::ReadStep;
     operation.result = PalmaResultSuccess;
     operation.data = {};
     operation_complete_event->Signal();
@@ -117,7 +119,7 @@ Result Palma::ReadPalmaUniqueCode(const PalmaConnectionHandle& handle) {
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
-    operation.operation = PalmaOperationType::ReadUniqueCode;
+    operation.operation = PackedPalmaOperationType::ReadUniqueCode;
     operation.result = PalmaResultSuccess;
     operation.data = {};
     operation_complete_event->Signal();
@@ -128,7 +130,7 @@ Result Palma::SetPalmaUniqueCodeInvalid(const PalmaConnectionHandle& handle) {
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
-    operation.operation = PalmaOperationType::SetUniqueCodeInvalid;
+    operation.operation = PackedPalmaOperationType::SetUniqueCodeInvalid;
     operation.result = PalmaResultSuccess;
     operation.data = {};
     operation_complete_event->Signal();
@@ -141,7 +143,7 @@ Result Palma::WritePalmaRgbLedPatternEntry(const PalmaConnectionHandle& handle,
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
-    operation.operation = PalmaOperationType::WriteRgbLedPatternEntry;
+    operation.operation = PackedPalmaOperationType::WriteRgbLedPatternEntry;
     operation.result = PalmaResultSuccess;
     operation.data = {};
     operation_complete_event->Signal();
@@ -153,7 +155,7 @@ Result Palma::WritePalmaWaveEntry(const PalmaConnectionHandle& handle, PalmaWave
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
-    operation.operation = PalmaOperationType::WriteWaveEntry;
+    operation.operation = PackedPalmaOperationType::WriteWaveEntry;
     operation.result = PalmaResultSuccess;
     operation.data = {};
     operation_complete_event->Signal();
@@ -166,7 +168,7 @@ Result Palma::SetPalmaDataBaseIdentificationVersion(const PalmaConnectionHandle&
         return InvalidPalmaHandle;
     }
     database_id_version = database_id_version_;
-    operation.operation = PalmaOperationType::ReadDataBaseIdentificationVersion;
+    operation.operation = PackedPalmaOperationType::ReadDataBaseIdentificationVersion;
     operation.result = PalmaResultSuccess;
     operation.data[0] = {};
     operation_complete_event->Signal();
@@ -177,7 +179,7 @@ Result Palma::GetPalmaDataBaseIdentificationVersion(const PalmaConnectionHandle&
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
-    operation.operation = PalmaOperationType::ReadDataBaseIdentificationVersion;
+    operation.operation = PackedPalmaOperationType::ReadDataBaseIdentificationVersion;
     operation.result = PalmaResultSuccess;
     operation.data = {};
     operation.data[0] = static_cast<u8>(database_id_version);

src/hid_core/resources/palma/palma.h

@@ -4,6 +4,8 @@
 #pragma once
 
 #include <array>
+#include <span>
+
 #include "common/common_funcs.h"
 #include "common/typed_address.h"
 #include "hid_core/hid_result.h"
@@ -27,9 +29,31 @@ namespace Service::HID {
 class Palma final : public ControllerBase {
 public:
     using PalmaOperationData = std::array<u8, 0x140>;
+    using PalmaApplicationSection = std::array<u8, 0x100>;
+    using Address = std::array<u8, 0x6>;
 
     // This is nn::hid::PalmaOperationType
-    enum class PalmaOperationType {
+    enum class PalmaOperationType : u64 {
+        PlayActivity,
+        SetFrModeType,
+        ReadStep,
+        EnableStep,
+        ResetStep,
+        ReadApplicationSection,
+        WriteApplicationSection,
+        ReadUniqueCode,
+        SetUniqueCodeInvalid,
+        WriteActivityEntry,
+        WriteRgbLedPatternEntry,
+        WriteWaveEntry,
+        ReadDataBaseIdentificationVersion,
+        WriteDataBaseIdentificationVersion,
+        SuspendFeature,
+        ReadPlayLog,
+        ResetPlayLog,
+    };
+
+    enum class PackedPalmaOperationType : u32 {
         PlayActivity,
         SetFrModeType,
         ReadStep,
@@ -75,7 +99,7 @@ public:
 
     // This is nn::hid::PalmaOperationInfo
     struct PalmaOperationInfo {
-        PalmaOperationType operation{};
+        PackedPalmaOperationType operation{};
         Result result{PalmaResultSuccess};
         PalmaOperationData data{};
     };
@@ -92,8 +116,7 @@ public:
     static_assert(sizeof(PalmaActivityEntry) == 0x20, "PalmaActivityEntry is an invalid size");
 
     struct PalmaConnectionHandle {
-        Core::HID::NpadIdType npad_id;
+        alignas(8) Core::HID::NpadIdType npad_id;
-        INSERT_PADDING_BYTES(4); // Unknown
     };
     static_assert(sizeof(PalmaConnectionHandle) == 0x8,
                   "PalmaConnectionHandle has incorrect size.");
@@ -115,8 +138,7 @@ public:
     Kernel::KReadableEvent& AcquirePalmaOperationCompleteEvent(
         const PalmaConnectionHandle& handle) const;
     Result GetPalmaOperationInfo(const PalmaConnectionHandle& handle,
-                                 PalmaOperationType& operation_type,
+                                 PalmaOperationType& operation_type, std::span<u8> out_data) const;
-                                 PalmaOperationData& data) const;
     Result PlayPalmaActivity(const PalmaConnectionHandle& handle, u64 palma_activity);
     Result SetPalmaFrModeType(const PalmaConnectionHandle& handle, PalmaFrModeType fr_mode_);
     Result ReadPalmaStep(const PalmaConnectionHandle& handle);

src/video_core/buffer_cache/buffer_cache.h

@@ -1488,7 +1488,10 @@ void BufferCache<P>::ImmediateUploadMemory([[maybe_unused]] Buffer& buffer,
             std::span<const u8> upload_span;
             const DAddr device_addr = buffer.CpuAddr() + copy.dst_offset;
             if (IsRangeGranular(device_addr, copy.size)) {
-                upload_span = std::span(device_memory.GetPointer<u8>(device_addr), copy.size);
+                auto* const ptr = device_memory.GetPointer<u8>(device_addr);
+                if (ptr != nullptr) {
+                    upload_span = std::span(ptr, copy.size);
+                }
             } else {
                 if (immediate_buffer.empty()) {
                     immediate_buffer = ImmediateBuffer(largest_copy);

src/video_core/buffer_cache/usage_tracker.h

@@ -26,6 +26,9 @@ public:
     void Track(u64 offset, u64 size) noexcept {
         const size_t page = offset >> PAGE_SHIFT;
         const size_t page_end = (offset + size) >> PAGE_SHIFT;
+        if (page_end < page || page_end >= pages.size()) {
+            return;
+        }
         TrackPage(page, offset, size);
         if (page == page_end) {
             return;
@@ -41,6 +44,9 @@ public:
     [[nodiscard]] bool IsUsed(u64 offset, u64 size) const noexcept {
         const size_t page = offset >> PAGE_SHIFT;
         const size_t page_end = (offset + size) >> PAGE_SHIFT;
+        if (page_end < page || page_end >= pages.size()) {
+            return false;
+        }
         if (IsPageUsed(page, offset, size)) {
             return true;
         }

src/video_core/control/channel_state.cpp

@@ -16,8 +16,9 @@ namespace Tegra::Control {
 
 ChannelState::ChannelState(s32 bind_id_) : bind_id{bind_id_}, initialized{} {}
 
-void ChannelState::Init(Core::System& system, GPU& gpu) {
+void ChannelState::Init(Core::System& system, GPU& gpu, u64 program_id_) {
     ASSERT(memory_manager);
+    program_id = program_id_;
     dma_pusher = std::make_unique<Tegra::DmaPusher>(system, gpu, *memory_manager, *this);
     maxwell_3d = std::make_unique<Engines::Maxwell3D>(system, *memory_manager);
     fermi_2d = std::make_unique<Engines::Fermi2D>(*memory_manager);

src/video_core/control/channel_state.h

@@ -40,11 +40,12 @@ struct ChannelState {
     ChannelState(ChannelState&& other) noexcept = default;
     ChannelState& operator=(ChannelState&& other) noexcept = default;
 
-    void Init(Core::System& system, GPU& gpu);
+    void Init(Core::System& system, GPU& gpu, u64 program_id);
 
     void BindRasterizer(VideoCore::RasterizerInterface* rasterizer);
 
     s32 bind_id = -1;
+    u64 program_id = 0;
     /// 3D engine
     std::unique_ptr<Engines::Maxwell3D> maxwell_3d;
     /// 2D engine

src/video_core/control/channel_state_cache.cpp

@@ -7,7 +7,7 @@ namespace VideoCommon {
 
 ChannelInfo::ChannelInfo(Tegra::Control::ChannelState& channel_state)
     : maxwell3d{*channel_state.maxwell_3d}, kepler_compute{*channel_state.kepler_compute},
-      gpu_memory{*channel_state.memory_manager} {}
+      gpu_memory{*channel_state.memory_manager}, program_id{channel_state.program_id} {}
 
 template class VideoCommon::ChannelSetupCaches<VideoCommon::ChannelInfo>;
 

src/video_core/control/channel_state_cache.h

@@ -39,6 +39,7 @@ public:
     Tegra::Engines::Maxwell3D& maxwell3d;
     Tegra::Engines::KeplerCompute& kepler_compute;
     Tegra::MemoryManager& gpu_memory;
+    u64 program_id;
 };
 
 template <class P>
@@ -77,9 +78,10 @@ protected:
     P* channel_state;
     size_t current_channel_id{UNSET_CHANNEL};
     size_t current_address_space{};
-    Tegra::Engines::Maxwell3D* maxwell3d;
+    Tegra::Engines::Maxwell3D* maxwell3d{};
-    Tegra::Engines::KeplerCompute* kepler_compute;
+    Tegra::Engines::KeplerCompute* kepler_compute{};
-    Tegra::MemoryManager* gpu_memory;
+    Tegra::MemoryManager* gpu_memory{};
+    u64 program_id{};
 
     std::deque<P> channel_storage;
     std::deque<size_t> free_channel_ids;

src/video_core/control/channel_state_cache.inc

@@ -58,6 +58,7 @@ void ChannelSetupCaches<P>::BindToChannel(s32 id) {
     maxwell3d = &channel_state->maxwell3d;
     kepler_compute = &channel_state->kepler_compute;
     gpu_memory = &channel_state->gpu_memory;
+    program_id = channel_state->program_id;
     current_address_space = gpu_memory->GetID();
 }
 
@@ -76,6 +77,7 @@ void ChannelSetupCaches<P>::EraseChannel(s32 id) {
         maxwell3d = nullptr;
         kepler_compute = nullptr;
         gpu_memory = nullptr;
+        program_id = 0;
     } else if (current_channel_id != UNSET_CHANNEL) {
         channel_state = &channel_storage[current_channel_id];
     }

src/video_core/engines/draw_manager.cpp

@@ -216,14 +216,11 @@ void DrawManager::DrawTexture() {
     const bool lower_left{regs.window_origin.mode !=
                           Maxwell3D::Regs::WindowOrigin::Mode::UpperLeft};
     if (lower_left) {
-        draw_texture_state.dst_y0 -= dst_height;
+        draw_texture_state.dst_y0 =
+            static_cast<f32>(regs.surface_clip.height) - draw_texture_state.dst_y0;
     }
-    draw_texture_state.dst_x1 =
+    draw_texture_state.dst_x1 = draw_texture_state.dst_x0 + dst_width;
-        draw_texture_state.dst_x0 +
+    draw_texture_state.dst_y1 = draw_texture_state.dst_y0 + dst_height;
-        static_cast<f32>(Settings::values.resolution_info.ScaleUp(static_cast<u32>(dst_width)));
-    draw_texture_state.dst_y1 =
-        draw_texture_state.dst_y0 +
-        static_cast<f32>(Settings::values.resolution_info.ScaleUp(static_cast<u32>(dst_height)));
     draw_texture_state.src_x0 = static_cast<float>(regs.draw_texture.src_x0) / 4096.f;
     draw_texture_state.src_y0 = static_cast<float>(regs.draw_texture.src_y0) / 4096.f;
     draw_texture_state.src_x1 =

src/video_core/gpu.cpp

@@ -67,8 +67,8 @@ struct GPU::Impl {
         return CreateChannel(new_channel_id++);
     }
 
-    void InitChannel(Control::ChannelState& to_init) {
+    void InitChannel(Control::ChannelState& to_init, u64 program_id) {
-        to_init.Init(system, gpu);
+        to_init.Init(system, gpu, program_id);
         to_init.BindRasterizer(rasterizer);
         rasterizer->InitializeChannel(to_init);
     }
@@ -412,8 +412,8 @@ std::shared_ptr<Control::ChannelState> GPU::AllocateChannel() {
     return impl->AllocateChannel();
 }
 
-void GPU::InitChannel(Control::ChannelState& to_init) {
+void GPU::InitChannel(Control::ChannelState& to_init, u64 program_id) {
-    impl->InitChannel(to_init);
+    impl->InitChannel(to_init, program_id);
 }
 
 void GPU::BindChannel(s32 channel_id) {

src/video_core/gpu.h

@@ -149,7 +149,7 @@ public:
 
     std::shared_ptr<Control::ChannelState> AllocateChannel();
 
-    void InitChannel(Control::ChannelState& to_init);
+    void InitChannel(Control::ChannelState& to_init, u64 program_id);
 
     void BindChannel(s32 channel_id);
 

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -370,27 +370,32 @@ void RasterizerOpenGL::DrawTexture() {
     const auto& sampler = texture_cache.GetGraphicsSampler(draw_texture_state.src_sampler);
     const auto& texture = texture_cache.GetImageView(draw_texture_state.src_texture);
 
+    const auto Scale = [&](auto dim) -> s32 {
+        return Settings::values.resolution_info.ScaleUp(static_cast<s32>(dim));
+    };
+
+    Region2D dst_region = {
+        Offset2D{.x = Scale(draw_texture_state.dst_x0), .y = Scale(draw_texture_state.dst_y0)},
+        Offset2D{.x = Scale(draw_texture_state.dst_x1), .y = Scale(draw_texture_state.dst_y1)}};
+    Region2D src_region = {
+        Offset2D{.x = Scale(draw_texture_state.src_x0), .y = Scale(draw_texture_state.src_y0)},
+        Offset2D{.x = Scale(draw_texture_state.src_x1), .y = Scale(draw_texture_state.src_y1)}};
+    Extent3D src_size = {static_cast<u32>(Scale(texture.size.width)),
+                         static_cast<u32>(Scale(texture.size.height)), texture.size.depth};
+
     if (device.HasDrawTexture()) {
         state_tracker.BindFramebuffer(texture_cache.GetFramebuffer()->Handle());
 
-        glDrawTextureNV(texture.DefaultHandle(), sampler->Handle(), draw_texture_state.dst_x0,
+        glDrawTextureNV(texture.DefaultHandle(), sampler->Handle(),
-                        draw_texture_state.dst_y0, draw_texture_state.dst_x1,
+                        static_cast<f32>(dst_region.start.x), static_cast<f32>(dst_region.start.y),
-                        draw_texture_state.dst_y1, 0,
+                        static_cast<f32>(dst_region.end.x), static_cast<f32>(dst_region.end.y), 0,
                         draw_texture_state.src_x0 / static_cast<float>(texture.size.width),
                         draw_texture_state.src_y0 / static_cast<float>(texture.size.height),
                         draw_texture_state.src_x1 / static_cast<float>(texture.size.width),
                         draw_texture_state.src_y1 / static_cast<float>(texture.size.height));
     } else {
-        Region2D dst_region = {Offset2D{.x = static_cast<s32>(draw_texture_state.dst_x0),
-                                        .y = static_cast<s32>(draw_texture_state.dst_y0)},
-                               Offset2D{.x = static_cast<s32>(draw_texture_state.dst_x1),
-                                        .y = static_cast<s32>(draw_texture_state.dst_y1)}};
-        Region2D src_region = {Offset2D{.x = static_cast<s32>(draw_texture_state.src_x0),
-                                        .y = static_cast<s32>(draw_texture_state.src_y0)},
-                               Offset2D{.x = static_cast<s32>(draw_texture_state.src_x1),
-                                        .y = static_cast<s32>(draw_texture_state.src_y1)}};
         blit_image.BlitColor(texture_cache.GetFramebuffer()->Handle(), texture.DefaultHandle(),
-                             sampler->Handle(), dst_region, src_region, texture.size);
+                             sampler->Handle(), dst_region, src_region, src_size);
         state_tracker.InvalidateState();
     }
 

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -215,6 +215,7 @@ ShaderCache::ShaderCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
           .support_gl_variable_aoffi = device.HasVariableAoffi(),
           .support_gl_sparse_textures = device.HasSparseTexture2(),
           .support_gl_derivative_control = device.HasDerivativeControl(),
+          .support_geometry_streams = true,
 
           .warp_size_potentially_larger_than_guest = device.IsWarpSizePotentiallyLargerThanGuest(),
 

src/video_core/renderer_vulkan/vk_query_cache.cpp

@@ -1064,8 +1064,6 @@ public:
                 }
             });
         }
-        auto* ptr = device_memory.GetPointer<u8>(new_query->dependant_address);
-        ASSERT(ptr != nullptr);
 
         new_query->dependant_manage = must_manage_dependance;
         pending_flush_queries.push_back(index);
@@ -1104,9 +1102,11 @@ public:
                 tfb_streamer.Free(query->dependant_index);
             } else {
                 u8* pointer = device_memory.GetPointer<u8>(query->dependant_address);
-                u32 result;
+                if (pointer != nullptr) {
-                std::memcpy(&result, pointer, sizeof(u32));
+                    u32 result;
-                num_vertices = static_cast<u64>(result) / query->stride;
+                    std::memcpy(&result, pointer, sizeof(u32));
+                    num_vertices = static_cast<u64>(result) / query->stride;
+                }
             }
             query->value = [&]() -> u64 {
                 switch (query->topology) {
@@ -1360,7 +1360,9 @@ bool QueryCacheRuntime::HostConditionalRenderingCompareValues(VideoCommon::Looku
     const auto check_value = [&](DAddr address) {
         u8* ptr = impl->device_memory.GetPointer<u8>(address);
         u64 value{};
-        std::memcpy(&value, ptr, sizeof(value));
+        if (ptr != nullptr) {
+            std::memcpy(&value, ptr, sizeof(value));
+        }
         return value == 0;
     };
     std::array<VideoCommon::LookupData*, 2> objects{&object_1, &object_2};

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -125,11 +125,23 @@ VkRect2D GetScissorState(const Maxwell& regs, size_t index, u32 up_scale = 1, u3
         return value < 0 ? std::min<s32>(converted_value - acumm, -1)
                          : std::max<s32>(converted_value + acumm, 1);
     };
+
+    const bool lower_left = regs.window_origin.mode != Maxwell::WindowOrigin::Mode::UpperLeft;
+    const s32 clip_height = regs.surface_clip.height;
+
+    // Flip coordinates if lower left
+    s32 min_y = lower_left ? (clip_height - src.max_y) : src.min_y.Value();
+    s32 max_y = lower_left ? (clip_height - src.min_y) : src.max_y.Value();
+
+    // Bound to render area
+    min_y = std::max(min_y, 0);
+    max_y = std::max(max_y, 0);
+
     if (src.enable) {
-        scissor.offset.x = scale_up(static_cast<s32>(src.min_x));
+        scissor.offset.x = scale_up(src.min_x);
-        scissor.offset.y = scale_up(static_cast<s32>(src.min_y));
+        scissor.offset.y = scale_up(min_y);
         scissor.extent.width = scale_up(src.max_x - src.min_x);
-        scissor.extent.height = scale_up(src.max_y - src.min_y);
+        scissor.extent.height = scale_up(max_y - min_y);
     } else {
         scissor.offset.x = 0;
         scissor.offset.y = 0;
@@ -308,17 +320,33 @@ void RasterizerVulkan::DrawTexture() {
     const auto& draw_texture_state = maxwell3d->draw_manager->GetDrawTextureState();
     const auto& sampler = texture_cache.GetGraphicsSampler(draw_texture_state.src_sampler);
     const auto& texture = texture_cache.GetImageView(draw_texture_state.src_texture);
-    Region2D dst_region = {Offset2D{.x = static_cast<s32>(draw_texture_state.dst_x0),
+    const auto* framebuffer = texture_cache.GetFramebuffer();
-                                    .y = static_cast<s32>(draw_texture_state.dst_y0)},
+
-                           Offset2D{.x = static_cast<s32>(draw_texture_state.dst_x1),
+    const bool src_rescaling = texture_cache.IsRescaling() && texture.IsRescaled();
-                                    .y = static_cast<s32>(draw_texture_state.dst_y1)}};
+    const bool dst_rescaling = texture_cache.IsRescaling() && framebuffer->IsRescaled();
-    Region2D src_region = {Offset2D{.x = static_cast<s32>(draw_texture_state.src_x0),
+
-                                    .y = static_cast<s32>(draw_texture_state.src_y0)},
+    const auto ScaleSrc = [&](auto dim_f) -> s32 {
-                           Offset2D{.x = static_cast<s32>(draw_texture_state.src_x1),
+        auto dim = static_cast<s32>(dim_f);
-                                    .y = static_cast<s32>(draw_texture_state.src_y1)}};
+        return src_rescaling ? Settings::values.resolution_info.ScaleUp(dim) : dim;
-    blit_image.BlitColor(texture_cache.GetFramebuffer(), texture.RenderTarget(),
+    };
-                         texture.ImageHandle(), sampler->Handle(), dst_region, src_region,
+
-                         texture.size);
+    const auto ScaleDst = [&](auto dim_f) -> s32 {
+        auto dim = static_cast<s32>(dim_f);
+        return dst_rescaling ? Settings::values.resolution_info.ScaleUp(dim) : dim;
+    };
+
+    Region2D dst_region = {Offset2D{.x = ScaleDst(draw_texture_state.dst_x0),
+                                    .y = ScaleDst(draw_texture_state.dst_y0)},
+                           Offset2D{.x = ScaleDst(draw_texture_state.dst_x1),
+                                    .y = ScaleDst(draw_texture_state.dst_y1)}};
+    Region2D src_region = {Offset2D{.x = ScaleSrc(draw_texture_state.src_x0),
+                                    .y = ScaleSrc(draw_texture_state.src_y0)},
+                           Offset2D{.x = ScaleSrc(draw_texture_state.src_x1),
+                                    .y = ScaleSrc(draw_texture_state.src_y1)}};
+    Extent3D src_size = {static_cast<u32>(ScaleSrc(texture.size.width)),
+                         static_cast<u32>(ScaleSrc(texture.size.height)), texture.size.depth};
+    blit_image.BlitColor(framebuffer, texture.RenderTarget(), texture.ImageHandle(),
+                         sampler->Handle(), dst_region, src_region, src_size);
 }
 
 void RasterizerVulkan::Clear(u32 layer_count) {
@@ -1054,37 +1082,16 @@ void RasterizerVulkan::UpdateDepthBias(Tegra::Engines::Maxwell3D::Regs& regs) {
                         regs.zeta.format == Tegra::DepthFormat::X8Z24_UNORM ||
                         regs.zeta.format == Tegra::DepthFormat::S8Z24_UNORM ||
                         regs.zeta.format == Tegra::DepthFormat::V8Z24_UNORM;
-    bool force_unorm = ([&] {
+    if (is_d24 && !device.SupportsD24DepthBuffer() && program_id == 0x1006A800016E000ULL) {
-        if (!is_d24 || device.SupportsD24DepthBuffer()) {
+        // Only activate this in Super Smash Brothers Ultimate
-            return false;
-        }
-        if (device.IsExtDepthBiasControlSupported()) {
-            return true;
-        }
-        if (!Settings::values.renderer_amdvlk_depth_bias_workaround) {
-            return false;
-        }
         // the base formulas can be obtained from here:
         //   https://docs.microsoft.com/en-us/windows/win32/direct3d11/d3d10-graphics-programming-guide-output-merger-stage-depth-bias
         const double rescale_factor =
             static_cast<double>(1ULL << (32 - 24)) / (static_cast<double>(0x1.ep+127));
         units = static_cast<float>(static_cast<double>(units) * rescale_factor);
-        return false;
+    }
-    })();
     scheduler.Record([constant = units, clamp = regs.depth_bias_clamp,
-                      factor = regs.slope_scale_depth_bias, force_unorm,
+                      factor = regs.slope_scale_depth_bias](vk::CommandBuffer cmdbuf) {
-                      precise = device.HasExactDepthBiasControl()](vk::CommandBuffer cmdbuf) {
-        if (force_unorm) {
-            VkDepthBiasRepresentationInfoEXT info{
-                .sType = VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT,
-                .pNext = nullptr,
-                .depthBiasRepresentation =
-                    VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORCE_UNORM_EXT,
-                .depthBiasExact = precise ? VK_TRUE : VK_FALSE,
-            };
-            cmdbuf.SetDepthBias(constant, clamp, factor, &info);
-            return;
-        }
         cmdbuf.SetDepthBias(constant, clamp, factor);
     });
 }

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -1962,21 +1962,22 @@ Framebuffer::Framebuffer(TextureCacheRuntime& runtime, std::span<ImageView*, NUM
 }
 
 Framebuffer::Framebuffer(TextureCacheRuntime& runtime, ImageView* color_buffer,
-                         ImageView* depth_buffer, VkExtent2D extent, bool is_rescaled)
+                         ImageView* depth_buffer, VkExtent2D extent, bool is_rescaled_)
     : render_area{extent} {
     std::array<ImageView*, NUM_RT> color_buffers{color_buffer};
-    CreateFramebuffer(runtime, color_buffers, depth_buffer, is_rescaled);
+    CreateFramebuffer(runtime, color_buffers, depth_buffer, is_rescaled_);
 }
 
 Framebuffer::~Framebuffer() = default;
 
 void Framebuffer::CreateFramebuffer(TextureCacheRuntime& runtime,
                                     std::span<ImageView*, NUM_RT> color_buffers,
-                                    ImageView* depth_buffer, bool is_rescaled) {
+                                    ImageView* depth_buffer, bool is_rescaled_) {
     boost::container::small_vector<VkImageView, NUM_RT + 1> attachments;
     RenderPassKey renderpass_key{};
     s32 num_layers = 1;
 
+    is_rescaled = is_rescaled_;
     const auto& resolution = runtime.resolution;
 
     u32 width = std::numeric_limits<u32>::max();

src/video_core/renderer_vulkan/vk_texture_cache.h

@@ -361,6 +361,10 @@ public:
         return has_stencil;
     }
 
+    [[nodiscard]] bool IsRescaled() const noexcept {
+        return is_rescaled;
+    }
+
 private:
     vk::Framebuffer framebuffer;
     VkRenderPass renderpass{};
@@ -373,6 +377,7 @@ private:
     std::array<size_t, NUM_RT> rt_map{};
     bool has_depth{};
     bool has_stencil{};
+    bool is_rescaled{};
 };
 
 struct TextureCacheParams {

src/video_core/texture_cache/texture_cache.h

@@ -72,12 +72,19 @@ TextureCache<P>::TextureCache(Runtime& runtime_, Tegra::MaxwellDeviceMemoryManag
 
 template <class P>
 void TextureCache<P>::RunGarbageCollector() {
-    bool high_priority_mode = total_used_memory >= expected_memory;
+    bool high_priority_mode = false;
-    bool aggressive_mode = total_used_memory >= critical_memory;
+    bool aggressive_mode = false;
-    const u64 ticks_to_destroy = aggressive_mode ? 10ULL : high_priority_mode ? 25ULL : 50ULL;
+    u64 ticks_to_destroy = 0;
-    size_t num_iterations = aggressive_mode ? 40 : (high_priority_mode ? 20 : 10);
+    size_t num_iterations = 0;
-    const auto clean_up = [this, &num_iterations, &high_priority_mode,
+
-                           &aggressive_mode](ImageId image_id) {
+    const auto Configure = [&](bool allow_aggressive) {
+        high_priority_mode = total_used_memory >= expected_memory;
+        aggressive_mode = allow_aggressive && total_used_memory >= critical_memory;
+        ticks_to_destroy = aggressive_mode ? 10ULL : high_priority_mode ? 25ULL : 50ULL;
+        num_iterations = aggressive_mode ? 40 : (high_priority_mode ? 20 : 10);
+    };
+    const auto Cleanup = [this, &num_iterations, &high_priority_mode,
+                          &aggressive_mode](ImageId image_id) {
         if (num_iterations == 0) {
             return true;
         }
@@ -123,7 +130,16 @@ void TextureCache<P>::RunGarbageCollector() {
         }
         return false;
     };
-    lru_cache.ForEachItemBelow(frame_tick - ticks_to_destroy, clean_up);
+
+    // Try to remove anything old enough and not high priority.
+    Configure(false);
+    lru_cache.ForEachItemBelow(frame_tick - ticks_to_destroy, Cleanup);
+
+    // If pressure is still too high, prune aggressively.
+    if (total_used_memory >= critical_memory) {
+        Configure(true);
+        lru_cache.ForEachItemBelow(frame_tick - ticks_to_destroy, Cleanup);
+    }
 }
 
 template <class P>
@@ -2098,7 +2114,9 @@ void TextureCache<P>::TrackImage(ImageBase& image, ImageId image_id) {
     ASSERT(False(image.flags & ImageFlagBits::Tracked));
     image.flags |= ImageFlagBits::Tracked;
     if (False(image.flags & ImageFlagBits::Sparse)) {
-        device_memory.UpdatePagesCachedCount(image.cpu_addr, image.guest_size_bytes, 1);
+        if (image.cpu_addr < ~(1ULL << 40)) {
+            device_memory.UpdatePagesCachedCount(image.cpu_addr, image.guest_size_bytes, 1);
+        }
         return;
     }
     if (True(image.flags & ImageFlagBits::Registered)) {
@@ -2124,7 +2142,9 @@ void TextureCache<P>::UntrackImage(ImageBase& image, ImageId image_id) {
     ASSERT(True(image.flags & ImageFlagBits::Tracked));
     image.flags &= ~ImageFlagBits::Tracked;
     if (False(image.flags & ImageFlagBits::Sparse)) {
-        device_memory.UpdatePagesCachedCount(image.cpu_addr, image.guest_size_bytes, -1);
+        if (image.cpu_addr < ~(1ULL << 40)) {
+            device_memory.UpdatePagesCachedCount(image.cpu_addr, image.guest_size_bytes, -1);
+        }
         return;
     }
     ASSERT(True(image.flags & ImageFlagBits::Registered));

src/yuzu/configuration/configure_applets.cpp

@@ -59,9 +59,7 @@ void ConfigureApplets::Setup(const ConfigurationShared::Builder& builder) {
 
         // Untested applets
         if (setting->Id() == Settings::values.data_erase_applet_mode.Id() ||
-            setting->Id() == Settings::values.error_applet_mode.Id() ||
             setting->Id() == Settings::values.net_connect_applet_mode.Id() ||
-            setting->Id() == Settings::values.web_applet_mode.Id() ||
             setting->Id() == Settings::values.shop_applet_mode.Id() ||
             setting->Id() == Settings::values.login_share_applet_mode.Id() ||
             setting->Id() == Settings::values.wifi_web_auth_applet_mode.Id() ||

tools/reset-submodules.sh

@@ -0,0 +1,8 @@
+#!/bin/bash -ex
+
+# SPDX-FileCopyrightText: 2024 yuzu Emulator Project
+# SPDX-License-Identifier: MIT
+
+git submodule sync
+git submodule foreach --recursive git reset --hard
+git submodule update --init --recursive