spl: Mark the other functions as unimplemented

.gitmodules

@@ -18,7 +18,7 @@
 	url = https://github.com/libusb/libusb.git
 [submodule "discord-rpc"]
     path = externals/discord-rpc
-    url = https://github.com/discord/discord-rpc.git
+    url = https://github.com/discordapp/discord-rpc.git
 [submodule "Vulkan-Headers"]
     path = externals/Vulkan-Headers
     url = https://github.com/KhronosGroup/Vulkan-Headers.git
@@ -43,6 +43,3 @@
 [submodule "SDL"]
 	path = externals/SDL
 	url = https://github.com/libsdl-org/SDL.git
-[submodule "externals/cpp-httplib"]
-	path = externals/cpp-httplib
-	url = https://github.com/yhirose/cpp-httplib.git

externals/CMakeLists.txt

@@ -53,10 +53,10 @@ endif()
 # SDL2
 if (NOT SDL2_FOUND AND ENABLE_SDL2)
     if (NOT WIN32)
-        # Yuzu itself needs: Events Joystick Haptic Sensor Timers Audio
+        # Yuzu itself needs: Events Joystick Haptic Sensor Timers
         # Yuzu-cmd also needs: Video (depends on Loadso/Dlopen)
         set(SDL_UNUSED_SUBSYSTEMS
-            Atomic Render Power Threads
+            Atomic Audio Render Power Threads
             File CPUinfo Filesystem Locale)
         foreach(_SUB ${SDL_UNUSED_SUBSYSTEMS})
           string(TOUPPER ${_SUB} _OPT)
@@ -115,7 +115,7 @@ if (ENABLE_WEB_SERVICE)
 
     # httplib
     add_library(httplib INTERFACE)
-    target_include_directories(httplib INTERFACE ./cpp-httplib)
+    target_include_directories(httplib INTERFACE ./httplib)
     target_compile_definitions(httplib INTERFACE -DCPPHTTPLIB_OPENSSL_SUPPORT)
     target_link_libraries(httplib INTERFACE ${OPENSSL_LIBRARIES})
     if (WIN32)

externals/httplib/README.md

@@ -0,0 +1,15 @@
+From https://github.com/yhirose/cpp-httplib/tree/ff5677ad197947177c158fe857caff4f0e242045 with https://github.com/yhirose/cpp-httplib/pull/701
+
+MIT License
+
+===
+
+cpp-httplib
+
+A C++11 header-only HTTP library.
+
+It's extremely easy to setup. Just include httplib.h file in your code!
+
+Inspired by Sinatra and express.
+
+© 2017 Yuji Hirose

src/audio_core/CMakeLists.txt

@@ -42,7 +42,6 @@ add_library(audio_core STATIC
     voice_context.h
 
     $<$<BOOL:${ENABLE_CUBEB}>:cubeb_sink.cpp cubeb_sink.h>
-    $<$<BOOL:${ENABLE_SDL2}>:sdl2_sink.cpp sdl2_sink.h>
 )
 
 create_target_directory_groups(audio_core)
@@ -72,7 +71,3 @@ if(ENABLE_CUBEB)
     target_link_libraries(audio_core PRIVATE cubeb)
     target_compile_definitions(audio_core PRIVATE -DHAVE_CUBEB=1)
 endif()
-if(ENABLE_SDL2)
-    target_link_libraries(audio_core PRIVATE SDL2)
-    target_compile_definitions(audio_core PRIVATE HAVE_SDL2)
-endif()

src/audio_core/sdl2_sink.cpp

@@ -1,163 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <atomic>
-#include <cstring>
-#include "audio_core/sdl2_sink.h"
-#include "audio_core/stream.h"
-#include "audio_core/time_stretch.h"
-#include "common/assert.h"
-#include "common/logging/log.h"
-//#include "common/settings.h"
-
-// Ignore -Wimplicit-fallthrough due to https://github.com/libsdl-org/SDL/issues/4307
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wimplicit-fallthrough"
-#endif
-#include <SDL.h>
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-namespace AudioCore {
-
-class SDLSinkStream final : public SinkStream {
-public:
-    SDLSinkStream(u32 sample_rate, u32 num_channels_, const std::string& output_device)
-        : num_channels{std::min(num_channels_, 6u)}, time_stretch{sample_rate, num_channels} {
-
-        SDL_AudioSpec spec;
-        spec.freq = sample_rate;
-        spec.channels = static_cast<u8>(num_channels);
-        spec.format = AUDIO_S16SYS;
-        spec.samples = 4096;
-        spec.callback = nullptr;
-
-        SDL_AudioSpec obtained;
-        if (output_device.empty()) {
-            dev = SDL_OpenAudioDevice(nullptr, 0, &spec, &obtained, 0);
-        } else {
-            dev = SDL_OpenAudioDevice(output_device.c_str(), 0, &spec, &obtained, 0);
-        }
-
-        if (dev == 0) {
-            LOG_CRITICAL(Audio_Sink, "Error opening sdl audio device: {}", SDL_GetError());
-            return;
-        }
-
-        SDL_PauseAudioDevice(dev, 0);
-    }
-
-    ~SDLSinkStream() override {
-        if (dev == 0) {
-            return;
-        }
-
-        SDL_CloseAudioDevice(dev);
-    }
-
-    void EnqueueSamples(u32 source_num_channels, const std::vector<s16>& samples) override {
-        if (source_num_channels > num_channels) {
-            // Downsample 6 channels to 2
-            ASSERT_MSG(source_num_channels == 6, "Channel count must be 6");
-
-            std::vector<s16> buf;
-            buf.reserve(samples.size() * num_channels / source_num_channels);
-            for (std::size_t i = 0; i < samples.size(); i += source_num_channels) {
-                // Downmixing implementation taken from the ATSC standard
-                const s16 left{samples[i + 0]};
-                const s16 right{samples[i + 1]};
-                const s16 center{samples[i + 2]};
-                const s16 surround_left{samples[i + 4]};
-                const s16 surround_right{samples[i + 5]};
-                // Not used in the ATSC reference implementation
-                [[maybe_unused]] const s16 low_frequency_effects{samples[i + 3]};
-
-                constexpr s32 clev{707}; // center mixing level coefficient
-                constexpr s32 slev{707}; // surround mixing level coefficient
-
-                buf.push_back(static_cast<s16>(left + (clev * center / 1000) +
-                                               (slev * surround_left / 1000)));
-                buf.push_back(static_cast<s16>(right + (clev * center / 1000) +
-                                               (slev * surround_right / 1000)));
-            }
-            int ret = SDL_QueueAudio(dev, static_cast<const void*>(buf.data()),
-                                     static_cast<u32>(buf.size() * sizeof(s16)));
-            if (ret < 0)
-                LOG_WARNING(Audio_Sink, "Could not queue audio buffer: {}", SDL_GetError());
-            return;
-        }
-
-        int ret = SDL_QueueAudio(dev, static_cast<const void*>(samples.data()),
-                                 static_cast<u32>(samples.size() * sizeof(s16)));
-        if (ret < 0)
-            LOG_WARNING(Audio_Sink, "Could not queue audio buffer: {}", SDL_GetError());
-    }
-
-    std::size_t SamplesInQueue(u32 channel_count) const override {
-        if (dev == 0)
-            return 0;
-
-        return SDL_GetQueuedAudioSize(dev) / (channel_count * sizeof(s16));
-    }
-
-    void Flush() override {
-        should_flush = true;
-    }
-
-    u32 GetNumChannels() const {
-        return num_channels;
-    }
-
-private:
-    SDL_AudioDeviceID dev = 0;
-    u32 num_channels{};
-    std::atomic<bool> should_flush{};
-    TimeStretcher time_stretch;
-};
-
-SDLSink::SDLSink(std::string_view target_device_name) {
-    if (!SDL_WasInit(SDL_INIT_AUDIO)) {
-        if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) {
-            LOG_CRITICAL(Audio_Sink, "SDL_InitSubSystem audio failed: {}", SDL_GetError());
-            return;
-        }
-    }
-
-    if (target_device_name != auto_device_name && !target_device_name.empty()) {
-        output_device = target_device_name;
-    } else {
-        output_device.clear();
-    }
-}
-
-SDLSink::~SDLSink() = default;
-
-SinkStream& SDLSink::AcquireSinkStream(u32 sample_rate, u32 num_channels, const std::string&) {
-    sink_streams.push_back(
-        std::make_unique<SDLSinkStream>(sample_rate, num_channels, output_device));
-    return *sink_streams.back();
-}
-
-std::vector<std::string> ListSDLSinkDevices() {
-    std::vector<std::string> device_list;
-
-    if (!SDL_WasInit(SDL_INIT_AUDIO)) {
-        if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) {
-            LOG_CRITICAL(Audio_Sink, "SDL_InitSubSystem audio failed: {}", SDL_GetError());
-            return {};
-        }
-    }
-
-    const int device_count = SDL_GetNumAudioDevices(0);
-    for (int i = 0; i < device_count; ++i) {
-        device_list.emplace_back(SDL_GetAudioDeviceName(i, 0));
-    }
-
-    return device_list;
-}
-
-} // namespace AudioCore

src/audio_core/sdl2_sink.h

@@ -1,29 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <string>
-#include <vector>
-
-#include "audio_core/sink.h"
-
-namespace AudioCore {
-
-class SDLSink final : public Sink {
-public:
-    explicit SDLSink(std::string_view device_id);
-    ~SDLSink() override;
-
-    SinkStream& AcquireSinkStream(u32 sample_rate, u32 num_channels,
-                                  const std::string& name) override;
-
-private:
-    std::string output_device;
-    std::vector<SinkStreamPtr> sink_streams;
-};
-
-std::vector<std::string> ListSDLSinkDevices();
-
-} // namespace AudioCore

src/audio_core/sink_details.cpp

@@ -11,9 +11,6 @@
 #ifdef HAVE_CUBEB
 #include "audio_core/cubeb_sink.h"
 #endif
-#ifdef HAVE_SDL2
-#include "audio_core/sdl2_sink.h"
-#endif
 #include "common/logging/log.h"
 
 namespace AudioCore {
@@ -38,13 +35,6 @@ constexpr SinkDetails sink_details[] = {
                     return std::make_unique<CubebSink>(device_id);
                 },
                 &ListCubebSinkDevices},
-#endif
-#ifdef HAVE_SDL2
-    SinkDetails{"sdl2",
-                [](std::string_view device_id) -> std::unique_ptr<Sink> {
-                    return std::make_unique<SDLSink>(device_id);
-                },
-                &ListSDLSinkDevices},
 #endif
     SinkDetails{"null",
                 [](std::string_view device_id) -> std::unique_ptr<Sink> {

src/common/fs/file.cpp

@@ -183,6 +183,10 @@ size_t WriteStringToFile(const std::filesystem::path& path, FileType type,
 
 size_t AppendStringToFile(const std::filesystem::path& path, FileType type,
                           std::string_view string) {
+    if (!Exists(path)) {
+        return WriteStringToFile(path, type, string);
+    }
+
     if (!IsFile(path)) {
         return 0;
     }

src/common/fs/file.h

@@ -71,7 +71,7 @@ template <typename Path>
 
 /**
  * Writes a string to a file at path and returns the number of characters successfully written.
- * If a file already exists at path, its contents will be erased.
+ * If an file already exists at path, its contents will be erased.
  * If the filesystem object at path is not a file, this function returns 0.
  *
  * @param path Filesystem path
@@ -95,6 +95,7 @@ template <typename Path>
 
 /**
  * Appends a string to a file at path and returns the number of characters successfully written.
+ * If a file does not exist at path, WriteStringToFile is called instead.
  * If the filesystem object at path is not a file, this function returns 0.
  *
  * @param path Filesystem path

src/common/host_memory.cpp

@@ -34,7 +34,7 @@ constexpr size_t HugePageSize = 0x200000;
 
 // Manually imported for MinGW compatibility
 #ifndef MEM_RESERVE_PLACEHOLDER
-#define MEM_RESERVE_PLACEHOLDER 0x00040000
+#define MEM_RESERVE_PLACEHOLDER 0x0004000
 #endif
 #ifndef MEM_REPLACE_PLACEHOLDER
 #define MEM_REPLACE_PLACEHOLDER 0x00004000

src/common/settings.cpp

@@ -55,7 +55,6 @@ void LogSettings() {
     log_setting("Renderer_UseAsynchronousGpuEmulation",
                 values.use_asynchronous_gpu_emulation.GetValue());
     log_setting("Renderer_UseNvdecEmulation", values.use_nvdec_emulation.GetValue());
-    log_setting("Renderer_AccelerateASTC", values.accelerate_astc.GetValue());
     log_setting("Renderer_UseVsync", values.use_vsync.GetValue());
     log_setting("Renderer_UseAssemblyShaders", values.use_assembly_shaders.GetValue());
     log_setting("Renderer_UseAsynchronousShaders", values.use_asynchronous_shaders.GetValue());
@@ -122,7 +121,6 @@ void RestoreGlobalState(bool is_powered_on) {
     values.cpu_accuracy.SetGlobal(true);
     values.cpuopt_unsafe_unfuse_fma.SetGlobal(true);
     values.cpuopt_unsafe_reduce_fp_error.SetGlobal(true);
-    values.cpuopt_unsafe_ignore_standard_fpcr.SetGlobal(true);
     values.cpuopt_unsafe_inaccurate_nan.SetGlobal(true);
     values.cpuopt_unsafe_fastmem_check.SetGlobal(true);
 
@@ -137,7 +135,6 @@ void RestoreGlobalState(bool is_powered_on) {
     values.gpu_accuracy.SetGlobal(true);
     values.use_asynchronous_gpu_emulation.SetGlobal(true);
     values.use_nvdec_emulation.SetGlobal(true);
-    values.accelerate_astc.SetGlobal(true);
     values.use_vsync.SetGlobal(true);
     values.use_assembly_shaders.SetGlobal(true);
     values.use_asynchronous_shaders.SetGlobal(true);

src/common/settings.h

@@ -129,7 +129,6 @@ struct Values {
 
     Setting<bool> cpuopt_unsafe_unfuse_fma;
     Setting<bool> cpuopt_unsafe_reduce_fp_error;
-    Setting<bool> cpuopt_unsafe_ignore_standard_fpcr;
     Setting<bool> cpuopt_unsafe_inaccurate_nan;
     Setting<bool> cpuopt_unsafe_fastmem_check;
 
@@ -148,9 +147,7 @@ struct Values {
     Setting<GPUAccuracy> gpu_accuracy;
     Setting<bool> use_asynchronous_gpu_emulation;
     Setting<bool> use_nvdec_emulation;
-    Setting<bool> accelerate_astc;
     Setting<bool> use_vsync;
-    Setting<bool> disable_fps_limit;
     Setting<bool> use_assembly_shaders;
     Setting<bool> use_asynchronous_shaders;
     Setting<bool> use_fast_gpu_time;
@@ -221,7 +218,6 @@ struct Values {
     std::string program_args;
     bool dump_exefs;
     bool dump_nso;
-    bool enable_fs_access_log;
     bool reporting_services;
     bool quest_flag;
     bool disable_macro_jit;

src/core/CMakeLists.txt

@@ -139,6 +139,7 @@ add_library(core STATIC
     frontend/input.h
     hardware_interrupt_manager.cpp
     hardware_interrupt_manager.h
+    hle/api_version.h
     hle/ipc.h
     hle/ipc_helpers.h
     hle/kernel/board/nintendo/nx/k_system_control.cpp
@@ -550,6 +551,8 @@ add_library(core STATIC
     hle/service/spl/module.h
     hle/service/spl/spl.cpp
     hle/service/spl/spl.h
+    hle/service/spl/spl_results.h
+    hle/service/spl/spl_types.h
     hle/service/ssl/ssl.cpp
     hle/service/ssl/ssl.h
     hle/service/time/clock_types.h

src/core/arm/dynarmic/arm_dynarmic_32.cpp

@@ -186,9 +186,6 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
         if (Settings::values.cpuopt_unsafe_reduce_fp_error.GetValue()) {
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_ReducedErrorFP;
         }
-        if (Settings::values.cpuopt_unsafe_ignore_standard_fpcr.GetValue()) {
-            config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreStandardFPCRValue;
-        }
         if (Settings::values.cpuopt_unsafe_inaccurate_nan.GetValue()) {
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;
         }

src/core/file_sys/system_archive/system_version.cpp

@@ -4,47 +4,29 @@
 
 #include "core/file_sys/system_archive/system_version.h"
 #include "core/file_sys/vfs_vector.h"
+#include "core/hle/api_version.h"
 
 namespace FileSys::SystemArchive {
 
-namespace SystemVersionData {
-
-// This section should reflect the best system version to describe yuzu's HLE api.
-// TODO(DarkLordZach): Update when HLE gets better.
-
-constexpr u8 VERSION_MAJOR = 11;
-constexpr u8 VERSION_MINOR = 0;
-constexpr u8 VERSION_MICRO = 1;
-
-constexpr u8 REVISION_MAJOR = 1;
-constexpr u8 REVISION_MINOR = 0;
-
-constexpr char PLATFORM_STRING[] = "NX";
-constexpr char VERSION_HASH[] = "69103fcb2004dace877094c2f8c29e6113be5dbf";
-constexpr char DISPLAY_VERSION[] = "11.0.1";
-constexpr char DISPLAY_TITLE[] = "NintendoSDK Firmware for NX 11.0.1-1.0";
-
-} // namespace SystemVersionData
-
 std::string GetLongDisplayVersion() {
-    return SystemVersionData::DISPLAY_TITLE;
+    return HLE::ApiVersion::DISPLAY_TITLE;
 }
 
 VirtualDir SystemVersion() {
     VirtualFile file = std::make_shared<VectorVfsFile>(std::vector<u8>(0x100), "file");
-    file->WriteObject(SystemVersionData::VERSION_MAJOR, 0);
-    file->WriteObject(SystemVersionData::VERSION_MINOR, 1);
-    file->WriteObject(SystemVersionData::VERSION_MICRO, 2);
-    file->WriteObject(SystemVersionData::REVISION_MAJOR, 4);
-    file->WriteObject(SystemVersionData::REVISION_MINOR, 5);
-    file->WriteArray(SystemVersionData::PLATFORM_STRING,
-                     std::min<u64>(sizeof(SystemVersionData::PLATFORM_STRING), 0x20ULL), 0x8);
-    file->WriteArray(SystemVersionData::VERSION_HASH,
-                     std::min<u64>(sizeof(SystemVersionData::VERSION_HASH), 0x40ULL), 0x28);
-    file->WriteArray(SystemVersionData::DISPLAY_VERSION,
-                     std::min<u64>(sizeof(SystemVersionData::DISPLAY_VERSION), 0x18ULL), 0x68);
-    file->WriteArray(SystemVersionData::DISPLAY_TITLE,
-                     std::min<u64>(sizeof(SystemVersionData::DISPLAY_TITLE), 0x80ULL), 0x80);
+    file->WriteObject(HLE::ApiVersion::HOS_VERSION_MAJOR, 0);
+    file->WriteObject(HLE::ApiVersion::HOS_VERSION_MINOR, 1);
+    file->WriteObject(HLE::ApiVersion::HOS_VERSION_MICRO, 2);
+    file->WriteObject(HLE::ApiVersion::SDK_REVISION_MAJOR, 4);
+    file->WriteObject(HLE::ApiVersion::SDK_REVISION_MINOR, 5);
+    file->WriteArray(HLE::ApiVersion::PLATFORM_STRING,
+                     std::min<u64>(sizeof(HLE::ApiVersion::PLATFORM_STRING), 0x20ULL), 0x8);
+    file->WriteArray(HLE::ApiVersion::VERSION_HASH,
+                     std::min<u64>(sizeof(HLE::ApiVersion::VERSION_HASH), 0x40ULL), 0x28);
+    file->WriteArray(HLE::ApiVersion::DISPLAY_VERSION,
+                     std::min<u64>(sizeof(HLE::ApiVersion::DISPLAY_VERSION), 0x18ULL), 0x68);
+    file->WriteArray(HLE::ApiVersion::DISPLAY_TITLE,
+                     std::min<u64>(sizeof(HLE::ApiVersion::DISPLAY_TITLE), 0x80ULL), 0x80);
     return std::make_shared<VectorVfsDirectory>(std::vector<VirtualFile>{file},
                                                 std::vector<VirtualDir>{}, "data");
 }

src/core/hle/api_version.h

@@ -0,0 +1,38 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/common_types.h"
+
+// This file contains yuzu's HLE API version constants.
+
+namespace HLE::ApiVersion {
+
+// Horizon OS version constants.
+
+constexpr u8 HOS_VERSION_MAJOR = 11;
+constexpr u8 HOS_VERSION_MINOR = 0;
+constexpr u8 HOS_VERSION_MICRO = 1;
+
+// NintendoSDK version constants.
+
+constexpr u8 SDK_REVISION_MAJOR = 1;
+constexpr u8 SDK_REVISION_MINOR = 0;
+
+constexpr char PLATFORM_STRING[] = "NX";
+constexpr char VERSION_HASH[] = "69103fcb2004dace877094c2f8c29e6113be5dbf";
+constexpr char DISPLAY_VERSION[] = "11.0.1";
+constexpr char DISPLAY_TITLE[] = "NintendoSDK Firmware for NX 11.0.1-1.0";
+
+// Atmosphere version constants.
+
+constexpr u8 ATMOSPHERE_RELEASE_VERSION_MAJOR = 0;
+constexpr u8 ATMOSPHERE_RELEASE_VERSION_MINOR = 19;
+constexpr u8 ATMOSPHERE_RELEASE_VERSION_MICRO = 4;
+
+constexpr u32 GetTargetFirmware() {
+    return u32{HOS_VERSION_MAJOR} << 24 | u32{HOS_VERSION_MINOR} << 16 |
+           u32{HOS_VERSION_MICRO} << 8 | 0U;
+}
+
+} // namespace HLE::ApiVersion

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

@@ -13,7 +13,6 @@
 #include "common/common_types.h"
 #include "common/hex_util.h"
 #include "common/logging/log.h"
-#include "common/settings.h"
 #include "common/string_util.h"
 #include "core/core.h"
 #include "core/file_sys/directory.h"
@@ -786,10 +785,6 @@ FSP_SRV::FSP_SRV(Core::System& system_)
     };
     // clang-format on
     RegisterHandlers(functions);
-
-    if (Settings::values.enable_fs_access_log) {
-        access_log_mode = AccessLogMode::SdCard;
-    }
 }
 
 FSP_SRV::~FSP_SRV() = default;
@@ -1046,9 +1041,9 @@ void FSP_SRV::DisableAutoSaveDataCreation(Kernel::HLERequestContext& ctx) {
 
 void FSP_SRV::SetGlobalAccessLogMode(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    access_log_mode = rp.PopEnum<AccessLogMode>();
+    log_mode = rp.PopEnum<LogMode>();
 
-    LOG_DEBUG(Service_FS, "called, access_log_mode={}", access_log_mode);
+    LOG_DEBUG(Service_FS, "called, log_mode={:08X}", log_mode);
 
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(ResultSuccess);
@@ -1059,7 +1054,7 @@ void FSP_SRV::GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(ResultSuccess);
-    rb.PushEnum(access_log_mode);
+    rb.PushEnum(log_mode);
 }
 
 void FSP_SRV::OutputAccessLogToSdCard(Kernel::HLERequestContext& ctx) {
@@ -1067,9 +1062,9 @@ void FSP_SRV::OutputAccessLogToSdCard(Kernel::HLERequestContext& ctx) {
     auto log = Common::StringFromFixedZeroTerminatedBuffer(
         reinterpret_cast<const char*>(raw.data()), raw.size());
 
-    LOG_DEBUG(Service_FS, "called");
+    LOG_DEBUG(Service_FS, "called, log='{}'", log);
 
-    reporter.SaveFSAccessLog(log);
+    reporter.SaveFilesystemAccessReport(log_mode, std::move(log));
 
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(ResultSuccess);

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

@@ -24,10 +24,11 @@ enum class AccessLogVersion : u32 {
     Latest = V7_0_0,
 };
 
-enum class AccessLogMode : u32 {
-    None,
+enum class LogMode : u32 {
+    Off,
     Log,
-    SdCard,
+    RedirectToSdCard,
+    LogToSdCard = Log | RedirectToSdCard,
 };
 
 class FSP_SRV final : public ServiceFramework<FSP_SRV> {
@@ -58,12 +59,13 @@ private:
 
     FileSystemController& fsc;
     const FileSys::ContentProvider& content_provider;
-    const Core::Reporter& reporter;
 
     FileSys::VirtualFile romfs;
     u64 current_process_id = 0;
     u32 access_log_program_index = 0;
-    AccessLogMode access_log_mode = AccessLogMode::None;
+    LogMode log_mode = LogMode::LogToSdCard;
+
+    const Core::Reporter& reporter;
 };
 
 } // namespace Service::FileSystem

src/core/hle/service/nvflinger/nvflinger.cpp

@@ -307,9 +307,6 @@ void NVFlinger::Compose() {
 }
 
 s64 NVFlinger::GetNextTicks() const {
-    if (Settings::values.disable_fps_limit.GetValue()) {
-        return 0;
-    }
     constexpr s64 max_hertz = 120LL;
     return (1000000000 * (1LL << swap_interval)) / max_hertz;
 }

src/core/hle/service/spl/csrng.cpp

@@ -9,7 +9,7 @@ namespace Service::SPL {
 CSRNG::CSRNG(Core::System& system_, std::shared_ptr<Module> module_)
     : Interface(system_, std::move(module_), "csrng") {
     static const FunctionInfo functions[] = {
-        {0, &CSRNG::GetRandomBytes, "GetRandomBytes"},
+        {0, &CSRNG::GenerateRandomBytes, "GenerateRandomBytes"},
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/spl/module.cpp

@@ -10,6 +10,7 @@
 #include <vector>
 #include "common/logging/log.h"
 #include "common/settings.h"
+#include "core/hle/api_version.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/spl/csrng.h"
 #include "core/hle/service/spl/module.h"
@@ -24,7 +25,46 @@ Module::Interface::Interface(Core::System& system_, std::shared_ptr<Module> modu
 
 Module::Interface::~Interface() = default;
 
-void Module::Interface::GetRandomBytes(Kernel::HLERequestContext& ctx) {
+void Module::Interface::GetConfig(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto config_item = rp.PopEnum<ConfigItem>();
+
+    // This should call svcCallSecureMonitor with the appropriate args.
+    // Since we do not have it implemented yet, we will use this for now.
+    const auto smc_result = GetConfigImpl(config_item);
+    const auto result_code = smc_result.Code();
+
+    if (smc_result.Failed()) {
+        LOG_ERROR(Service_SPL, "called, config_item={}, result_code={}", config_item,
+                  result_code.raw);
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(result_code);
+    }
+
+    LOG_DEBUG(Service_SPL, "called, config_item={}, result_code={}, smc_result={}", config_item,
+              result_code.raw, *smc_result);
+
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(result_code);
+    rb.Push(*smc_result);
+}
+
+void Module::Interface::ModularExponentiate(Kernel::HLERequestContext& ctx) {
+    UNIMPLEMENTED_MSG("ModularExponentiate is not implemented!");
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSecureMonitorNotImplemented);
+}
+
+void Module::Interface::SetConfig(Kernel::HLERequestContext& ctx) {
+    UNIMPLEMENTED_MSG("SetConfig is not implemented!");
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSecureMonitorNotImplemented);
+}
+
+void Module::Interface::GenerateRandomBytes(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_SPL, "called");
 
     const std::size_t size = ctx.GetWriteBufferSize();
@@ -39,6 +79,88 @@ void Module::Interface::GetRandomBytes(Kernel::HLERequestContext& ctx) {
     rb.Push(ResultSuccess);
 }
 
+void Module::Interface::IsDevelopment(Kernel::HLERequestContext& ctx) {
+    UNIMPLEMENTED_MSG("IsDevelopment is not implemented!");
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSecureMonitorNotImplemented);
+}
+
+void Module::Interface::SetBootReason(Kernel::HLERequestContext& ctx) {
+    UNIMPLEMENTED_MSG("SetBootReason is not implemented!");
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSecureMonitorNotImplemented);
+}
+
+void Module::Interface::GetBootReason(Kernel::HLERequestContext& ctx) {
+    UNIMPLEMENTED_MSG("GetBootReason is not implemented!");
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSecureMonitorNotImplemented);
+}
+
+ResultVal<u64> Module::Interface::GetConfigImpl(ConfigItem config_item) const {
+    switch (config_item) {
+    case ConfigItem::DisableProgramVerification:
+    case ConfigItem::DramId:
+    case ConfigItem::SecurityEngineInterruptNumber:
+    case ConfigItem::FuseVersion:
+    case ConfigItem::HardwareType:
+    case ConfigItem::HardwareState:
+    case ConfigItem::IsRecoveryBoot:
+    case ConfigItem::DeviceId:
+    case ConfigItem::BootReason:
+    case ConfigItem::MemoryMode:
+    case ConfigItem::IsDevelopmentFunctionEnabled:
+    case ConfigItem::KernelConfiguration:
+    case ConfigItem::IsChargerHiZModeEnabled:
+    case ConfigItem::QuestState:
+    case ConfigItem::RegulatorType:
+    case ConfigItem::DeviceUniqueKeyGeneration:
+    case ConfigItem::Package2Hash:
+        return ResultSecureMonitorNotImplemented;
+    case ConfigItem::ExosphereApiVersion:
+        // Get information about the current exosphere version.
+        return MakeResult((u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MAJOR} << 56) |
+                          (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MINOR} << 48) |
+                          (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MICRO} << 40) |
+                          (static_cast<u64>(HLE::ApiVersion::GetTargetFirmware())));
+    case ConfigItem::ExosphereNeedsReboot:
+        // We are executing, so we aren't in the process of rebooting.
+        return MakeResult(u64{0});
+    case ConfigItem::ExosphereNeedsShutdown:
+        // We are executing, so we aren't in the process of shutting down.
+        return MakeResult(u64{0});
+    case ConfigItem::ExosphereGitCommitHash:
+        // Get information about the current exosphere git commit hash.
+        return MakeResult(u64{0});
+    case ConfigItem::ExosphereHasRcmBugPatch:
+        // Get information about whether this unit has the RCM bug patched.
+        return MakeResult(u64{0});
+    case ConfigItem::ExosphereBlankProdInfo:
+        // Get whether this unit should simulate a "blanked" PRODINFO.
+        return MakeResult(u64{0});
+    case ConfigItem::ExosphereAllowCalWrites:
+        // Get whether this unit should allow writing to the calibration partition.
+        return MakeResult(u64{0});
+    case ConfigItem::ExosphereEmummcType:
+        // Get what kind of emummc this unit has active.
+        return MakeResult(u64{0});
+    case ConfigItem::ExospherePayloadAddress:
+        // Gets the physical address of the reboot payload buffer, if one exists.
+        return ResultSecureMonitorNotInitialized;
+    case ConfigItem::ExosphereLogConfiguration:
+        // Get the log configuration.
+        return MakeResult(u64{0});
+    case ConfigItem::ExosphereForceEnableUsb30:
+        // Get whether usb 3.0 should be force-enabled.
+        return MakeResult(u64{0});
+    default:
+        return ResultSecureMonitorInvalidArgument;
+    }
+}
+
 void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
     auto module = std::make_shared<Module>();
     std::make_shared<CSRNG>(system, module)->InstallAsService(service_manager);

src/core/hle/service/spl/module.h

@@ -6,6 +6,8 @@
 
 #include <random>
 #include "core/hle/service/service.h"
+#include "core/hle/service/spl/spl_results.h"
+#include "core/hle/service/spl/spl_types.h"
 
 namespace Core {
 class System;
@@ -21,12 +23,21 @@ public:
                            const char* name);
         ~Interface() override;
 
-        void GetRandomBytes(Kernel::HLERequestContext& ctx);
+        // General
+        void GetConfig(Kernel::HLERequestContext& ctx);
+        void ModularExponentiate(Kernel::HLERequestContext& ctx);
+        void SetConfig(Kernel::HLERequestContext& ctx);
+        void GenerateRandomBytes(Kernel::HLERequestContext& ctx);
+        void IsDevelopment(Kernel::HLERequestContext& ctx);
+        void SetBootReason(Kernel::HLERequestContext& ctx);
+        void GetBootReason(Kernel::HLERequestContext& ctx);
 
     protected:
         std::shared_ptr<Module> module;
 
     private:
+        ResultVal<u64> GetConfigImpl(ConfigItem config_item) const;
+
         std::mt19937 rng;
     };
 };

src/core/hle/service/spl/spl.cpp

@@ -10,13 +10,13 @@ SPL::SPL(Core::System& system_, std::shared_ptr<Module> module_)
     : Interface(system_, std::move(module_), "spl:") {
     // clang-format off
     static const FunctionInfo functions[] = {
-        {0, nullptr, "GetConfig"},
-        {1, nullptr, "ModularExponentiate"},
-        {5, nullptr, "SetConfig"},
-        {7, &SPL::GetRandomBytes, "GetRandomBytes"},
-        {11, nullptr, "IsDevelopment"},
-        {24, nullptr, "SetBootReason"},
-        {25, nullptr, "GetBootReason"},
+        {0, &SPL::GetConfig, "GetConfig"},
+        {1, &SPL::ModularExponentiate, "ModularExponentiate"},
+        {5, &SPL::SetConfig, "SetConfig"},
+        {7, &SPL::GenerateRandomBytes, "GenerateRandomBytes"},
+        {11, &SPL::IsDevelopment, "IsDevelopment"},
+        {24, &SPL::SetBootReason, "SetBootReason"},
+        {25, &SPL::GetBootReason, "GetBootReason"},
     };
     // clang-format on
 
@@ -27,22 +27,22 @@ SPL_MIG::SPL_MIG(Core::System& system_, std::shared_ptr<Module> module_)
     : Interface(system_, std::move(module_), "spl:mig") {
     // clang-format off
     static const FunctionInfo functions[] = {
-        {0, nullptr, "GetConfig"},
-        {1, nullptr, "ModularExponentiate"},
+        {0, &SPL::GetConfig, "GetConfig"},
+        {1, &SPL::ModularExponentiate, "ModularExponentiate"},
         {2, nullptr, "GenerateAesKek"},
         {3, nullptr, "LoadAesKey"},
         {4, nullptr, "GenerateAesKey"},
-        {5, nullptr, "SetConfig"},
-        {7, &SPL::GetRandomBytes, "GenerateRandomBytes"},
-        {11, nullptr, "IsDevelopment"},
+        {5, &SPL::SetConfig, "SetConfig"},
+        {7, &SPL::GenerateRandomBytes, "GenerateRandomBytes"},
+        {11, &SPL::IsDevelopment, "IsDevelopment"},
         {14, nullptr, "DecryptAesKey"},
         {15, nullptr, "CryptAesCtr"},
         {16, nullptr, "ComputeCmac"},
         {21, nullptr, "AllocateAesKeyslot"},
         {22, nullptr, "DeallocateAesKeySlot"},
         {23, nullptr, "GetAesKeyslotAvailableEvent"},
-        {24, nullptr, "SetBootReason"},
-        {25, nullptr, "GetBootReason"},
+        {24, &SPL::SetBootReason, "SetBootReason"},
+        {25, &SPL::GetBootReason, "GetBootReason"},
     };
     // clang-format on
 
@@ -53,16 +53,16 @@ SPL_FS::SPL_FS(Core::System& system_, std::shared_ptr<Module> module_)
     : Interface(system_, std::move(module_), "spl:fs") {
     // clang-format off
     static const FunctionInfo functions[] = {
-        {0, nullptr, "GetConfig"},
-        {1, nullptr, "ModularExponentiate"},
+        {0, &SPL::GetConfig, "GetConfig"},
+        {1, &SPL::ModularExponentiate, "ModularExponentiate"},
         {2, nullptr, "GenerateAesKek"},
         {3, nullptr, "LoadAesKey"},
         {4, nullptr, "GenerateAesKey"},
-        {5, nullptr, "SetConfig"},
-        {7, &SPL::GetRandomBytes, "GenerateRandomBytes"},
+        {5, &SPL::SetConfig, "SetConfig"},
+        {7, &SPL::GenerateRandomBytes, "GenerateRandomBytes"},
         {9, nullptr, "ImportLotusKey"},
         {10, nullptr, "DecryptLotusMessage"},
-        {11, nullptr, "IsDevelopment"},
+        {11, &SPL::IsDevelopment, "IsDevelopment"},
         {12, nullptr, "GenerateSpecificAesKey"},
         {14, nullptr, "DecryptAesKey"},
         {15, nullptr, "CryptAesCtr"},
@@ -71,8 +71,8 @@ SPL_FS::SPL_FS(Core::System& system_, std::shared_ptr<Module> module_)
         {21, nullptr, "AllocateAesKeyslot"},
         {22, nullptr, "DeallocateAesKeySlot"},
         {23, nullptr, "GetAesKeyslotAvailableEvent"},
-        {24, nullptr, "SetBootReason"},
-        {25, nullptr, "GetBootReason"},
+        {24, &SPL::SetBootReason, "SetBootReason"},
+        {25, &SPL::GetBootReason, "GetBootReason"},
         {31, nullptr, "GetPackage2Hash"},
     };
     // clang-format on
@@ -84,14 +84,14 @@ SPL_SSL::SPL_SSL(Core::System& system_, std::shared_ptr<Module> module_)
     : Interface(system_, std::move(module_), "spl:ssl") {
     // clang-format off
     static const FunctionInfo functions[] = {
-        {0, nullptr, "GetConfig"},
-        {1, nullptr, "ModularExponentiate"},
+        {0, &SPL::GetConfig, "GetConfig"},
+        {1, &SPL::ModularExponentiate, "ModularExponentiate"},
         {2, nullptr, "GenerateAesKek"},
         {3, nullptr, "LoadAesKey"},
         {4, nullptr, "GenerateAesKey"},
-        {5, nullptr, "SetConfig"},
-        {7, &SPL::GetRandomBytes, "GetRandomBytes"},
-        {11, nullptr, "IsDevelopment"},
+        {5, &SPL::SetConfig, "SetConfig"},
+        {7, &SPL::GenerateRandomBytes, "GenerateRandomBytes"},
+        {11, &SPL::IsDevelopment, "IsDevelopment"},
         {13, nullptr, "DecryptDeviceUniqueData"},
         {14, nullptr, "DecryptAesKey"},
         {15, nullptr, "CryptAesCtr"},
@@ -99,8 +99,8 @@ SPL_SSL::SPL_SSL(Core::System& system_, std::shared_ptr<Module> module_)
         {21, nullptr, "AllocateAesKeyslot"},
         {22, nullptr, "DeallocateAesKeySlot"},
         {23, nullptr, "GetAesKeyslotAvailableEvent"},
-        {24, nullptr, "SetBootReason"},
-        {25, nullptr, "GetBootReason"},
+        {24, &SPL::SetBootReason, "SetBootReason"},
+        {25, &SPL::GetBootReason, "GetBootReason"},
         {26, nullptr, "DecryptAndStoreSslClientCertKey"},
         {27, nullptr, "ModularExponentiateWithSslClientCertKey"},
     };
@@ -113,14 +113,14 @@ SPL_ES::SPL_ES(Core::System& system_, std::shared_ptr<Module> module_)
     : Interface(system_, std::move(module_), "spl:es") {
     // clang-format off
     static const FunctionInfo functions[] = {
-        {0, nullptr, "GetConfig"},
-        {1, nullptr, "ModularExponentiate"},
+        {0, &SPL::GetConfig, "GetConfig"},
+        {1, &SPL::ModularExponentiate, "ModularExponentiate"},
         {2, nullptr, "GenerateAesKek"},
         {3, nullptr, "LoadAesKey"},
         {4, nullptr, "GenerateAesKey"},
-        {5, nullptr, "SetConfig"},
-        {7, &SPL::GetRandomBytes, "GenerateRandomBytes"},
-        {11, nullptr, "IsDevelopment"},
+        {5, &SPL::SetConfig, "SetConfig"},
+        {7, &SPL::GenerateRandomBytes, "GenerateRandomBytes"},
+        {11, &SPL::IsDevelopment, "IsDevelopment"},
         {13, nullptr, "DecryptDeviceUniqueData"},
         {14, nullptr, "DecryptAesKey"},
         {15, nullptr, "CryptAesCtr"},
@@ -131,8 +131,8 @@ SPL_ES::SPL_ES(Core::System& system_, std::shared_ptr<Module> module_)
         {21, nullptr, "AllocateAesKeyslot"},
         {22, nullptr, "DeallocateAesKeySlot"},
         {23, nullptr, "GetAesKeyslotAvailableEvent"},
-        {24, nullptr, "SetBootReason"},
-        {25, nullptr, "GetBootReason"},
+        {24, &SPL::SetBootReason, "SetBootReason"},
+        {25, &SPL::GetBootReason, "GetBootReason"},
         {28, nullptr, "DecryptAndStoreDrmDeviceCertKey"},
         {29, nullptr, "ModularExponentiateWithDrmDeviceCertKey"},
         {31, nullptr, "PrepareEsArchiveKey"},
@@ -147,14 +147,14 @@ SPL_MANU::SPL_MANU(Core::System& system_, std::shared_ptr<Module> module_)
     : Interface(system_, std::move(module_), "spl:manu") {
     // clang-format off
     static const FunctionInfo functions[] = {
-        {0, nullptr, "GetConfig"},
-        {1, nullptr, "ModularExponentiate"},
+        {0, &SPL::GetConfig, "GetConfig"},
+        {1, &SPL::ModularExponentiate, "ModularExponentiate"},
         {2, nullptr, "GenerateAesKek"},
         {3, nullptr, "LoadAesKey"},
         {4, nullptr, "GenerateAesKey"},
-        {5, nullptr, "SetConfig"},
-        {7, &SPL::GetRandomBytes, "GetRandomBytes"},
-        {11, nullptr, "IsDevelopment"},
+        {5, &SPL::SetConfig, "SetConfig"},
+        {7, &SPL::GenerateRandomBytes, "GenerateRandomBytes"},
+        {11, &SPL::IsDevelopment, "IsDevelopment"},
         {13, nullptr, "DecryptDeviceUniqueData"},
         {14, nullptr, "DecryptAesKey"},
         {15, nullptr, "CryptAesCtr"},
@@ -162,8 +162,8 @@ SPL_MANU::SPL_MANU(Core::System& system_, std::shared_ptr<Module> module_)
         {21, nullptr, "AllocateAesKeyslot"},
         {22, nullptr, "DeallocateAesKeySlot"},
         {23, nullptr, "GetAesKeyslotAvailableEvent"},
-        {24, nullptr, "SetBootReason"},
-        {25, nullptr, "GetBootReason"},
+        {24, &SPL::SetBootReason, "SetBootReason"},
+        {25, &SPL::GetBootReason, "GetBootReason"},
         {30, nullptr, "ReencryptDeviceUniqueData"},
     };
     // clang-format on

src/core/hle/service/spl/spl_results.h

@@ -0,0 +1,29 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/result.h"
+
+namespace Service::SPL {
+
+// Description 0 - 99
+constexpr ResultCode ResultSecureMonitorError{ErrorModule::SPL, 0};
+constexpr ResultCode ResultSecureMonitorNotImplemented{ErrorModule::SPL, 1};
+constexpr ResultCode ResultSecureMonitorInvalidArgument{ErrorModule::SPL, 2};
+constexpr ResultCode ResultSecureMonitorBusy{ErrorModule::SPL, 3};
+constexpr ResultCode ResultSecureMonitorNoAsyncOperation{ErrorModule::SPL, 4};
+constexpr ResultCode ResultSecureMonitorInvalidAsyncOperation{ErrorModule::SPL, 5};
+constexpr ResultCode ResultSecureMonitorNotPermitted{ErrorModule::SPL, 6};
+constexpr ResultCode ResultSecureMonitorNotInitialized{ErrorModule::SPL, 7};
+
+constexpr ResultCode ResultInvalidSize{ErrorModule::SPL, 100};
+constexpr ResultCode ResultUnknownSecureMonitorError{ErrorModule::SPL, 101};
+constexpr ResultCode ResultDecryptionFailed{ErrorModule::SPL, 102};
+
+constexpr ResultCode ResultOutOfKeySlots{ErrorModule::SPL, 104};
+constexpr ResultCode ResultInvalidKeySlot{ErrorModule::SPL, 105};
+constexpr ResultCode ResultBootReasonAlreadySet{ErrorModule::SPL, 106};
+constexpr ResultCode ResultBootReasonNotSet{ErrorModule::SPL, 107};
+constexpr ResultCode ResultInvalidArgument{ErrorModule::SPL, 108};
+
+} // namespace Service::SPL

src/core/hle/service/spl/spl_types.h

@@ -0,0 +1,230 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <span>
+
+#include "common/bit_field.h"
+#include "common/common_types.h"
+
+namespace Service::SPL {
+
+constexpr size_t AES_128_KEY_SIZE = 0x10;
+
+namespace Smc {
+
+enum class FunctionId : u32 {
+    SetConfig = 0xC3000401,
+    GetConfig = 0xC3000002,
+    GetResult = 0xC3000003,
+    GetResultData = 0xC3000404,
+    ModularExponentiate = 0xC3000E05,
+    GenerateRandomBytes = 0xC3000006,
+    GenerateAesKek = 0xC3000007,
+    LoadAesKey = 0xC3000008,
+    ComputeAes = 0xC3000009,
+    GenerateSpecificAesKey = 0xC300000A,
+    ComputeCmac = 0xC300040B,
+    ReencryptDeviceUniqueData = 0xC300D60C,
+    DecryptDeviceUniqueData = 0xC300100D,
+
+    ModularExponentiateWithStorageKey = 0xC300060F,
+    PrepareEsDeviceUniqueKey = 0xC3000610,
+    LoadPreparedAesKey = 0xC3000011,
+    PrepareCommonEsTitleKey = 0xC3000012,
+
+    // Deprecated functions.
+    LoadEsDeviceKey = 0xC300100C,
+    DecryptAndStoreGcKey = 0xC300100E,
+
+    // Atmosphere functions.
+    AtmosphereIramCopy = 0xF0000201,
+    AtmosphereReadWriteRegister = 0xF0000002,
+
+    AtmosphereGetEmummcConfig = 0xF0000404,
+};
+
+enum class CipherMode {
+    CbcEncrypt = 0,
+    CbcDecrypt = 1,
+    Ctr = 2,
+};
+
+enum class DeviceUniqueDataMode {
+    DecryptDeviceUniqueData = 0,
+    DecryptAndStoreGcKey = 1,
+    DecryptAndStoreEsDeviceKey = 2,
+    DecryptAndStoreSslKey = 3,
+    DecryptAndStoreDrmDeviceCertKey = 4,
+};
+
+enum class ModularExponentiateWithStorageKeyMode {
+    Gc = 0,
+    Ssl = 1,
+    DrmDeviceCert = 2,
+};
+
+enum class EsCommonKeyType {
+    TitleKey = 0,
+    ArchiveKey = 1,
+};
+
+struct AsyncOperationKey {
+    u64 value;
+};
+
+} // namespace Smc
+
+enum class HardwareType {
+    Icosa = 0,
+    Copper = 1,
+    Hoag = 2,
+    Iowa = 3,
+    Calcio = 4,
+    Aula = 5,
+};
+
+enum class SocType {
+    Erista = 0,
+    Mariko = 1,
+};
+
+enum class HardwareState {
+    Development = 0,
+    Production = 1,
+};
+
+enum class MemoryArrangement {
+    Standard = 0,
+    StandardForAppletDev = 1,
+    StandardForSystemDev = 2,
+    Expanded = 3,
+    ExpandedForAppletDev = 4,
+
+    // Note: Dynamic is not official.
+    // Atmosphere uses it to maintain compatibility with firmwares prior to 6.0.0,
+    // which removed the explicit retrieval of memory arrangement from PM.
+    Dynamic = 5,
+    Count,
+};
+
+enum class BootReason {
+    Unknown = 0,
+    AcOk = 1,
+    OnKey = 2,
+    RtcAlarm1 = 3,
+    RtcAlarm2 = 4,
+};
+
+struct BootReasonValue {
+    union {
+        u32 value{};
+
+        BitField<0, 8, u32> power_intr;
+        BitField<8, 8, u32> rtc_intr;
+        BitField<16, 8, u32> nv_erc;
+        BitField<24, 8, u32> boot_reason;
+    };
+};
+static_assert(sizeof(BootReasonValue) == sizeof(u32), "BootReasonValue definition!");
+
+struct AesKey {
+    std::array<u64, AES_128_KEY_SIZE / sizeof(u64)> data64{};
+
+    std::span<u8> AsBytes() {
+        return std::span{reinterpret_cast<u8*>(data64.data()), AES_128_KEY_SIZE};
+    }
+
+    std::span<const u8> AsBytes() const {
+        return std::span{reinterpret_cast<const u8*>(data64.data()), AES_128_KEY_SIZE};
+    }
+};
+static_assert(sizeof(AesKey) == AES_128_KEY_SIZE, "AesKey definition!");
+
+struct IvCtr {
+    std::array<u64, AES_128_KEY_SIZE / sizeof(u64)> data64{};
+
+    std::span<u8> AsBytes() {
+        return std::span{reinterpret_cast<u8*>(data64.data()), AES_128_KEY_SIZE};
+    }
+
+    std::span<const u8> AsBytes() const {
+        return std::span{reinterpret_cast<const u8*>(data64.data()), AES_128_KEY_SIZE};
+    }
+};
+static_assert(sizeof(AesKey) == AES_128_KEY_SIZE, "IvCtr definition!");
+
+struct Cmac {
+    std::array<u64, AES_128_KEY_SIZE / sizeof(u64)> data64{};
+
+    std::span<u8> AsBytes() {
+        return std::span{reinterpret_cast<u8*>(data64.data()), AES_128_KEY_SIZE};
+    }
+
+    std::span<const u8> AsBytes() const {
+        return std::span{reinterpret_cast<const u8*>(data64.data()), AES_128_KEY_SIZE};
+    }
+};
+static_assert(sizeof(AesKey) == AES_128_KEY_SIZE, "Cmac definition!");
+
+struct AccessKey {
+    std::array<u64, AES_128_KEY_SIZE / sizeof(u64)> data64{};
+
+    std::span<u8> AsBytes() {
+        return std::span{reinterpret_cast<u8*>(data64.data()), AES_128_KEY_SIZE};
+    }
+
+    std::span<const u8> AsBytes() const {
+        return std::span{reinterpret_cast<const u8*>(data64.data()), AES_128_KEY_SIZE};
+    }
+};
+static_assert(sizeof(AesKey) == AES_128_KEY_SIZE, "AccessKey definition!");
+
+struct KeySource {
+    std::array<u64, AES_128_KEY_SIZE / sizeof(u64)> data64{};
+
+    std::span<u8> AsBytes() {
+        return std::span{reinterpret_cast<u8*>(data64.data()), AES_128_KEY_SIZE};
+    }
+
+    std::span<const u8> AsBytes() const {
+        return std::span{reinterpret_cast<const u8*>(data64.data()), AES_128_KEY_SIZE};
+    }
+};
+static_assert(sizeof(AesKey) == AES_128_KEY_SIZE, "KeySource definition!");
+
+enum class ConfigItem : u32 {
+    // Standard config items.
+    DisableProgramVerification = 1,
+    DramId = 2,
+    SecurityEngineInterruptNumber = 3,
+    FuseVersion = 4,
+    HardwareType = 5,
+    HardwareState = 6,
+    IsRecoveryBoot = 7,
+    DeviceId = 8,
+    BootReason = 9,
+    MemoryMode = 10,
+    IsDevelopmentFunctionEnabled = 11,
+    KernelConfiguration = 12,
+    IsChargerHiZModeEnabled = 13,
+    QuestState = 14,
+    RegulatorType = 15,
+    DeviceUniqueKeyGeneration = 16,
+    Package2Hash = 17,
+
+    // Extension config items for exosphere.
+    ExosphereApiVersion = 65000,
+    ExosphereNeedsReboot = 65001,
+    ExosphereNeedsShutdown = 65002,
+    ExosphereGitCommitHash = 65003,
+    ExosphereHasRcmBugPatch = 65004,
+    ExosphereBlankProdInfo = 65005,
+    ExosphereAllowCalWrites = 65006,
+    ExosphereEmummcType = 65007,
+    ExospherePayloadAddress = 65008,
+    ExosphereLogConfiguration = 65009,
+    ExosphereForceEnableUsb30 = 65010,
+};
+
+} // namespace Service::SPL

src/core/reporter.cpp

@@ -195,9 +195,7 @@ json GetHLERequestContextData(Kernel::HLERequestContext& ctx, Core::Memory::Memo
 
 namespace Core {
 
-Reporter::Reporter(System& system_) : system(system_) {
-    ClearFSAccessLog();
-}
+Reporter::Reporter(System& system_) : system(system_) {}
 
 Reporter::~Reporter() = default;
 
@@ -364,12 +362,22 @@ void Reporter::SaveErrorReport(u64 title_id, ResultCode result,
     SaveToFile(std::move(out), GetPath("error_report", title_id, timestamp));
 }
 
-void Reporter::SaveFSAccessLog(std::string_view log_message) const {
-    const auto access_log_path =
-        Common::FS::GetYuzuPath(Common::FS::YuzuPath::SDMCDir) / "FsAccessLog.txt";
+void Reporter::SaveFilesystemAccessReport(Service::FileSystem::LogMode log_mode,
+                                          std::string log_message) const {
+    if (!IsReportingEnabled())
+        return;
 
-    void(Common::FS::AppendStringToFile(access_log_path, Common::FS::FileType::TextFile,
-                                        log_message));
+    const auto timestamp = GetTimestamp();
+    const auto title_id = system.CurrentProcess()->GetTitleID();
+    json out;
+
+    out["yuzu_version"] = GetYuzuVersionData();
+    out["report_common"] = GetReportCommonData(title_id, ResultSuccess, timestamp);
+
+    out["log_mode"] = fmt::format("{:08X}", static_cast<u32>(log_mode));
+    out["log_message"] = std::move(log_message);
+
+    SaveToFile(std::move(out), GetPath("filesystem_access_report", title_id, timestamp));
 }
 
 void Reporter::SaveUserReport() const {
@@ -384,18 +392,6 @@ void Reporter::SaveUserReport() const {
                GetPath("user_report", title_id, timestamp));
 }
 
-void Reporter::ClearFSAccessLog() const {
-    const auto access_log_path =
-        Common::FS::GetYuzuPath(Common::FS::YuzuPath::SDMCDir) / "FsAccessLog.txt";
-
-    Common::FS::IOFile access_log_file{access_log_path, Common::FS::FileAccessMode::Write,
-                                       Common::FS::FileType::TextFile};
-
-    if (!access_log_file.IsOpen()) {
-        LOG_ERROR(Common_Filesystem, "Failed to clear the filesystem access log.");
-    }
-}
-
 bool Reporter::IsReportingEnabled() const {
     return Settings::values.reporting_services;
 }

src/core/reporter.h

@@ -16,6 +16,10 @@ namespace Kernel {
 class HLERequestContext;
 } // namespace Kernel
 
+namespace Service::FileSystem {
+enum class LogMode : u32;
+}
+
 namespace Service::LM {
 struct LogMessage;
 } // namespace Service::LM
@@ -65,15 +69,14 @@ public:
                          std::optional<std::string> custom_text_main = {},
                          std::optional<std::string> custom_text_detail = {}) const;
 
-    void SaveFSAccessLog(std::string_view log_message) const;
+    void SaveFilesystemAccessReport(Service::FileSystem::LogMode log_mode,
+                                    std::string log_message) const;
 
     // Can be used anywhere to generate a backtrace and general info report at any point during
     // execution. Not intended to be used for anything other than debugging or testing.
     void SaveUserReport() const;
 
 private:
-    void ClearFSAccessLog() const;
-
     bool IsReportingEnabled() const;
 
     System& system;

src/core/telemetry_session.cpp

@@ -230,7 +230,6 @@ void TelemetrySession::AddInitialInfo(Loader::AppLoader& app_loader,
              Settings::values.use_asynchronous_gpu_emulation.GetValue());
     AddField(field_type, "Renderer_UseNvdecEmulation",
              Settings::values.use_nvdec_emulation.GetValue());
-    AddField(field_type, "Renderer_AccelerateASTC", Settings::values.accelerate_astc.GetValue());
     AddField(field_type, "Renderer_UseVsync", Settings::values.use_vsync.GetValue());
     AddField(field_type, "Renderer_UseAssemblyShaders",
              Settings::values.use_assembly_shaders.GetValue());

src/input_common/mouse/mouse_input.cpp

@@ -2,23 +2,25 @@
 // Licensed under GPLv2+
 // Refer to the license.txt file included.
 
-#include <stop_token>
-#include <thread>
-
 #include "common/settings.h"
 #include "input_common/mouse/mouse_input.h"
 
 namespace MouseInput {
 
 Mouse::Mouse() {
-    update_thread = std::jthread([this](std::stop_token stop_token) { UpdateThread(stop_token); });
+    update_thread = std::thread(&Mouse::UpdateThread, this);
 }
 
-Mouse::~Mouse() = default;
+Mouse::~Mouse() {
+    update_thread_running = false;
+    if (update_thread.joinable()) {
+        update_thread.join();
+    }
+}
 
-void Mouse::UpdateThread(std::stop_token stop_token) {
+void Mouse::UpdateThread() {
     constexpr int update_time = 10;
-    while (!stop_token.stop_requested()) {
+    while (update_thread_running) {
         for (MouseInfo& info : mouse_info) {
             const Common::Vec3f angular_direction{
                 -info.tilt_direction.y,

src/input_common/mouse/mouse_input.h

@@ -6,7 +6,6 @@
 
 #include <array>
 #include <mutex>
-#include <stop_token>
 #include <thread>
 
 #include "common/common_types.h"
@@ -86,7 +85,7 @@ public:
     [[nodiscard]] const MouseData& GetMouseState(std::size_t button) const;
 
 private:
-    void UpdateThread(std::stop_token stop_token);
+    void UpdateThread();
     void UpdateYuzuSettings();
     void StopPanning();
 
@@ -106,11 +105,12 @@ private:
     u16 buttons{};
     u16 toggle_buttons{};
     u16 lock_buttons{};
-    std::jthread update_thread;
+    std::thread update_thread;
     MouseButton last_button{MouseButton::Undefined};
     std::array<MouseInfo, 7> mouse_info;
     Common::SPSCQueue<MouseStatus> mouse_queue;
     bool configuring{false};
+    bool update_thread_running{true};
     int mouse_panning_timout{};
 };
 } // namespace MouseInput

src/video_core/CMakeLists.txt

@@ -237,7 +237,6 @@ add_library(video_core STATIC
     texture_cache/util.cpp
     texture_cache/util.h
     textures/astc.h
-    textures/astc.cpp
     textures/decoders.cpp
     textures/decoders.h
     textures/texture.cpp

src/video_core/host_shaders/astc_decoder.comp

@@ -763,7 +763,7 @@ void ComputeEndpoints(out uvec4 ep1, out uvec4 ep2, uint color_endpoint_mode) {
     case 1: {
         READ_UINT_VALUES(2)
         uint L0 = (v[0] >> 2) | (v[1] & 0xC0);
-        uint L1 = min(L0 + (v[1] & 0x3F), 0xFFU);
+        uint L1 = max(L0 + (v[1] & 0x3F), 0xFFU);
         ep1 = uvec4(0xFF, L0, L0, L0);
         ep2 = uvec4(0xFF, L1, L1, L1);
         break;

src/video_core/renderer_opengl/gl_texture_cache.cpp

@@ -9,8 +9,6 @@
 
 #include <glad/glad.h>
 
-#include "common/settings.h"
-
 #include "video_core/renderer_opengl/gl_device.h"
 #include "video_core/renderer_opengl/gl_shader_manager.h"
 #include "video_core/renderer_opengl/gl_state_tracker.h"
@@ -309,9 +307,7 @@ void ApplySwizzle(GLuint handle, PixelFormat format, std::array<SwizzleSource, 4
 
 [[nodiscard]] bool CanBeAccelerated(const TextureCacheRuntime& runtime,
                                     const VideoCommon::ImageInfo& info) {
-    if (IsPixelFormatASTC(info.format)) {
-        return !runtime.HasNativeASTC() && Settings::values.accelerate_astc.GetValue();
-    }
+    return !runtime.HasNativeASTC() && IsPixelFormatASTC(info.format);
     // Disable other accelerated uploads for now as they don't implement swizzled uploads
     return false;
     switch (info.type) {

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -8,7 +8,6 @@
 #include <vector>
 
 #include "common/bit_cast.h"
-#include "common/settings.h"
 
 #include "video_core/engines/fermi_2d.h"
 #include "video_core/renderer_vulkan/blit_image.h"
@@ -829,11 +828,7 @@ Image::Image(TextureCacheRuntime& runtime, const ImageInfo& info_, GPUVAddr gpu_
         commit = runtime.memory_allocator.Commit(buffer, MemoryUsage::DeviceLocal);
     }
     if (IsPixelFormatASTC(info.format) && !runtime.device.IsOptimalAstcSupported()) {
-        if (Settings::values.accelerate_astc.GetValue()) {
-            flags |= VideoCommon::ImageFlagBits::AcceleratedUpload;
-        } else {
-            flags |= VideoCommon::ImageFlagBits::Converted;
-        }
+        flags |= VideoCommon::ImageFlagBits::AcceleratedUpload;
     }
     if (runtime.device.HasDebuggingToolAttached()) {
         if (image) {

src/video_core/texture_cache/util.cpp

@@ -47,7 +47,6 @@
 #include "video_core/texture_cache/formatter.h"
 #include "video_core/texture_cache/samples_helper.h"
 #include "video_core/texture_cache/util.h"
-#include "video_core/textures/astc.h"
 #include "video_core/textures/decoders.h"
 
 namespace VideoCommon {
@@ -885,16 +884,8 @@ void ConvertImage(std::span<const u8> input, const ImageInfo& info, std::span<u8
         ASSERT(copy.image_extent == mip_size);
         ASSERT(copy.buffer_row_length == Common::AlignUp(mip_size.width, tile_size.width));
         ASSERT(copy.buffer_image_height == Common::AlignUp(mip_size.height, tile_size.height));
-        if (IsPixelFormatASTC(info.format)) {
-            ASSERT(copy.image_extent.depth == 1);
-            Tegra::Texture::ASTC::Decompress(input.subspan(copy.buffer_offset),
-                                             copy.image_extent.width, copy.image_extent.height,
-                                             copy.image_subresource.num_layers, tile_size.width,
-                                             tile_size.height, output.subspan(output_offset));
-        } else {
-            DecompressBC4(input.subspan(copy.buffer_offset), copy.image_extent,
-                          output.subspan(output_offset));
-        }
+        DecompressBC4(input.subspan(copy.buffer_offset), copy.image_extent,
+                      output.subspan(output_offset));
         copy.buffer_offset = output_offset;
         copy.buffer_row_length = mip_size.width;
         copy.buffer_image_height = mip_size.height;
@@ -1096,15 +1087,7 @@ std::optional<SubresourceBase> FindSubresource(const ImageInfo& candidate, const
         return std::nullopt;
     }
     const ImageInfo& existing = image.info;
-    if (True(options & RelaxedOptions::Format)) {
-        // Format checking is relaxed, but we still have to check for matching bytes per block.
-        // This avoids creating a view for blits on UE4 titles where formats with different bytes
-        // per block are aliased.
-        if (BytesPerBlock(existing.format) != BytesPerBlock(candidate.format)) {
-            return std::nullopt;
-        }
-    } else {
-        // Format comaptibility is not relaxed, ensure we are creating a view on a compatible format
+    if (False(options & RelaxedOptions::Format)) {
         if (!IsViewCompatible(existing.format, candidate.format, broken_views, native_bgr)) {
             return std::nullopt;
         }

src/video_core/textures/astc.h

@@ -129,7 +129,4 @@ struct AstcBufferData {
     decltype(REPLICATE_BYTE_TO_16_TABLE) replicate_byte_to_16 = REPLICATE_BYTE_TO_16_TABLE;
 } constexpr ASTC_BUFFER_DATA;
 
-void Decompress(std::span<const uint8_t> data, uint32_t width, uint32_t height, uint32_t depth,
-                uint32_t block_width, uint32_t block_height, std::span<uint8_t> output);
-
 } // namespace Tegra::Texture::ASTC

src/video_core/vulkan_common/vulkan_debug_callback.cpp

@@ -12,14 +12,6 @@ VkBool32 Callback(VkDebugUtilsMessageSeverityFlagBitsEXT severity,
                   VkDebugUtilsMessageTypeFlagsEXT type,
                   const VkDebugUtilsMessengerCallbackDataEXT* data,
                   [[maybe_unused]] void* user_data) {
-    // Skip logging known false-positive validation errors
-    switch (static_cast<u32>(data->messageIdNumber)) {
-    case 0x682a878au: // VUID-vkCmdBindVertexBuffers2EXT-pBuffers-parameter
-    case 0x99fb7dfdu: // UNASSIGNED-RequiredParameter (vkCmdBindVertexBuffers2EXT pBuffers[0])
-        return VK_FALSE;
-    default:
-        break;
-    }
     const std::string_view message{data->pMessage};
     if (severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) {
         LOG_CRITICAL(Render_Vulkan, "{}", message);

src/web_service/web_backend.cpp

@@ -100,9 +100,8 @@ struct Client::Impl {
         request.body = data;
 
         httplib::Response response;
-        httplib::Error error;
 
-        if (!cli->send(request, response, error)) {
+        if (!cli->send(request, response)) {
             LOG_ERROR(WebService, "{} to {} returned null", method, host + path);
             return WebResult{WebResult::Code::LibError, "Null response", ""};
         }

src/yuzu/configuration/config.cpp

@@ -221,7 +221,7 @@ const std::array<int, Settings::NativeKeyboard::NumKeyboardMods> Config::default
 // This must be in alphabetical order according to action name as it must have the same order as
 // UISetting::values.shortcuts, which is alphabetically ordered.
 // clang-format off
-const std::array<UISettings::Shortcut, 18> Config::default_hotkeys{{
+const std::array<UISettings::Shortcut, 17> Config::default_hotkeys{{
     {QStringLiteral("Capture Screenshot"),       QStringLiteral("Main Window"), {QStringLiteral("Ctrl+P"), Qt::WidgetWithChildrenShortcut}},
     {QStringLiteral("Change Docked Mode"),       QStringLiteral("Main Window"), {QStringLiteral("F10"), Qt::ApplicationShortcut}},
     {QStringLiteral("Continue/Pause Emulation"), QStringLiteral("Main Window"), {QStringLiteral("F4"), Qt::WindowShortcut}},
@@ -236,7 +236,6 @@ const std::array<UISettings::Shortcut, 18> Config::default_hotkeys{{
     {QStringLiteral("Restart Emulation"),        QStringLiteral("Main Window"), {QStringLiteral("F6"), Qt::WindowShortcut}},
     {QStringLiteral("Stop Emulation"),           QStringLiteral("Main Window"), {QStringLiteral("F5"), Qt::WindowShortcut}},
     {QStringLiteral("Toggle Filter Bar"),        QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F"), Qt::WindowShortcut}},
-    {QStringLiteral("Toggle Framerate Limit"),   QStringLiteral("Main Window"), {QStringLiteral("Ctrl+U"), Qt::ApplicationShortcut}},
     {QStringLiteral("Toggle Mouse Panning"),     QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F9"), Qt::ApplicationShortcut}},
     {QStringLiteral("Toggle Speed Limit"),       QStringLiteral("Main Window"), {QStringLiteral("Ctrl+Z"), Qt::ApplicationShortcut}},
     {QStringLiteral("Toggle Status Bar"),        QStringLiteral("Main Window"), {QStringLiteral("Ctrl+S"), Qt::WindowShortcut}},
@@ -648,8 +647,6 @@ void Config::ReadDebuggingValues() {
         ReadSetting(QStringLiteral("program_args"), QString{}).toString().toStdString();
     Settings::values.dump_exefs = ReadSetting(QStringLiteral("dump_exefs"), false).toBool();
     Settings::values.dump_nso = ReadSetting(QStringLiteral("dump_nso"), false).toBool();
-    Settings::values.enable_fs_access_log =
-        ReadSetting(QStringLiteral("enable_fs_access_log"), false).toBool();
     Settings::values.reporting_services =
         ReadSetting(QStringLiteral("reporting_services"), false).toBool();
     Settings::values.quest_flag = ReadSetting(QStringLiteral("quest_flag"), false).toBool();
@@ -757,8 +754,6 @@ void Config::ReadCpuValues() {
                       QStringLiteral("cpuopt_unsafe_unfuse_fma"), true);
     ReadSettingGlobal(Settings::values.cpuopt_unsafe_reduce_fp_error,
                       QStringLiteral("cpuopt_unsafe_reduce_fp_error"), true);
-    ReadSettingGlobal(Settings::values.cpuopt_unsafe_ignore_standard_fpcr,
-                      QStringLiteral("cpuopt_unsafe_ignore_standard_fpcr"), true);
     ReadSettingGlobal(Settings::values.cpuopt_unsafe_inaccurate_nan,
                       QStringLiteral("cpuopt_unsafe_inaccurate_nan"), true);
     ReadSettingGlobal(Settings::values.cpuopt_unsafe_fastmem_check,
@@ -812,10 +807,7 @@ void Config::ReadRendererValues() {
                       QStringLiteral("use_asynchronous_gpu_emulation"), true);
     ReadSettingGlobal(Settings::values.use_nvdec_emulation, QStringLiteral("use_nvdec_emulation"),
                       true);
-    ReadSettingGlobal(Settings::values.accelerate_astc, QStringLiteral("accelerate_astc"), true);
     ReadSettingGlobal(Settings::values.use_vsync, QStringLiteral("use_vsync"), true);
-    ReadSettingGlobal(Settings::values.disable_fps_limit, QStringLiteral("disable_fps_limit"),
-                      false);
     ReadSettingGlobal(Settings::values.use_assembly_shaders, QStringLiteral("use_assembly_shaders"),
                       false);
     ReadSettingGlobal(Settings::values.use_asynchronous_shaders,
@@ -1266,8 +1258,6 @@ void Config::SaveDebuggingValues() {
                  QString::fromStdString(Settings::values.program_args), QString{});
     WriteSetting(QStringLiteral("dump_exefs"), Settings::values.dump_exefs, false);
     WriteSetting(QStringLiteral("dump_nso"), Settings::values.dump_nso, false);
-    WriteSetting(QStringLiteral("enable_fs_access_log"), Settings::values.enable_fs_access_log,
-                 false);
     WriteSetting(QStringLiteral("quest_flag"), Settings::values.quest_flag, false);
     WriteSetting(QStringLiteral("use_debug_asserts"), Settings::values.use_debug_asserts, false);
     WriteSetting(QStringLiteral("disable_macro_jit"), Settings::values.disable_macro_jit, false);
@@ -1344,8 +1334,6 @@ void Config::SaveCpuValues() {
                        Settings::values.cpuopt_unsafe_unfuse_fma, true);
     WriteSettingGlobal(QStringLiteral("cpuopt_unsafe_reduce_fp_error"),
                        Settings::values.cpuopt_unsafe_reduce_fp_error, true);
-    WriteSettingGlobal(QStringLiteral("cpuopt_unsafe_ignore_standard_fpcr"),
-                       Settings::values.cpuopt_unsafe_ignore_standard_fpcr, true);
     WriteSettingGlobal(QStringLiteral("cpuopt_unsafe_inaccurate_nan"),
                        Settings::values.cpuopt_unsafe_inaccurate_nan, true);
     WriteSettingGlobal(QStringLiteral("cpuopt_unsafe_fastmem_check"),
@@ -1400,10 +1388,7 @@ void Config::SaveRendererValues() {
                        Settings::values.use_asynchronous_gpu_emulation, true);
     WriteSettingGlobal(QStringLiteral("use_nvdec_emulation"), Settings::values.use_nvdec_emulation,
                        true);
-    WriteSettingGlobal(QStringLiteral("accelerate_astc"), Settings::values.accelerate_astc, true);
     WriteSettingGlobal(QStringLiteral("use_vsync"), Settings::values.use_vsync, true);
-    WriteSettingGlobal(QStringLiteral("disable_fps_limit"), Settings::values.disable_fps_limit,
-                       false);
     WriteSettingGlobal(QStringLiteral("use_assembly_shaders"),
                        Settings::values.use_assembly_shaders, false);
     WriteSettingGlobal(QStringLiteral("use_asynchronous_shaders"),

src/yuzu/configuration/config.h

@@ -42,7 +42,7 @@ public:
         default_mouse_buttons;
     static const std::array<int, Settings::NativeKeyboard::NumKeyboardKeys> default_keyboard_keys;
     static const std::array<int, Settings::NativeKeyboard::NumKeyboardMods> default_keyboard_mods;
-    static const std::array<UISettings::Shortcut, 18> default_hotkeys;
+    static const std::array<UISettings::Shortcut, 17> default_hotkeys;
 
 private:
     void Initialize(const std::string& config_name);

src/yuzu/configuration/configure_cpu.cpp

@@ -34,15 +34,12 @@ void ConfigureCpu::SetConfiguration() {
     ui->accuracy->setEnabled(runtime_lock);
     ui->cpuopt_unsafe_unfuse_fma->setEnabled(runtime_lock);
     ui->cpuopt_unsafe_reduce_fp_error->setEnabled(runtime_lock);
-    ui->cpuopt_unsafe_ignore_standard_fpcr->setEnabled(runtime_lock);
     ui->cpuopt_unsafe_inaccurate_nan->setEnabled(runtime_lock);
     ui->cpuopt_unsafe_fastmem_check->setEnabled(runtime_lock);
 
     ui->cpuopt_unsafe_unfuse_fma->setChecked(Settings::values.cpuopt_unsafe_unfuse_fma.GetValue());
     ui->cpuopt_unsafe_reduce_fp_error->setChecked(
         Settings::values.cpuopt_unsafe_reduce_fp_error.GetValue());
-    ui->cpuopt_unsafe_ignore_standard_fpcr->setChecked(
-        Settings::values.cpuopt_unsafe_ignore_standard_fpcr.GetValue());
     ui->cpuopt_unsafe_inaccurate_nan->setChecked(
         Settings::values.cpuopt_unsafe_inaccurate_nan.GetValue());
     ui->cpuopt_unsafe_fastmem_check->setChecked(
@@ -87,9 +84,6 @@ void ConfigureCpu::ApplyConfiguration() {
     ConfigurationShared::ApplyPerGameSetting(&Settings::values.cpuopt_unsafe_reduce_fp_error,
                                              ui->cpuopt_unsafe_reduce_fp_error,
                                              cpuopt_unsafe_reduce_fp_error);
-    ConfigurationShared::ApplyPerGameSetting(&Settings::values.cpuopt_unsafe_ignore_standard_fpcr,
-                                             ui->cpuopt_unsafe_ignore_standard_fpcr,
-                                             cpuopt_unsafe_ignore_standard_fpcr);
     ConfigurationShared::ApplyPerGameSetting(&Settings::values.cpuopt_unsafe_inaccurate_nan,
                                              ui->cpuopt_unsafe_inaccurate_nan,
                                              cpuopt_unsafe_inaccurate_nan);
@@ -143,9 +137,6 @@ void ConfigureCpu::SetupPerGameUI() {
     ConfigurationShared::SetColoredTristate(ui->cpuopt_unsafe_reduce_fp_error,
                                             Settings::values.cpuopt_unsafe_reduce_fp_error,
                                             cpuopt_unsafe_reduce_fp_error);
-    ConfigurationShared::SetColoredTristate(ui->cpuopt_unsafe_ignore_standard_fpcr,
-                                            Settings::values.cpuopt_unsafe_ignore_standard_fpcr,
-                                            cpuopt_unsafe_ignore_standard_fpcr);
     ConfigurationShared::SetColoredTristate(ui->cpuopt_unsafe_inaccurate_nan,
                                             Settings::values.cpuopt_unsafe_inaccurate_nan,
                                             cpuopt_unsafe_inaccurate_nan);

src/yuzu/configuration/configure_cpu.h

@@ -40,7 +40,6 @@ private:
 
     ConfigurationShared::CheckState cpuopt_unsafe_unfuse_fma;
     ConfigurationShared::CheckState cpuopt_unsafe_reduce_fp_error;
-    ConfigurationShared::CheckState cpuopt_unsafe_ignore_standard_fpcr;
     ConfigurationShared::CheckState cpuopt_unsafe_inaccurate_nan;
     ConfigurationShared::CheckState cpuopt_unsafe_fastmem_check;
 };

src/yuzu/configuration/configure_cpu.ui

@@ -111,18 +111,6 @@
           </property>
          </widget>
         </item>
-        <item>
-         <widget class="QCheckBox" name="cpuopt_unsafe_ignore_standard_fpcr">
-          <property name="toolTip">
-           <string>
-            &lt;div&gt;This option improves the speed of 32 bits ASIMD floating-point functions by running with incorrect rounding modes.&lt;/div&gt;
-           </string>
-          </property>
-          <property name="text">
-           <string>Faster ASIMD instructions (32 bits only)</string>
-          </property>
-         </widget>
-        </item>
         <item>
          <widget class="QCheckBox" name="cpuopt_unsafe_inaccurate_nan">
           <property name="toolTip">

src/yuzu/configuration/configure_debug.cpp

@@ -28,21 +28,17 @@ ConfigureDebug::ConfigureDebug(QWidget* parent) : QWidget(parent), ui(new Ui::Co
 ConfigureDebug::~ConfigureDebug() = default;
 
 void ConfigureDebug::SetConfiguration() {
-    const bool runtime_lock = !Core::System::GetInstance().IsPoweredOn();
-
-    ui->toggle_console->setEnabled(runtime_lock);
+    ui->toggle_console->setEnabled(!Core::System::GetInstance().IsPoweredOn());
     ui->toggle_console->setChecked(UISettings::values.show_console);
     ui->log_filter_edit->setText(QString::fromStdString(Settings::values.log_filter));
     ui->homebrew_args_edit->setText(QString::fromStdString(Settings::values.program_args));
-    ui->fs_access_log->setEnabled(runtime_lock);
-    ui->fs_access_log->setChecked(Settings::values.enable_fs_access_log);
     ui->reporting_services->setChecked(Settings::values.reporting_services);
     ui->quest_flag->setChecked(Settings::values.quest_flag);
     ui->use_debug_asserts->setChecked(Settings::values.use_debug_asserts);
     ui->use_auto_stub->setChecked(Settings::values.use_auto_stub);
-    ui->enable_graphics_debugging->setEnabled(runtime_lock);
+    ui->enable_graphics_debugging->setEnabled(!Core::System::GetInstance().IsPoweredOn());
     ui->enable_graphics_debugging->setChecked(Settings::values.renderer_debug);
-    ui->disable_macro_jit->setEnabled(runtime_lock);
+    ui->disable_macro_jit->setEnabled(!Core::System::GetInstance().IsPoweredOn());
     ui->disable_macro_jit->setChecked(Settings::values.disable_macro_jit);
     ui->extended_logging->setChecked(Settings::values.extended_logging);
 }
@@ -51,7 +47,6 @@ void ConfigureDebug::ApplyConfiguration() {
     UISettings::values.show_console = ui->toggle_console->isChecked();
     Settings::values.log_filter = ui->log_filter_edit->text().toStdString();
     Settings::values.program_args = ui->homebrew_args_edit->text().toStdString();
-    Settings::values.enable_fs_access_log = ui->fs_access_log->isChecked();
     Settings::values.reporting_services = ui->reporting_services->isChecked();
     Settings::values.quest_flag = ui->quest_flag->isChecked();
     Settings::values.use_debug_asserts = ui->use_debug_asserts->isChecked();

src/yuzu/configuration/configure_debug.ui

@@ -144,16 +144,9 @@
    <item>
     <widget class="QGroupBox" name="groupBox_5">
      <property name="title">
-      <string>Debugging</string>
+      <string>Dump</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_7">
-      <item>
-       <widget class="QCheckBox" name="fs_access_log">
-        <property name="text">
-         <string>Enable FS Access Log</string>
-        </property>
-       </widget>
-      </item>
       <item>
        <widget class="QCheckBox" name="reporting_services">
         <property name="text">

src/yuzu/configuration/configure_graphics.cpp

@@ -70,12 +70,10 @@ void ConfigureGraphics::SetConfiguration() {
     ui->use_asynchronous_gpu_emulation->setEnabled(runtime_lock);
     ui->use_disk_shader_cache->setEnabled(runtime_lock);
     ui->use_nvdec_emulation->setEnabled(runtime_lock);
-    ui->accelerate_astc->setEnabled(runtime_lock);
     ui->use_disk_shader_cache->setChecked(Settings::values.use_disk_shader_cache.GetValue());
     ui->use_asynchronous_gpu_emulation->setChecked(
         Settings::values.use_asynchronous_gpu_emulation.GetValue());
     ui->use_nvdec_emulation->setChecked(Settings::values.use_nvdec_emulation.GetValue());
-    ui->accelerate_astc->setChecked(Settings::values.accelerate_astc.GetValue());
 
     if (Settings::IsConfiguringGlobal()) {
         ui->api->setCurrentIndex(static_cast<int>(Settings::values.renderer_backend.GetValue()));
@@ -120,8 +118,6 @@ void ConfigureGraphics::ApplyConfiguration() {
                                              use_asynchronous_gpu_emulation);
     ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_nvdec_emulation,
                                              ui->use_nvdec_emulation, use_nvdec_emulation);
-    ConfigurationShared::ApplyPerGameSetting(&Settings::values.accelerate_astc, ui->accelerate_astc,
-                                             accelerate_astc);
 
     if (Settings::IsConfiguringGlobal()) {
         // Guard if during game and set to game-specific value
@@ -258,7 +254,6 @@ void ConfigureGraphics::SetupPerGameUI() {
         ui->use_asynchronous_gpu_emulation->setEnabled(
             Settings::values.use_asynchronous_gpu_emulation.UsingGlobal());
         ui->use_nvdec_emulation->setEnabled(Settings::values.use_nvdec_emulation.UsingGlobal());
-        ui->accelerate_astc->setEnabled(Settings::values.accelerate_astc.UsingGlobal());
         ui->use_disk_shader_cache->setEnabled(Settings::values.use_disk_shader_cache.UsingGlobal());
         ui->bg_button->setEnabled(Settings::values.bg_red.UsingGlobal());
 
@@ -274,8 +269,6 @@ void ConfigureGraphics::SetupPerGameUI() {
         ui->use_disk_shader_cache, Settings::values.use_disk_shader_cache, use_disk_shader_cache);
     ConfigurationShared::SetColoredTristate(
         ui->use_nvdec_emulation, Settings::values.use_nvdec_emulation, use_nvdec_emulation);
-    ConfigurationShared::SetColoredTristate(ui->accelerate_astc, Settings::values.accelerate_astc,
-                                            accelerate_astc);
     ConfigurationShared::SetColoredTristate(ui->use_asynchronous_gpu_emulation,
                                             Settings::values.use_asynchronous_gpu_emulation,
                                             use_asynchronous_gpu_emulation);

src/yuzu/configuration/configure_graphics.h

@@ -47,7 +47,6 @@ private:
     QColor bg_color;
 
     ConfigurationShared::CheckState use_nvdec_emulation;
-    ConfigurationShared::CheckState accelerate_astc;
     ConfigurationShared::CheckState use_disk_shader_cache;
     ConfigurationShared::CheckState use_asynchronous_gpu_emulation;
 

src/yuzu/configuration/configure_graphics.ui

@@ -104,13 +104,6 @@
           </property>
          </widget>
         </item>
-        <item>
-          <widget class="QCheckBox" name="accelerate_astc">
-            <property name="text">
-              <string>Accelerate ASTC texture decoding</string>
-            </property>
-          </widget>
-        </item>
         <item>
          <widget class="QWidget" name="fullscreen_mode_layout" native="true">
           <layout class="QHBoxLayout" name="horizontalLayout_1">

src/yuzu/configuration/configure_graphics_advanced.cpp

@@ -28,7 +28,6 @@ void ConfigureGraphicsAdvanced::SetConfiguration() {
     ui->anisotropic_filtering_combobox->setEnabled(runtime_lock);
 
     ui->use_vsync->setChecked(Settings::values.use_vsync.GetValue());
-    ui->disable_fps_limit->setChecked(Settings::values.disable_fps_limit.GetValue());
     ui->use_assembly_shaders->setChecked(Settings::values.use_assembly_shaders.GetValue());
     ui->use_asynchronous_shaders->setChecked(Settings::values.use_asynchronous_shaders.GetValue());
     ui->use_fast_gpu_time->setChecked(Settings::values.use_fast_gpu_time.GetValue());
@@ -58,8 +57,6 @@ void ConfigureGraphicsAdvanced::ApplyConfiguration() {
     ConfigurationShared::ApplyPerGameSetting(&Settings::values.max_anisotropy,
                                              ui->anisotropic_filtering_combobox);
     ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_vsync, ui->use_vsync, use_vsync);
-    ConfigurationShared::ApplyPerGameSetting(&Settings::values.disable_fps_limit,
-                                             ui->disable_fps_limit, disable_fps_limit);
     ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_assembly_shaders,
                                              ui->use_assembly_shaders, use_assembly_shaders);
     ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_asynchronous_shaders,
@@ -100,7 +97,6 @@ void ConfigureGraphicsAdvanced::SetupPerGameUI() {
     if (Settings::IsConfiguringGlobal()) {
         ui->gpu_accuracy->setEnabled(Settings::values.gpu_accuracy.UsingGlobal());
         ui->use_vsync->setEnabled(Settings::values.use_vsync.UsingGlobal());
-        ui->disable_fps_limit->setEnabled(Settings::values.disable_fps_limit.UsingGlobal());
         ui->use_assembly_shaders->setEnabled(Settings::values.use_assembly_shaders.UsingGlobal());
         ui->use_asynchronous_shaders->setEnabled(
             Settings::values.use_asynchronous_shaders.UsingGlobal());
@@ -112,8 +108,6 @@ void ConfigureGraphicsAdvanced::SetupPerGameUI() {
     }
 
     ConfigurationShared::SetColoredTristate(ui->use_vsync, Settings::values.use_vsync, use_vsync);
-    ConfigurationShared::SetColoredTristate(ui->disable_fps_limit,
-                                            Settings::values.disable_fps_limit, disable_fps_limit);
     ConfigurationShared::SetColoredTristate(
         ui->use_assembly_shaders, Settings::values.use_assembly_shaders, use_assembly_shaders);
     ConfigurationShared::SetColoredTristate(ui->use_asynchronous_shaders,

src/yuzu/configuration/configure_graphics_advanced.h

@@ -35,7 +35,6 @@ private:
     std::unique_ptr<Ui::ConfigureGraphicsAdvanced> ui;
 
     ConfigurationShared::CheckState use_vsync;
-    ConfigurationShared::CheckState disable_fps_limit;
     ConfigurationShared::CheckState use_assembly_shaders;
     ConfigurationShared::CheckState use_asynchronous_shaders;
     ConfigurationShared::CheckState use_fast_gpu_time;

src/yuzu/configuration/configure_graphics_advanced.ui

@@ -76,24 +76,6 @@
           </property>
          </widget>
         </item>
-        <item>
-         <widget class="QCheckBox" name="disable_fps_limit">
-          <property name="enabled">
-           <bool>true</bool>
-          </property>
-          <property name="toolTip">
-           <string>
-            &lt;html&gt;&lt;head/&gt;&lt;body&gt;
-            &lt;p&gt;Presents guest frames as they become available, disabling the FPS limit in most titles.&lt;/p&gt;
-            &lt;p&gt;NOTE: Will cause instabilities.&lt;/p&gt;
-            &lt;/body&gt;&lt;/html&gt;
-           </string>
-          </property>
-          <property name="text">
-           <string>Disable framerate limit (experimental)</string>
-          </property>
-         </widget>
-        </item>
         <item>
          <widget class="QCheckBox" name="use_assembly_shaders">
           <property name="toolTip">

src/yuzu/main.cpp

@@ -1025,11 +1025,7 @@ void GMainWindow::InitializeHotkeys() {
     connect(hotkey_registry.GetHotkey(main_window, QStringLiteral("Mute Audio"), this),
             &QShortcut::activated, this,
             [] { Settings::values.audio_muted = !Settings::values.audio_muted; });
-    connect(hotkey_registry.GetHotkey(main_window, QStringLiteral("Toggle Framerate Limit"), this),
-            &QShortcut::activated, this, [] {
-                Settings::values.disable_fps_limit.SetValue(
-                    !Settings::values.disable_fps_limit.GetValue());
-            });
+
     connect(hotkey_registry.GetHotkey(main_window, QStringLiteral("Toggle Mouse Panning"), this),
             &QShortcut::activated, this, [&] {
                 Settings::values.mouse_panning = !Settings::values.mouse_panning;

src/yuzu_cmd/config.cpp

@@ -443,16 +443,12 @@ void Config::ReadValues() {
         sdl2_config->GetBoolean("Renderer", "use_asynchronous_gpu_emulation", true));
     Settings::values.use_vsync.SetValue(
         static_cast<u16>(sdl2_config->GetInteger("Renderer", "use_vsync", 1)));
-    Settings::values.disable_fps_limit.SetValue(
-        sdl2_config->GetBoolean("Renderer", "disable_fps_limit", false));
     Settings::values.use_assembly_shaders.SetValue(
         sdl2_config->GetBoolean("Renderer", "use_assembly_shaders", true));
     Settings::values.use_asynchronous_shaders.SetValue(
         sdl2_config->GetBoolean("Renderer", "use_asynchronous_shaders", false));
-    Settings::values.use_nvdec_emulation.SetValue(
-        sdl2_config->GetBoolean("Renderer", "use_nvdec_emulation", true));
-    Settings::values.accelerate_astc.SetValue(
-        sdl2_config->GetBoolean("Renderer", "accelerate_astc", true));
+    Settings::values.use_asynchronous_shaders.SetValue(
+        sdl2_config->GetBoolean("Renderer", "use_asynchronous_shaders", false));
     Settings::values.use_fast_gpu_time.SetValue(
         sdl2_config->GetBoolean("Renderer", "use_fast_gpu_time", true));
 
@@ -481,8 +477,6 @@ void Config::ReadValues() {
     Settings::values.program_args = sdl2_config->Get("Debugging", "program_args", "");
     Settings::values.dump_exefs = sdl2_config->GetBoolean("Debugging", "dump_exefs", false);
     Settings::values.dump_nso = sdl2_config->GetBoolean("Debugging", "dump_nso", false);
-    Settings::values.enable_fs_access_log =
-        sdl2_config->GetBoolean("Debugging", "enable_fs_access_log", false);
     Settings::values.reporting_services =
         sdl2_config->GetBoolean("Debugging", "reporting_services", false);
     Settings::values.quest_flag = sdl2_config->GetBoolean("Debugging", "quest_flag", false);

src/yuzu_cmd/default_ini.h

@@ -194,14 +194,6 @@ use_assembly_shaders =
 # 0 (default): Off, 1: On
 use_asynchronous_shaders =
 
-# Enable NVDEC emulation.
-# 0: Off, 1 (default): On
-use_nvdec_emulation =
-
-# Accelerate ASTC texture decoding.
-# 0: Off, 1 (default): On
-accelerate_astc =
-
 # Turns on the frame limiter, which will limit frames output to the target game speed
 # 0: Off, 1: On (default)
 use_frame_limit =
@@ -260,10 +252,7 @@ swap_screen =
 
 [Audio]
 # Which audio output engine to use.
-# auto (default): Auto-select
-# cubeb: Cubeb audio engine (if available)
-# sdl2: SDL2 audio engine (if available)
-# null: No audio output
+# auto (default): Auto-select, null: No audio output, cubeb: Cubeb audio engine (if available)
 output_engine =
 
 # Whether or not to enable the audio-stretching post-processing effect.
@@ -349,8 +338,6 @@ record_frame_times =
 dump_exefs=false
 # Determines whether or not yuzu will dump all NSOs it attempts to load while loading them
 dump_nso=false
-# Determines whether or not yuzu will save the filesystem access log.
-enable_fs_access_log=false
 # Determines whether or not yuzu will report to the game that the emulated console is in Kiosk Mode
 # false: Retail/Normal Mode (default), true: Kiosk Mode
 quest_flag =
@@ -362,9 +349,6 @@ use_debug_asserts =
 use_auto_stub =
 # Enables/Disables the macro JIT compiler
 disable_macro_jit=false
-# Presents guest frames as they become available. Experimental.
-# false: Disabled (default), true: Enabled
-disable_fps_limit=false
 
 [WebService]
 # Whether or not to enable telemetry