"Merge Tagged PR 1340"

.ci/yuzu-patreon-step2.yml

@@ -9,7 +9,6 @@ stages:
   displayName: 'build'
   jobs:
   - job: build
-    timeoutInMinutes: 120
     displayName: 'windows-msvc'
     pool:
       vmImage: windows-2019

src/audio_core/CMakeLists.txt

@@ -44,16 +44,6 @@ add_library(audio_core STATIC
 
 create_target_directory_groups(audio_core)
 
-if (NOT MSVC)
-    target_compile_options(audio_core PRIVATE
-        -Werror=ignored-qualifiers
-        -Werror=implicit-fallthrough
-        -Werror=reorder
-        -Werror=sign-compare
-        -Werror=unused-variable
-    )
-endif()
-
 target_link_libraries(audio_core PUBLIC common core)
 target_link_libraries(audio_core PRIVATE SoundTouch)
 

src/audio_core/audio_renderer.cpp

@@ -3,13 +3,16 @@
 // Refer to the license.txt file included.
 
 #include <vector>
-
+#include "audio_core/algorithm/interpolate.h"
 #include "audio_core/audio_out.h"
 #include "audio_core/audio_renderer.h"
+#include "audio_core/codec.h"
 #include "audio_core/common.h"
 #include "audio_core/info_updater.h"
 #include "audio_core/voice_context.h"
+#include "common/assert.h"
 #include "common/logging/log.h"
+#include "core/core.h"
 #include "core/hle/kernel/writable_event.h"
 #include "core/memory.h"
 #include "core/settings.h"

src/audio_core/audio_renderer.h

@@ -21,6 +21,7 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
+#include "core/hle/kernel/object.h"
 #include "core/hle/result.h"
 
 namespace Core::Timing {

src/audio_core/behavior_info.cpp

@@ -57,15 +57,15 @@ bool BehaviorInfo::IsLongSizePreDelaySupported() const {
     return AudioCommon::IsRevisionSupported(3, user_revision);
 }
 
-bool BehaviorInfo::IsAudioRendererProcessingTimeLimit80PercentSupported() const {
+bool BehaviorInfo::IsAudioRenererProcessingTimeLimit80PercentSupported() const {
     return AudioCommon::IsRevisionSupported(5, user_revision);
 }
 
-bool BehaviorInfo::IsAudioRendererProcessingTimeLimit75PercentSupported() const {
+bool BehaviorInfo::IsAudioRenererProcessingTimeLimit75PercentSupported() const {
     return AudioCommon::IsRevisionSupported(4, user_revision);
 }
 
-bool BehaviorInfo::IsAudioRendererProcessingTimeLimit70PercentSupported() const {
+bool BehaviorInfo::IsAudioRenererProcessingTimeLimit70PercentSupported() const {
     return AudioCommon::IsRevisionSupported(1, user_revision);
 }
 

src/audio_core/behavior_info.h

@@ -49,9 +49,9 @@ public:
     bool IsAdpcmLoopContextBugFixed() const;
     bool IsSplitterSupported() const;
     bool IsLongSizePreDelaySupported() const;
-    bool IsAudioRendererProcessingTimeLimit80PercentSupported() const;
-    bool IsAudioRendererProcessingTimeLimit75PercentSupported() const;
-    bool IsAudioRendererProcessingTimeLimit70PercentSupported() const;
+    bool IsAudioRenererProcessingTimeLimit80PercentSupported() const;
+    bool IsAudioRenererProcessingTimeLimit75PercentSupported() const;
+    bool IsAudioRenererProcessingTimeLimit70PercentSupported() const;
     bool IsElapsedFrameCountSupported() const;
     bool IsMemoryPoolForceMappingEnabled() const;
     bool IsFlushVoiceWaveBuffersSupported() const;

src/audio_core/codec.cpp

@@ -16,9 +16,8 @@ std::vector<s16> DecodeADPCM(const u8* const data, std::size_t size, const ADPCM
 
     constexpr std::size_t FRAME_LEN = 8;
     constexpr std::size_t SAMPLES_PER_FRAME = 14;
-    static constexpr std::array<int, 16> SIGNED_NIBBLES{
-        0, 1, 2, 3, 4, 5, 6, 7, -8, -7, -6, -5, -4, -3, -2, -1,
-    };
+    constexpr std::array<int, 16> SIGNED_NIBBLES = {
+        {0, 1, 2, 3, 4, 5, 6, 7, -8, -7, -6, -5, -4, -3, -2, -1}};
 
     const std::size_t sample_count = (size / FRAME_LEN) * SAMPLES_PER_FRAME;
     const std::size_t ret_size =

src/audio_core/codec.h

@@ -38,7 +38,7 @@ using ADPCM_Coeff = std::array<s16, 16>;
  * @param state ADPCM state, this is updated with new state
  * @return Decoded stereo signed PCM16 data, sample_count in length
  */
-std::vector<s16> DecodeADPCM(const u8* data, std::size_t size, const ADPCM_Coeff& coeff,
+std::vector<s16> DecodeADPCM(const u8* const data, std::size_t size, const ADPCM_Coeff& coeff,
                              ADPCMState& state);
 
 }; // namespace AudioCore::Codec

src/audio_core/command_generator.cpp

@@ -152,7 +152,7 @@ void CommandGenerator::GenerateVoiceCommand(ServerVoiceInfo& voice_info) {
                     if (!destination_data->IsConfigured()) {
                         continue;
                     }
-                    if (destination_data->GetMixId() >= static_cast<int>(mix_context.GetCount())) {
+                    if (destination_data->GetMixId() >= mix_context.GetCount()) {
                         continue;
                     }
 
@@ -196,7 +196,7 @@ void CommandGenerator::PreCommand() {
     for (std::size_t i = 0; i < splitter_context.GetInfoCount(); i++) {
         const auto& base = splitter_context.GetInfo(i);
         std::string graph = fmt::format("b[{}]", i);
-        const auto* head = base.GetHead();
+        auto* head = base.GetHead();
         while (head != nullptr) {
             graph += fmt::format("->{}", head->GetMixId());
             head = head->GetNextDestination();
@@ -214,7 +214,7 @@ void CommandGenerator::PostCommand() {
 
 void CommandGenerator::GenerateDataSourceCommand(ServerVoiceInfo& voice_info, VoiceState& dsp_state,
                                                  s32 channel) {
-    const auto& in_params = voice_info.GetInParams();
+    auto& in_params = voice_info.GetInParams();
     const auto depop = in_params.should_depop;
 
     if (depop) {
@@ -405,7 +405,7 @@ void CommandGenerator::GenerateBiquadFilterEffectCommand(s32 mix_buffer_offset,
 }
 
 void CommandGenerator::GenerateAuxCommand(s32 mix_buffer_offset, EffectBase* info, bool enabled) {
-    auto* aux = dynamic_cast<EffectAuxInfo*>(info);
+    auto aux = dynamic_cast<EffectAuxInfo*>(info);
     const auto& params = aux->GetParams();
     if (aux->GetSendBuffer() != 0 && aux->GetRecvBuffer() != 0) {
         const auto max_channels = params.count;
@@ -435,7 +435,7 @@ void CommandGenerator::GenerateAuxCommand(s32 mix_buffer_offset, EffectBase* inf
                     GetMixBuffer(output_index), worker_params.sample_count, offset, write_count);
                 memory.WriteBlock(aux->GetRecvInfo(), &recv_info, sizeof(AuxInfoDSP));
 
-                if (samples_read != static_cast<int>(worker_params.sample_count) &&
+                if (samples_read != worker_params.sample_count &&
                     samples_read <= params.sample_count) {
                     std::memset(GetMixBuffer(output_index), 0, params.sample_count - samples_read);
                 }
@@ -571,7 +571,7 @@ void CommandGenerator::GenerateSubMixCommand(ServerMixInfo& mix_info) {
     if (dumping_frame) {
         LOG_DEBUG(Audio, "(DSP_TRACE) GenerateSubMixCommand");
     }
-    const auto& in_params = mix_info.GetInParams();
+    auto& in_params = mix_info.GetInParams();
     GenerateDepopForMixBuffersCommand(in_params.buffer_count, in_params.buffer_offset,
                                       in_params.sample_rate);
 
@@ -611,8 +611,7 @@ void CommandGenerator::GenerateMixCommands(ServerMixInfo& mix_info) {
             const auto& dest_mix = mix_context.GetInfo(destination_data->GetMixId());
             const auto& dest_in_params = dest_mix.GetInParams();
             const auto mix_index = (base - 1) % in_params.buffer_count + in_params.buffer_offset;
-            for (std::size_t i = 0; i < static_cast<std::size_t>(dest_in_params.buffer_count);
-                 i++) {
+            for (std::size_t i = 0; i < dest_in_params.buffer_count; i++) {
                 const auto mixed_volume = in_params.volume * destination_data->GetMixVolume(i);
                 if (mixed_volume != 0.0f) {
                     GenerateMixCommand(dest_in_params.buffer_offset + i, mix_index, mixed_volume,
@@ -651,7 +650,7 @@ void CommandGenerator::GenerateFinalMixCommand() {
         LOG_DEBUG(Audio, "(DSP_TRACE) GenerateFinalMixCommand");
     }
     auto& mix_info = mix_context.GetFinalMixInfo();
-    const auto& in_params = mix_info.GetInParams();
+    const auto in_params = mix_info.GetInParams();
 
     GenerateDepopForMixBuffersCommand(in_params.buffer_count, in_params.buffer_offset,
                                       in_params.sample_rate);
@@ -675,7 +674,7 @@ void CommandGenerator::GenerateFinalMixCommand() {
 
 s32 CommandGenerator::DecodePcm16(ServerVoiceInfo& voice_info, VoiceState& dsp_state,
                                   s32 sample_count, s32 channel, std::size_t mix_offset) {
-    const auto& in_params = voice_info.GetInParams();
+    auto& in_params = voice_info.GetInParams();
     const auto& wave_buffer = in_params.wave_buffer[dsp_state.wave_buffer_index];
     if (wave_buffer.buffer_address == 0) {
         return 0;
@@ -705,7 +704,7 @@ s32 CommandGenerator::DecodePcm16(ServerVoiceInfo& voice_info, VoiceState& dsp_s
         std::vector<s16> buffer(samples_processed * channel_count);
         memory.ReadBlock(buffer_pos, buffer.data(), buffer.size() * sizeof(s16));
 
-        for (std::size_t i = 0; i < static_cast<std::size_t>(samples_processed); i++) {
+        for (std::size_t i = 0; i < samples_processed; i++) {
             sample_buffer[mix_offset + i] = buffer[i * channel_count + channel];
         }
     }
@@ -715,7 +714,7 @@ s32 CommandGenerator::DecodePcm16(ServerVoiceInfo& voice_info, VoiceState& dsp_s
 
 s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_state,
                                   s32 sample_count, s32 channel, std::size_t mix_offset) {
-    const auto& in_params = voice_info.GetInParams();
+    auto& in_params = voice_info.GetInParams();
     const auto& wave_buffer = in_params.wave_buffer[dsp_state.wave_buffer_index];
     if (wave_buffer.buffer_address == 0) {
         return 0;
@@ -727,9 +726,8 @@ s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_s
         return 0;
     }
 
-    static constexpr std::array<int, 16> SIGNED_NIBBLES{
-        0, 1, 2, 3, 4, 5, 6, 7, -8, -7, -6, -5, -4, -3, -2, -1,
-    };
+    constexpr std::array<int, 16> SIGNED_NIBBLES = {
+        {0, 1, 2, 3, 4, 5, 6, 7, -8, -7, -6, -5, -4, -3, -2, -1}};
 
     constexpr std::size_t FRAME_LEN = 8;
     constexpr std::size_t NIBBLES_PER_SAMPLE = 16;
@@ -768,8 +766,8 @@ s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_s
         val = std::clamp<s32>(val, -32768, 32767);
         // Advance output feedback.
         yn2 = yn1;
-        yn1 = static_cast<s16>(val);
-        return yn1;
+        yn1 = val;
+        return static_cast<s16>(val);
     };
 
     std::size_t buffer_offset{};
@@ -791,7 +789,7 @@ s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_s
             position_in_frame += 2;
 
             // Decode entire frame
-            if (remaining_samples >= static_cast<int>(SAMPLES_PER_FRAME)) {
+            if (remaining_samples >= SAMPLES_PER_FRAME) {
                 for (std::size_t i = 0; i < SAMPLES_PER_FRAME / 2; i++) {
 
                     // Sample 1
@@ -855,7 +853,7 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, s32* o
                                              VoiceState& dsp_state, s32 channel,
                                              s32 target_sample_rate, s32 sample_count,
                                              s32 node_id) {
-    const auto& in_params = voice_info.GetInParams();
+    auto& in_params = voice_info.GetInParams();
     if (dumping_frame) {
         LOG_DEBUG(Audio,
                   "(DSP_TRACE) DecodeFromWaveBuffers, node_id={}, channel={}, "
@@ -868,8 +866,8 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, s32* o
     const auto resample_rate = static_cast<s32>(
         static_cast<float>(in_params.sample_rate) / static_cast<float>(target_sample_rate) *
         static_cast<float>(static_cast<s32>(in_params.pitch * 32768.0f)));
-    if (dsp_state.fraction + sample_count * resample_rate >
-        static_cast<s32>(SCALED_MIX_BUFFER_SIZE - 4ULL)) {
+    auto* output_base = output;
+    if ((dsp_state.fraction + sample_count * resample_rate) > (SCALED_MIX_BUFFER_SIZE - 4ULL)) {
         return;
     }
 

src/audio_core/command_generator.h

@@ -7,6 +7,7 @@
 #include <array>
 #include "audio_core/common.h"
 #include "audio_core/voice_context.h"
+#include "common/common_funcs.h"
 #include "common/common_types.h"
 
 namespace Core::Memory {

src/audio_core/common.h

@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #pragma once
-
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"

src/audio_core/cubeb_sink.cpp

@@ -192,8 +192,8 @@ SinkStream& CubebSink::AcquireSinkStream(u32 sample_rate, u32 num_channels,
 
 long CubebSinkStream::DataCallback(cubeb_stream* stream, void* user_data, const void* input_buffer,
                                    void* output_buffer, long num_frames) {
-    auto* impl = static_cast<CubebSinkStream*>(user_data);
-    auto* buffer = static_cast<u8*>(output_buffer);
+    CubebSinkStream* impl = static_cast<CubebSinkStream*>(user_data);
+    u8* buffer = reinterpret_cast<u8*>(output_buffer);
 
     if (!impl) {
         return {};

src/audio_core/effect_context.cpp

@@ -184,19 +184,19 @@ void EffectAuxInfo::UpdateForCommandGeneration() {
     }
 }
 
-VAddr EffectAuxInfo::GetSendInfo() const {
+const VAddr EffectAuxInfo::GetSendInfo() const {
     return send_info;
 }
 
-VAddr EffectAuxInfo::GetSendBuffer() const {
+const VAddr EffectAuxInfo::GetSendBuffer() const {
     return send_buffer;
 }
 
-VAddr EffectAuxInfo::GetRecvInfo() const {
+const VAddr EffectAuxInfo::GetRecvInfo() const {
     return recv_info;
 }
 
-VAddr EffectAuxInfo::GetRecvBuffer() const {
+const VAddr EffectAuxInfo::GetRecvBuffer() const {
     return recv_buffer;
 }
 

src/audio_core/effect_context.h

@@ -166,13 +166,13 @@ public:
             std::array<u8, 0xa0> raw;
         };
     };
-    static_assert(sizeof(InParams) == 0xc0, "InParams is an invalid size");
+    static_assert(sizeof(EffectInfo::InParams) == 0xc0, "InParams is an invalid size");
 
     struct OutParams {
         UsageStatus status{};
         INSERT_PADDING_BYTES(15);
     };
-    static_assert(sizeof(OutParams) == 0x10, "OutParams is an invalid size");
+    static_assert(sizeof(EffectInfo::OutParams) == 0x10, "OutParams is an invalid size");
 };
 
 struct AuxAddress {
@@ -184,8 +184,8 @@ struct AuxAddress {
 
 class EffectBase {
 public:
-    explicit EffectBase(EffectType effect_type);
-    virtual ~EffectBase();
+    EffectBase(EffectType effect_type);
+    ~EffectBase();
 
     virtual void Update(EffectInfo::InParams& in_params) = 0;
     virtual void UpdateForCommandGeneration() = 0;
@@ -206,7 +206,8 @@ protected:
 template <typename T>
 class EffectGeneric : public EffectBase {
 public:
-    explicit EffectGeneric(EffectType effect_type) : EffectBase(effect_type) {}
+    EffectGeneric(EffectType effect_type) : EffectBase::EffectBase(effect_type) {}
+    ~EffectGeneric() = default;
 
     T& GetParams() {
         return internal_params;
@@ -223,7 +224,7 @@ private:
 class EffectStubbed : public EffectBase {
 public:
     explicit EffectStubbed();
-    ~EffectStubbed() override;
+    ~EffectStubbed();
 
     void Update(EffectInfo::InParams& in_params) override;
     void UpdateForCommandGeneration() override;
@@ -232,7 +233,7 @@ public:
 class EffectI3dl2Reverb : public EffectGeneric<I3dl2ReverbParams> {
 public:
     explicit EffectI3dl2Reverb();
-    ~EffectI3dl2Reverb() override;
+    ~EffectI3dl2Reverb();
 
     void Update(EffectInfo::InParams& in_params) override;
     void UpdateForCommandGeneration() override;
@@ -244,7 +245,7 @@ private:
 class EffectBiquadFilter : public EffectGeneric<BiquadFilterParams> {
 public:
     explicit EffectBiquadFilter();
-    ~EffectBiquadFilter() override;
+    ~EffectBiquadFilter();
 
     void Update(EffectInfo::InParams& in_params) override;
     void UpdateForCommandGeneration() override;
@@ -253,14 +254,14 @@ public:
 class EffectAuxInfo : public EffectGeneric<AuxInfo> {
 public:
     explicit EffectAuxInfo();
-    ~EffectAuxInfo() override;
+    ~EffectAuxInfo();
 
     void Update(EffectInfo::InParams& in_params) override;
     void UpdateForCommandGeneration() override;
-    VAddr GetSendInfo() const;
-    VAddr GetSendBuffer() const;
-    VAddr GetRecvInfo() const;
-    VAddr GetRecvBuffer() const;
+    const VAddr GetSendInfo() const;
+    const VAddr GetSendBuffer() const;
+    const VAddr GetRecvInfo() const;
+    const VAddr GetRecvBuffer() const;
 
 private:
     VAddr send_info{};
@@ -274,7 +275,7 @@ private:
 class EffectDelay : public EffectGeneric<DelayParams> {
 public:
     explicit EffectDelay();
-    ~EffectDelay() override;
+    ~EffectDelay();
 
     void Update(EffectInfo::InParams& in_params) override;
     void UpdateForCommandGeneration() override;
@@ -286,7 +287,7 @@ private:
 class EffectBufferMixer : public EffectGeneric<BufferMixerParams> {
 public:
     explicit EffectBufferMixer();
-    ~EffectBufferMixer() override;
+    ~EffectBufferMixer();
 
     void Update(EffectInfo::InParams& in_params) override;
     void UpdateForCommandGeneration() override;
@@ -295,7 +296,7 @@ public:
 class EffectReverb : public EffectGeneric<ReverbParams> {
 public:
     explicit EffectReverb();
-    ~EffectReverb() override;
+    ~EffectReverb();
 
     void Update(EffectInfo::InParams& in_params) override;
     void UpdateForCommandGeneration() override;

src/audio_core/info_updater.cpp

@@ -64,6 +64,7 @@ bool InfoUpdater::UpdateBehaviorInfo(BehaviorInfo& in_behavior_info) {
 }
 
 bool InfoUpdater::UpdateMemoryPools(std::vector<ServerMemoryPoolInfo>& memory_pool_info) {
+    const auto force_mapping = behavior_info.IsMemoryPoolForceMappingEnabled();
     const auto memory_pool_count = memory_pool_info.size();
     const auto total_memory_pool_in = sizeof(ServerMemoryPoolInfo::InParams) * memory_pool_count;
     const auto total_memory_pool_out = sizeof(ServerMemoryPoolInfo::OutParams) * memory_pool_count;
@@ -173,7 +174,7 @@ bool InfoUpdater::UpdateVoices(VoiceContext& voice_context,
         }
         // Voice states for each channel
         std::array<VoiceState*, AudioCommon::MAX_CHANNEL_COUNT> voice_states{};
-        ASSERT(static_cast<std::size_t>(in_params.id) < voice_count);
+        ASSERT(in_params.id < voice_count);
 
         // Grab our current voice info
         auto& voice_info = voice_context.GetInfo(static_cast<std::size_t>(in_params.id));
@@ -351,8 +352,8 @@ ResultCode InfoUpdater::UpdateMixes(MixContext& mix_context, std::size_t mix_buf
         for (std::size_t i = 0; i < mix_count; i++) {
             const auto& in = mix_in_params[i];
             total_buffer_count += in.buffer_count;
-            if (static_cast<std::size_t>(in.dest_mix_id) > mix_count &&
-                in.dest_mix_id != AudioCommon::NO_MIX && in.mix_id != AudioCommon::FINAL_MIX) {
+            if (in.dest_mix_id > mix_count && in.dest_mix_id != AudioCommon::NO_MIX &&
+                in.mix_id != AudioCommon::FINAL_MIX) {
                 LOG_ERROR(
                     Audio,
                     "Invalid mix destination, mix_id={:X}, dest_mix_id={:X}, mix_buffer_count={:X}",

src/audio_core/mix_context.cpp

@@ -53,7 +53,7 @@ void MixContext::UpdateDistancesFromFinalMix() {
         auto mix_id = in_params.mix_id;
         // Needs to be referenced out of scope
         s32 distance_to_final_mix{AudioCommon::FINAL_MIX};
-        for (; distance_to_final_mix < static_cast<s32>(info_count); distance_to_final_mix++) {
+        for (; distance_to_final_mix < info_count; distance_to_final_mix++) {
             if (mix_id == AudioCommon::FINAL_MIX) {
                 // If we're at the final mix, we're done
                 break;
@@ -77,7 +77,7 @@ void MixContext::UpdateDistancesFromFinalMix() {
         }
 
         // If we're out of range for our distance, mark it as no final mix
-        if (distance_to_final_mix >= static_cast<s32>(info_count)) {
+        if (distance_to_final_mix >= info_count) {
             distance_to_final_mix = AudioCommon::NO_FINAL_MIX;
         }
 

src/audio_core/splitter_context.cpp

@@ -306,7 +306,7 @@ bool SplitterContext::UpdateInfo(const std::vector<u8>& input, std::size_t& inpu
             break;
         }
 
-        if (header.send_id < 0 || static_cast<std::size_t>(header.send_id) > info_count) {
+        if (header.send_id < 0 || header.send_id > info_count) {
             LOG_ERROR(Audio, "Bad splitter data id");
             break;
         }
@@ -348,7 +348,7 @@ bool SplitterContext::UpdateData(const std::vector<u8>& input, std::size_t& inpu
             break;
         }
 
-        if (header.splitter_id < 0 || static_cast<std::size_t>(header.splitter_id) > data_count) {
+        if (header.splitter_id < 0 || header.splitter_id > data_count) {
             LOG_ERROR(Audio, "Bad splitter data id");
             break;
         }
@@ -434,7 +434,7 @@ const std::vector<s32>& NodeStates::GetIndexList() const {
 }
 
 void NodeStates::PushTsortResult(s32 index) {
-    ASSERT(index < static_cast<s32>(node_count));
+    ASSERT(index < node_count);
     index_list[index_pos++] = index;
 }
 

src/audio_core/stream.cpp

@@ -12,6 +12,7 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/core_timing.h"
+#include "core/core_timing_util.h"
 #include "core/settings.h"
 
 namespace AudioCore {

src/audio_core/voice_context.cpp

@@ -488,11 +488,11 @@ s32 VoiceContext::DecodePcm16(s32* output_buffer, ServerWaveBuffer* wave_buffer,
 
     // Fast path
     if (channel_count == 1) {
-        for (std::ptrdiff_t i = 0; i < samples_processed; i++) {
+        for (std::size_t i = 0; i < samples_processed; i++) {
             output_buffer[i] = buffer_data[i];
         }
     } else {
-        for (std::ptrdiff_t i = 0; i < samples_processed; i++) {
+        for (std::size_t i = 0; i < samples_processed; i++) {
             output_buffer[i] = buffer_data[i * channel_count + channel];
         }
     }

src/common/CMakeLists.txt

@@ -192,9 +192,4 @@ create_target_directory_groups(common)
 find_package(Boost 1.71 COMPONENTS context headers REQUIRED)
 
 target_link_libraries(common PUBLIC ${Boost_LIBRARIES} fmt::fmt microprofile)
-target_link_libraries(common PRIVATE lz4::lz4 xbyak)
-if (MSVC)
-  target_link_libraries(common PRIVATE zstd::zstd)
-else()
-  target_link_libraries(common PRIVATE zstd)
-endif()
+target_link_libraries(common PRIVATE lz4::lz4 zstd::zstd xbyak)

src/common/wall_clock.cpp

@@ -15,7 +15,7 @@ namespace Common {
 using base_timer = std::chrono::steady_clock;
 using base_time_point = std::chrono::time_point<base_timer>;
 
-class StandardWallClock final : public WallClock {
+class StandardWallClock : public WallClock {
 public:
     StandardWallClock(u64 emulated_cpu_frequency, u64 emulated_clock_frequency)
         : WallClock(emulated_cpu_frequency, emulated_clock_frequency, false) {

src/common/wall_clock.h

@@ -13,8 +13,6 @@ namespace Common {
 
 class WallClock {
 public:
-    virtual ~WallClock() = default;
-
     /// Returns current wall time in nanoseconds
     [[nodiscard]] virtual std::chrono::nanoseconds GetTimeNS() = 0;
 

src/common/x64/native_clock.h

@@ -12,7 +12,7 @@
 namespace Common {
 
 namespace X64 {
-class NativeClock final : public WallClock {
+class NativeClock : public WallClock {
 public:
     NativeClock(u64 emulated_cpu_frequency, u64 emulated_clock_frequency, u64 rtsc_frequency);
 

src/core/arm/dynarmic/arm_dynarmic_cp15.cpp

@@ -34,7 +34,7 @@ std::optional<Callback> DynarmicCP15::CompileInternalOperation(bool two, unsigne
                                                                CoprocReg CRm, unsigned opc2) {
     LOG_CRITICAL(Core_ARM, "CP15: cdp{} p15, {}, {}, {}, {}, {}", two ? "2" : "", opc1, CRd, CRn,
                  CRm, opc2);
-    return std::nullopt;
+    return {};
 }
 
 CallbackOrAccessOneWord DynarmicCP15::CompileSendOneWord(bool two, unsigned opc1, CoprocReg CRn,
@@ -115,7 +115,7 @@ std::optional<Callback> DynarmicCP15::CompileLoadWords(bool two, bool long_trans
         LOG_CRITICAL(Core_ARM, "CP15: mrrc{}{} p15, {}, [...]", two ? "2" : "",
                      long_transfer ? "l" : "", CRd);
     }
-    return std::nullopt;
+    return {};
 }
 
 std::optional<Callback> DynarmicCP15::CompileStoreWords(bool two, bool long_transfer, CoprocReg CRd,
@@ -127,7 +127,7 @@ std::optional<Callback> DynarmicCP15::CompileStoreWords(bool two, bool long_tran
         LOG_CRITICAL(Core_ARM, "CP15: mrrc{}{} p15, {}, [...]", two ? "2" : "",
                      long_transfer ? "l" : "", CRd);
     }
-    return std::nullopt;
+    return {};
 }
 
 } // namespace Core

src/core/arm/dynarmic/arm_dynarmic_cp15.h

@@ -35,8 +35,8 @@ public:
                                               std::optional<u8> option) override;
 
     ARM_Dynarmic_32& parent;
-    u32 uprw = 0;
-    u32 uro = 0;
+    u32 uprw;
+    u32 uro;
 };
 
 } // namespace Core

src/core/core.cpp

@@ -178,7 +178,7 @@ struct System::Impl {
         arp_manager.ResetAll();
 
         telemetry_session = std::make_unique<Core::TelemetrySession>();
-        service_manager = std::make_shared<Service::SM::ServiceManager>(kernel);
+        service_manager = std::make_shared<Service::SM::ServiceManager>();
 
         Service::Init(service_manager, system);
         GDBStub::DeferStart();
@@ -221,7 +221,7 @@ struct System::Impl {
         telemetry_session->AddInitialInfo(*app_loader);
         auto main_process =
             Kernel::Process::Create(system, "main", Kernel::Process::ProcessType::Userland);
-        const auto [load_result, load_parameters] = app_loader->Load(*main_process, system);
+        const auto [load_result, load_parameters] = app_loader->Load(*main_process);
         if (load_result != Loader::ResultStatus::Success) {
             LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", static_cast<int>(load_result));
             Shutdown();
@@ -629,11 +629,11 @@ Loader::AppLoader& System::GetAppLoader() const {
     return *impl->app_loader;
 }
 
-void System::SetFilesystem(FileSys::VirtualFilesystem vfs) {
+void System::SetFilesystem(std::shared_ptr<FileSys::VfsFilesystem> vfs) {
     impl->virtual_filesystem = std::move(vfs);
 }
 
-FileSys::VirtualFilesystem System::GetFilesystem() const {
+std::shared_ptr<FileSys::VfsFilesystem> System::GetFilesystem() const {
     return impl->virtual_filesystem;
 }
 

src/core/core.h

@@ -120,7 +120,7 @@ public:
      * Gets the instance of the System singleton class.
      * @returns Reference to the instance of the System singleton class.
      */
-    [[deprecated("Use of the global system instance is deprecated")]] static System& GetInstance() {
+    static System& GetInstance() {
         return s_instance;
     }
 
@@ -316,9 +316,9 @@ public:
     Service::SM::ServiceManager& ServiceManager();
     const Service::SM::ServiceManager& ServiceManager() const;
 
-    void SetFilesystem(FileSys::VirtualFilesystem vfs);
+    void SetFilesystem(std::shared_ptr<FileSys::VfsFilesystem> vfs);
 
-    FileSys::VirtualFilesystem GetFilesystem() const;
+    std::shared_ptr<FileSys::VfsFilesystem> GetFilesystem() const;
 
     void RegisterCheatList(const std::vector<Memory::CheatEntry>& list,
                            const std::array<u8, 0x20>& build_id, VAddr main_region_begin,

src/core/crypto/key_manager.cpp

@@ -23,6 +23,7 @@
 #include "common/hex_util.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
+#include "core/core.h"
 #include "core/crypto/aes_util.h"
 #include "core/crypto/key_manager.h"
 #include "core/crypto/partition_data_manager.h"
@@ -1021,10 +1022,10 @@ void KeyManager::DeriveBase() {
     }
 }
 
-void KeyManager::DeriveETicket(PartitionDataManager& data,
-                               const FileSys::ContentProvider& provider) {
+void KeyManager::DeriveETicket(PartitionDataManager& data) {
     // ETicket keys
-    const auto es = provider.GetEntry(0x0100000000000033, FileSys::ContentRecordType::Program);
+    const auto es = Core::System::GetInstance().GetContentProvider().GetEntry(
+        0x0100000000000033, FileSys::ContentRecordType::Program);
 
     if (es == nullptr) {
         return;

src/core/crypto/key_manager.h

@@ -20,10 +20,6 @@ namespace Common::FS {
 class IOFile;
 }
 
-namespace FileSys {
-class ContentProvider;
-}
-
 namespace Loader {
 enum class ResultStatus : u16;
 }
@@ -256,7 +252,7 @@ public:
 
     bool BaseDeriveNecessary() const;
     void DeriveBase();
-    void DeriveETicket(PartitionDataManager& data, const FileSys::ContentProvider& provider);
+    void DeriveETicket(PartitionDataManager& data);
     void PopulateTickets();
     void SynthesizeTickets();
 

src/core/file_sys/bis_factory.cpp

@@ -4,10 +4,10 @@
 
 #include <fmt/format.h>
 #include "common/file_util.h"
+#include "core/core.h"
 #include "core/file_sys/bis_factory.h"
 #include "core/file_sys/mode.h"
 #include "core/file_sys/registered_cache.h"
-#include "core/file_sys/vfs.h"
 
 namespace FileSys {
 
@@ -81,11 +81,11 @@ VirtualDir BISFactory::OpenPartition(BisPartitionId id) const {
     }
 }
 
-VirtualFile BISFactory::OpenPartitionStorage(BisPartitionId id,
-                                             VirtualFilesystem file_system) const {
+VirtualFile BISFactory::OpenPartitionStorage(BisPartitionId id) const {
     auto& keys = Core::Crypto::KeyManager::Instance();
-    Core::Crypto::PartitionDataManager pdm{file_system->OpenDirectory(
-        Common::FS::GetUserPath(Common::FS::UserPath::SysDataDir), Mode::Read)};
+    Core::Crypto::PartitionDataManager pdm{
+        Core::System::GetInstance().GetFilesystem()->OpenDirectory(
+            Common::FS::GetUserPath(Common::FS::UserPath::SysDataDir), Mode::Read)};
     keys.PopulateFromPartitionData(pdm);
 
     switch (id) {

src/core/file_sys/bis_factory.h

@@ -52,7 +52,7 @@ public:
     VirtualDir GetModificationDumpRoot(u64 title_id) const;
 
     VirtualDir OpenPartition(BisPartitionId id) const;
-    VirtualFile OpenPartitionStorage(BisPartitionId id, VirtualFilesystem file_system) const;
+    VirtualFile OpenPartitionStorage(BisPartitionId id) const;
 
     VirtualDir GetImageDirectory() const;
 

src/core/file_sys/content_archive.cpp

@@ -323,7 +323,7 @@ bool NCA::ReadRomFSSection(const NCASectionHeader& section, const NCASectionTabl
         subsection_buckets.back().entries.push_back({section.bktr.relocation.offset, {0}, ctr_low});
         subsection_buckets.back().entries.push_back({size, {0}, 0});
 
-        std::optional<Core::Crypto::Key128> key;
+        std::optional<Core::Crypto::Key128> key = {};
         if (encrypted) {
             if (has_rights_id) {
                 status = Loader::ResultStatus::Success;
@@ -442,18 +442,18 @@ std::optional<Core::Crypto::Key128> NCA::GetTitlekey() {
     memcpy(rights_id.data(), header.rights_id.data(), 16);
     if (rights_id == u128{}) {
         status = Loader::ResultStatus::ErrorInvalidRightsID;
-        return std::nullopt;
+        return {};
     }
 
     auto titlekey = keys.GetKey(Core::Crypto::S128KeyType::Titlekey, rights_id[1], rights_id[0]);
     if (titlekey == Core::Crypto::Key128{}) {
         status = Loader::ResultStatus::ErrorMissingTitlekey;
-        return std::nullopt;
+        return {};
     }
 
     if (!keys.HasKey(Core::Crypto::S128KeyType::Titlekek, master_key_id)) {
         status = Loader::ResultStatus::ErrorMissingTitlekek;
-        return std::nullopt;
+        return {};
     }
 
     Core::Crypto::AESCipher<Core::Crypto::Key128> cipher(
@@ -477,7 +477,7 @@ VirtualFile NCA::Decrypt(const NCASectionHeader& s_header, VirtualFile in, u64 s
     case NCASectionCryptoType::BKTR:
         LOG_TRACE(Crypto, "called with mode=CTR, starting_offset={:016X}", starting_offset);
         {
-            std::optional<Core::Crypto::Key128> key;
+            std::optional<Core::Crypto::Key128> key = {};
             if (has_rights_id) {
                 status = Loader::ResultStatus::Success;
                 key = GetTitlekey();

src/core/file_sys/control_metadata.h

@@ -83,7 +83,7 @@ enum class Language : u8 {
     Italian = 7,
     Dutch = 8,
     CanadianFrench = 9,
-    Portuguese = 10,
+    Portugese = 10,
     Russian = 11,
     Korean = 12,
     Taiwanese = 13,

src/core/file_sys/ips_layer.cpp

@@ -245,11 +245,9 @@ void IPSwitchCompiler::Parse() {
 
             // Read rest of patch
             while (true) {
-                if (i + 1 >= lines.size()) {
+                if (i + 1 >= lines.size())
                     break;
-                }
-
-                const auto& patch_line = lines[++i];
+                const auto patch_line = lines[++i];
 
                 // Start of new patch
                 if (StartsWith(patch_line, "@enabled") || StartsWith(patch_line, "@disabled")) {

src/core/file_sys/nca_patch.cpp

@@ -12,49 +12,6 @@
 #include "core/file_sys/nca_patch.h"
 
 namespace FileSys {
-namespace {
-template <bool Subsection, typename BlockType, typename BucketType>
-std::pair<std::size_t, std::size_t> SearchBucketEntry(u64 offset, const BlockType& block,
-                                                      const BucketType& buckets) {
-    if constexpr (Subsection) {
-        const auto& last_bucket = buckets[block.number_buckets - 1];
-        if (offset >= last_bucket.entries[last_bucket.number_entries].address_patch) {
-            return {block.number_buckets - 1, last_bucket.number_entries};
-        }
-    } else {
-        ASSERT_MSG(offset <= block.size, "Offset is out of bounds in BKTR relocation block.");
-    }
-
-    std::size_t bucket_id = std::count_if(
-        block.base_offsets.begin() + 1, block.base_offsets.begin() + block.number_buckets,
-        [&offset](u64 base_offset) { return base_offset <= offset; });
-
-    const auto& bucket = buckets[bucket_id];
-
-    if (bucket.number_entries == 1) {
-        return {bucket_id, 0};
-    }
-
-    std::size_t low = 0;
-    std::size_t mid = 0;
-    std::size_t high = bucket.number_entries - 1;
-    while (low <= high) {
-        mid = (low + high) / 2;
-        if (bucket.entries[mid].address_patch > offset) {
-            high = mid - 1;
-        } else {
-            if (mid == bucket.number_entries - 1 ||
-                bucket.entries[mid + 1].address_patch > offset) {
-                return {bucket_id, mid};
-            }
-
-            low = mid + 1;
-        }
-    }
-
-    UNREACHABLE_MSG("Offset could not be found in BKTR block.");
-}
-} // Anonymous namespace
 
 BKTR::BKTR(VirtualFile base_romfs_, VirtualFile bktr_romfs_, RelocationBlock relocation_,
            std::vector<RelocationBucket> relocation_buckets_, SubsectionBlock subsection_,
@@ -153,6 +110,46 @@ std::size_t BKTR::Read(u8* data, std::size_t length, std::size_t offset) const {
     return raw_read;
 }
 
+template <bool Subsection, typename BlockType, typename BucketType>
+std::pair<std::size_t, std::size_t> BKTR::SearchBucketEntry(u64 offset, BlockType block,
+                                                            BucketType buckets) const {
+    if constexpr (Subsection) {
+        const auto last_bucket = buckets[block.number_buckets - 1];
+        if (offset >= last_bucket.entries[last_bucket.number_entries].address_patch)
+            return {block.number_buckets - 1, last_bucket.number_entries};
+    } else {
+        ASSERT_MSG(offset <= block.size, "Offset is out of bounds in BKTR relocation block.");
+    }
+
+    std::size_t bucket_id = std::count_if(
+        block.base_offsets.begin() + 1, block.base_offsets.begin() + block.number_buckets,
+        [&offset](u64 base_offset) { return base_offset <= offset; });
+
+    const auto bucket = buckets[bucket_id];
+
+    if (bucket.number_entries == 1)
+        return {bucket_id, 0};
+
+    std::size_t low = 0;
+    std::size_t mid = 0;
+    std::size_t high = bucket.number_entries - 1;
+    while (low <= high) {
+        mid = (low + high) / 2;
+        if (bucket.entries[mid].address_patch > offset) {
+            high = mid - 1;
+        } else {
+            if (mid == bucket.number_entries - 1 ||
+                bucket.entries[mid + 1].address_patch > offset) {
+                return {bucket_id, mid};
+            }
+
+            low = mid + 1;
+        }
+    }
+
+    UNREACHABLE_MSG("Offset could not be found in BKTR block.");
+}
+
 RelocationEntry BKTR::GetRelocationEntry(u64 offset) const {
     const auto res = SearchBucketEntry<false>(offset, relocation, relocation_buckets);
     return relocation_buckets[res.first].entries[res.second];

src/core/file_sys/nca_patch.h

@@ -117,6 +117,10 @@ public:
     bool Rename(std::string_view name) override;
 
 private:
+    template <bool Subsection, typename BlockType, typename BucketType>
+    std::pair<std::size_t, std::size_t> SearchBucketEntry(u64 offset, BlockType block,
+                                                          BucketType buckets) const;
+
     RelocationEntry GetRelocationEntry(u64 offset) const;
     RelocationEntry GetNextRelocationEntry(u64 offset) const;
 

src/core/file_sys/patch_manager.cpp

@@ -27,7 +27,6 @@
 #include "core/settings.h"
 
 namespace FileSys {
-namespace {
 
 constexpr u64 SINGLE_BYTE_MODULUS = 0x100;
 constexpr u64 DLC_BASE_TITLE_ID_MASK = 0xFFFFFFFFFFFFE000;
@@ -37,28 +36,19 @@ constexpr std::array<const char*, 14> EXEFS_FILE_NAMES{
     "subsdk3", "subsdk4",   "subsdk5", "subsdk6", "subsdk7", "subsdk8", "subsdk9",
 };
 
-enum class TitleVersionFormat : u8 {
-    ThreeElements, ///< vX.Y.Z
-    FourElements,  ///< vX.Y.Z.W
-};
-
-std::string FormatTitleVersion(u32 version,
-                               TitleVersionFormat format = TitleVersionFormat::ThreeElements) {
+std::string FormatTitleVersion(u32 version, TitleVersionFormat format) {
     std::array<u8, sizeof(u32)> bytes{};
-    bytes[0] = static_cast<u8>(version % SINGLE_BYTE_MODULUS);
+    bytes[0] = version % SINGLE_BYTE_MODULUS;
     for (std::size_t i = 1; i < bytes.size(); ++i) {
         version /= SINGLE_BYTE_MODULUS;
-        bytes[i] = static_cast<u8>(version % SINGLE_BYTE_MODULUS);
+        bytes[i] = version % SINGLE_BYTE_MODULUS;
     }
 
-    if (format == TitleVersionFormat::FourElements) {
+    if (format == TitleVersionFormat::FourElements)
         return fmt::format("v{}.{}.{}.{}", bytes[3], bytes[2], bytes[1], bytes[0]);
-    }
     return fmt::format("v{}.{}.{}", bytes[3], bytes[2], bytes[1]);
 }
 
-// Returns a directory with name matching name case-insensitive. Returns nullptr if directory
-// doesn't have a directory with name.
 VirtualDir FindSubdirectoryCaseless(const VirtualDir dir, std::string_view name) {
 #ifdef _WIN32
     return dir->GetSubdirectory(name);
@@ -75,43 +65,6 @@ VirtualDir FindSubdirectoryCaseless(const VirtualDir dir, std::string_view name)
 #endif
 }
 
-std::optional<std::vector<Core::Memory::CheatEntry>> ReadCheatFileFromFolder(
-    u64 title_id, const PatchManager::BuildID& build_id_, const VirtualDir& base_path, bool upper) {
-    const auto build_id_raw = Common::HexToString(build_id_, upper);
-    const auto build_id = build_id_raw.substr(0, sizeof(u64) * 2);
-    const auto file = base_path->GetFile(fmt::format("{}.txt", build_id));
-
-    if (file == nullptr) {
-        LOG_INFO(Common_Filesystem, "No cheats file found for title_id={:016X}, build_id={}",
-                 title_id, build_id);
-        return std::nullopt;
-    }
-
-    std::vector<u8> data(file->GetSize());
-    if (file->Read(data.data(), data.size()) != data.size()) {
-        LOG_INFO(Common_Filesystem, "Failed to read cheats file for title_id={:016X}, build_id={}",
-                 title_id, build_id);
-        return std::nullopt;
-    }
-
-    const Core::Memory::TextCheatParser parser;
-    return parser.Parse(std::string_view(reinterpret_cast<const char*>(data.data()), data.size()));
-}
-
-void AppendCommaIfNotEmpty(std::string& to, std::string_view with) {
-    if (to.empty()) {
-        to += with;
-    } else {
-        to += ", ";
-        to += with;
-    }
-}
-
-bool IsDirValidAndNonEmpty(const VirtualDir& dir) {
-    return dir != nullptr && (!dir->GetFiles().empty() || !dir->GetSubdirectories().empty());
-}
-} // Anonymous namespace
-
 PatchManager::PatchManager(u64 title_id) : title_id(title_id) {}
 
 PatchManager::~PatchManager() = default;
@@ -292,7 +245,7 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::st
     return out;
 }
 
-bool PatchManager::HasNSOPatch(const BuildID& build_id_) const {
+bool PatchManager::HasNSOPatch(const std::array<u8, 32>& build_id_) const {
     const auto build_id_raw = Common::HexToString(build_id_);
     const auto build_id = build_id_raw.substr(0, build_id_raw.find_last_not_of('0') + 1);
 
@@ -312,8 +265,36 @@ bool PatchManager::HasNSOPatch(const BuildID& build_id_) const {
     return !CollectPatches(patch_dirs, build_id).empty();
 }
 
+namespace {
+std::optional<std::vector<Core::Memory::CheatEntry>> ReadCheatFileFromFolder(
+    const Core::System& system, u64 title_id, const std::array<u8, 0x20>& build_id_,
+    const VirtualDir& base_path, bool upper) {
+    const auto build_id_raw = Common::HexToString(build_id_, upper);
+    const auto build_id = build_id_raw.substr(0, sizeof(u64) * 2);
+    const auto file = base_path->GetFile(fmt::format("{}.txt", build_id));
+
+    if (file == nullptr) {
+        LOG_INFO(Common_Filesystem, "No cheats file found for title_id={:016X}, build_id={}",
+                 title_id, build_id);
+        return std::nullopt;
+    }
+
+    std::vector<u8> data(file->GetSize());
+    if (file->Read(data.data(), data.size()) != data.size()) {
+        LOG_INFO(Common_Filesystem, "Failed to read cheats file for title_id={:016X}, build_id={}",
+                 title_id, build_id);
+        return std::nullopt;
+    }
+
+    Core::Memory::TextCheatParser parser;
+    return parser.Parse(system,
+                        std::string_view(reinterpret_cast<const char*>(data.data()), data.size()));
+}
+
+} // Anonymous namespace
+
 std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(
-    const Core::System& system, const BuildID& build_id_) const {
+    const Core::System& system, const std::array<u8, 32>& build_id_) const {
     const auto load_dir = system.GetFileSystemController().GetModificationLoadRoot(title_id);
     if (load_dir == nullptr) {
         LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
@@ -333,12 +314,14 @@ std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(
 
         auto cheats_dir = FindSubdirectoryCaseless(subdir, "cheats");
         if (cheats_dir != nullptr) {
-            if (const auto res = ReadCheatFileFromFolder(title_id, build_id_, cheats_dir, true)) {
+            auto res = ReadCheatFileFromFolder(system, title_id, build_id_, cheats_dir, true);
+            if (res.has_value()) {
                 std::copy(res->begin(), res->end(), std::back_inserter(out));
                 continue;
             }
 
-            if (const auto res = ReadCheatFileFromFolder(title_id, build_id_, cheats_dir, false)) {
+            res = ReadCheatFileFromFolder(system, title_id, build_id_, cheats_dir, false);
+            if (res.has_value()) {
                 std::copy(res->begin(), res->end(), std::back_inserter(out));
             }
         }
@@ -452,11 +435,21 @@ VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, Content
     return romfs;
 }
 
-PatchManager::PatchVersionNames PatchManager::GetPatchVersionNames(VirtualFile update_raw) const {
-    if (title_id == 0) {
-        return {};
-    }
+static void AppendCommaIfNotEmpty(std::string& to, const std::string& with) {
+    if (to.empty())
+        to += with;
+    else
+        to += ", " + with;
+}
 
+static bool IsDirValidAndNonEmpty(const VirtualDir& dir) {
+    return dir != nullptr && (!dir->GetFiles().empty() || !dir->GetSubdirectories().empty());
+}
+
+std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNames(
+    VirtualFile update_raw) const {
+    if (title_id == 0)
+        return {};
     std::map<std::string, std::string, std::less<>> out;
     const auto& installed = Core::System::GetInstance().GetContentProvider();
     const auto& disabled = Settings::values.disabled_addons[title_id];
@@ -479,7 +472,8 @@ PatchManager::PatchVersionNames PatchManager::GetPatchVersionNames(VirtualFile u
             if (meta_ver.value_or(0) == 0) {
                 out.insert_or_assign(update_label, "");
             } else {
-                out.insert_or_assign(update_label, FormatTitleVersion(*meta_ver));
+                out.insert_or_assign(
+                    update_label, FormatTitleVersion(*meta_ver, TitleVersionFormat::ThreeElements));
             }
         } else if (update_raw != nullptr) {
             out.insert_or_assign(update_label, "PACKED");
@@ -568,46 +562,40 @@ std::optional<u32> PatchManager::GetGameVersion() const {
     return installed.GetEntryVersion(title_id);
 }
 
-PatchManager::Metadata PatchManager::GetControlMetadata() const {
+std::pair<std::unique_ptr<NACP>, VirtualFile> PatchManager::GetControlMetadata() const {
     const auto& installed = Core::System::GetInstance().GetContentProvider();
 
     const auto base_control_nca = installed.GetEntry(title_id, ContentRecordType::Control);
-    if (base_control_nca == nullptr) {
+    if (base_control_nca == nullptr)
         return {};
-    }
 
     return ParseControlNCA(*base_control_nca);
 }
 
-PatchManager::Metadata PatchManager::ParseControlNCA(const NCA& nca) const {
+std::pair<std::unique_ptr<NACP>, VirtualFile> PatchManager::ParseControlNCA(const NCA& nca) const {
     const auto base_romfs = nca.GetRomFS();
-    if (base_romfs == nullptr) {
+    if (base_romfs == nullptr)
         return {};
-    }
 
     const auto romfs = PatchRomFS(base_romfs, nca.GetBaseIVFCOffset(), ContentRecordType::Control);
-    if (romfs == nullptr) {
+    if (romfs == nullptr)
         return {};
-    }
 
     const auto extracted = ExtractRomFS(romfs);
-    if (extracted == nullptr) {
+    if (extracted == nullptr)
         return {};
-    }
 
     auto nacp_file = extracted->GetFile("control.nacp");
-    if (nacp_file == nullptr) {
+    if (nacp_file == nullptr)
         nacp_file = extracted->GetFile("Control.nacp");
-    }
 
     auto nacp = nacp_file == nullptr ? nullptr : std::make_unique<NACP>(nacp_file);
 
     VirtualFile icon_file;
     for (const auto& language : FileSys::LANGUAGE_NAMES) {
-        icon_file = extracted->GetFile(std::string("icon_").append(language).append(".dat"));
-        if (icon_file != nullptr) {
+        icon_file = extracted->GetFile("icon_" + std::string(language) + ".dat");
+        if (icon_file != nullptr)
             break;
-        }
     }
 
     return {std::move(nacp), icon_file};

src/core/file_sys/patch_manager.h

@@ -22,62 +22,70 @@ namespace FileSys {
 class NCA;
 class NACP;
 
+enum class TitleVersionFormat : u8 {
+    ThreeElements, ///< vX.Y.Z
+    FourElements,  ///< vX.Y.Z.W
+};
+
+std::string FormatTitleVersion(u32 version,
+                               TitleVersionFormat format = TitleVersionFormat::ThreeElements);
+
+// Returns a directory with name matching name case-insensitive. Returns nullptr if directory
+// doesn't have a directory with name.
+VirtualDir FindSubdirectoryCaseless(VirtualDir dir, std::string_view name);
+
 // A centralized class to manage patches to games.
 class PatchManager {
 public:
-    using BuildID = std::array<u8, 0x20>;
-    using Metadata = std::pair<std::unique_ptr<NACP>, VirtualFile>;
-    using PatchVersionNames = std::map<std::string, std::string, std::less<>>;
-
     explicit PatchManager(u64 title_id);
     ~PatchManager();
 
-    [[nodiscard]] u64 GetTitleID() const;
+    u64 GetTitleID() const;
 
     // Currently tracked ExeFS patches:
     // - Game Updates
-    [[nodiscard]] VirtualDir PatchExeFS(VirtualDir exefs) const;
+    VirtualDir PatchExeFS(VirtualDir exefs) const;
 
     // Currently tracked NSO patches:
     // - IPS
     // - IPSwitch
-    [[nodiscard]] std::vector<u8> PatchNSO(const std::vector<u8>& nso,
-                                           const std::string& name) const;
+    std::vector<u8> PatchNSO(const std::vector<u8>& nso, const std::string& name) const;
 
     // Checks to see if PatchNSO() will have any effect given the NSO's build ID.
     // Used to prevent expensive copies in NSO loader.
-    [[nodiscard]] bool HasNSOPatch(const BuildID& build_id) const;
+    bool HasNSOPatch(const std::array<u8, 0x20>& build_id) const;
 
     // Creates a CheatList object with all
-    [[nodiscard]] std::vector<Core::Memory::CheatEntry> CreateCheatList(
-        const Core::System& system, const BuildID& build_id) const;
+    std::vector<Core::Memory::CheatEntry> CreateCheatList(
+        const Core::System& system, const std::array<u8, 0x20>& build_id) const;
 
     // Currently tracked RomFS patches:
     // - Game Updates
     // - LayeredFS
-    [[nodiscard]] VirtualFile PatchRomFS(VirtualFile base, u64 ivfc_offset,
-                                         ContentRecordType type = ContentRecordType::Program,
-                                         VirtualFile update_raw = nullptr) const;
+    VirtualFile PatchRomFS(VirtualFile base, u64 ivfc_offset,
+                           ContentRecordType type = ContentRecordType::Program,
+                           VirtualFile update_raw = nullptr) const;
 
     // Returns a vector of pairs between patch names and patch versions.
     // i.e. Update 3.2.2 will return {"Update", "3.2.2"}
-    [[nodiscard]] PatchVersionNames GetPatchVersionNames(VirtualFile update_raw = nullptr) const;
+    std::map<std::string, std::string, std::less<>> GetPatchVersionNames(
+        VirtualFile update_raw = nullptr) const;
 
     // If the game update exists, returns the u32 version field in its Meta-type NCA. If that fails,
     // it will fallback to the Meta-type NCA of the base game. If that fails, the result will be
     // std::nullopt
-    [[nodiscard]] std::optional<u32> GetGameVersion() const;
+    std::optional<u32> GetGameVersion() const;
 
     // Given title_id of the program, attempts to get the control data of the update and parse
     // it, falling back to the base control data.
-    [[nodiscard]] Metadata GetControlMetadata() const;
+    std::pair<std::unique_ptr<NACP>, VirtualFile> GetControlMetadata() const;
 
     // Version of GetControlMetadata that takes an arbitrary NCA
-    [[nodiscard]] Metadata ParseControlNCA(const NCA& nca) const;
+    std::pair<std::unique_ptr<NACP>, VirtualFile> ParseControlNCA(const NCA& nca) const;
 
 private:
-    [[nodiscard]] std::vector<VirtualFile> CollectPatches(const std::vector<VirtualDir>& patch_dirs,
-                                                          const std::string& build_id) const;
+    std::vector<VirtualFile> CollectPatches(const std::vector<VirtualDir>& patch_dirs,
+                                            const std::string& build_id) const;
 
     u64 title_id;
 };

src/core/file_sys/romfs_factory.cpp

@@ -6,6 +6,7 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
+#include "core/core.h"
 #include "core/file_sys/card_image.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
@@ -18,9 +19,7 @@
 
 namespace FileSys {
 
-RomFSFactory::RomFSFactory(Loader::AppLoader& app_loader, ContentProvider& provider,
-                           Service::FileSystem::FileSystemController& controller)
-    : content_provider{provider}, filesystem_controller{controller} {
+RomFSFactory::RomFSFactory(Loader::AppLoader& app_loader) {
     // Load the RomFS from the app
     if (app_loader.ReadRomFS(file) != Loader::ResultStatus::Success) {
         LOG_ERROR(Service_FS, "Unable to read RomFS!");
@@ -47,38 +46,39 @@ ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess(u64 current_process_titl
 
 ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage,
                                           ContentRecordType type) const {
-    const std::shared_ptr<NCA> res = GetEntry(title_id, storage, type);
+    std::shared_ptr<NCA> res;
+
+    switch (storage) {
+    case StorageId::None:
+        res = Core::System::GetInstance().GetContentProvider().GetEntry(title_id, type);
+        break;
+    case StorageId::NandSystem:
+        res =
+            Core::System::GetInstance().GetFileSystemController().GetSystemNANDContents()->GetEntry(
+                title_id, type);
+        break;
+    case StorageId::NandUser:
+        res = Core::System::GetInstance().GetFileSystemController().GetUserNANDContents()->GetEntry(
+            title_id, type);
+        break;
+    case StorageId::SdCard:
+        res = Core::System::GetInstance().GetFileSystemController().GetSDMCContents()->GetEntry(
+            title_id, type);
+        break;
+    default:
+        UNIMPLEMENTED_MSG("Unimplemented storage_id={:02X}", static_cast<u8>(storage));
+    }
+
     if (res == nullptr) {
         // TODO(DarkLordZach): Find the right error code to use here
         return RESULT_UNKNOWN;
     }
-
     const auto romfs = res->GetRomFS();
     if (romfs == nullptr) {
         // TODO(DarkLordZach): Find the right error code to use here
         return RESULT_UNKNOWN;
     }
-
     return MakeResult<VirtualFile>(romfs);
 }
 
-std::shared_ptr<NCA> RomFSFactory::GetEntry(u64 title_id, StorageId storage,
-                                            ContentRecordType type) const {
-    switch (storage) {
-    case StorageId::None:
-        return content_provider.GetEntry(title_id, type);
-    case StorageId::NandSystem:
-        return filesystem_controller.GetSystemNANDContents()->GetEntry(title_id, type);
-    case StorageId::NandUser:
-        return filesystem_controller.GetUserNANDContents()->GetEntry(title_id, type);
-    case StorageId::SdCard:
-        return filesystem_controller.GetSDMCContents()->GetEntry(title_id, type);
-    case StorageId::Host:
-    case StorageId::GameCard:
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented storage_id={:02X}", static_cast<u8>(storage));
-        return nullptr;
-    }
-}
-
 } // namespace FileSys

src/core/file_sys/romfs_factory.h

@@ -13,15 +13,8 @@ namespace Loader {
 class AppLoader;
 } // namespace Loader
 
-namespace Service::FileSystem {
-class FileSystemController;
-}
-
 namespace FileSys {
 
-class ContentProvider;
-class NCA;
-
 enum class ContentRecordType : u8;
 
 enum class StorageId : u8 {
@@ -36,26 +29,18 @@ enum class StorageId : u8 {
 /// File system interface to the RomFS archive
 class RomFSFactory {
 public:
-    explicit RomFSFactory(Loader::AppLoader& app_loader, ContentProvider& provider,
-                          Service::FileSystem::FileSystemController& controller);
+    explicit RomFSFactory(Loader::AppLoader& app_loader);
     ~RomFSFactory();
 
     void SetPackedUpdate(VirtualFile update_raw);
-    [[nodiscard]] ResultVal<VirtualFile> OpenCurrentProcess(u64 current_process_title_id) const;
-    [[nodiscard]] ResultVal<VirtualFile> Open(u64 title_id, StorageId storage,
-                                              ContentRecordType type) const;
+    ResultVal<VirtualFile> OpenCurrentProcess(u64 current_process_title_id) const;
+    ResultVal<VirtualFile> Open(u64 title_id, StorageId storage, ContentRecordType type) const;
 
 private:
-    [[nodiscard]] std::shared_ptr<NCA> GetEntry(u64 title_id, StorageId storage,
-                                                ContentRecordType type) const;
-
     VirtualFile file;
     VirtualFile update_raw;
     bool updatable;
     u64 ivfc_offset;
-
-    ContentProvider& content_provider;
-    Service::FileSystem::FileSystemController& filesystem_controller;
 };
 
 } // namespace FileSys

src/core/file_sys/submission_package.cpp

@@ -267,9 +267,9 @@ void NSP::ReadNCAs(const std::vector<VirtualFile>& files) {
             }
 
             const CNMT cnmt(inner_file);
+            auto& ncas_title = ncas[cnmt.GetTitleID()];
 
-            ncas[cnmt.GetTitleID()][{cnmt.GetType(), ContentRecordType::Meta}] = nca;
-
+            ncas_title[{cnmt.GetType(), ContentRecordType::Meta}] = nca;
             for (const auto& rec : cnmt.GetContentRecords()) {
                 const auto id_string = Common::HexToString(rec.nca_id, false);
                 auto next_file = pfs->GetFile(fmt::format("{}.nca", id_string));
@@ -286,32 +286,13 @@ void NSP::ReadNCAs(const std::vector<VirtualFile>& files) {
                 }
 
                 auto next_nca = std::make_shared<NCA>(std::move(next_file), nullptr, 0);
-
                 if (next_nca->GetType() == NCAContentType::Program) {
-                    program_status[next_nca->GetTitleId()] = next_nca->GetStatus();
+                    program_status[cnmt.GetTitleID()] = next_nca->GetStatus();
                 }
-
-                if (next_nca->GetStatus() != Loader::ResultStatus::Success &&
-                    next_nca->GetStatus() != Loader::ResultStatus::ErrorMissingBKTRBaseRomFS) {
-                    continue;
-                }
-
-                // If the last 3 hexadecimal digits of the CNMT TitleID is 0x800 or is missing the
-                // BKTRBaseRomFS, this is an update NCA. Otherwise, this is a base NCA.
-                if ((cnmt.GetTitleID() & 0x800) != 0 ||
-                    next_nca->GetStatus() == Loader::ResultStatus::ErrorMissingBKTRBaseRomFS) {
-                    // If the last 3 hexadecimal digits of the NCA's TitleID is between 0x1 and
-                    // 0x7FF, this is a multi-program update NCA. Otherwise, this is a regular
-                    // update NCA.
-                    if ((next_nca->GetTitleId() & 0x7FF) != 0 &&
-                        (next_nca->GetTitleId() & 0x800) == 0) {
-                        ncas[next_nca->GetTitleId()][{cnmt.GetType(), rec.type}] =
-                            std::move(next_nca);
-                    } else {
-                        ncas[cnmt.GetTitleID()][{cnmt.GetType(), rec.type}] = std::move(next_nca);
-                    }
-                } else {
-                    ncas[next_nca->GetTitleId()][{cnmt.GetType(), rec.type}] = std::move(next_nca);
+                if (next_nca->GetStatus() == Loader::ResultStatus::Success ||
+                    (next_nca->GetStatus() == Loader::ResultStatus::ErrorMissingBKTRBaseRomFS &&
+                     (cnmt.GetTitleID() & 0x800) != 0)) {
+                    ncas_title[{cnmt.GetType(), rec.type}] = std::move(next_nca);
                 }
             }
 

src/core/file_sys/vfs.cpp

@@ -169,12 +169,11 @@ VfsDirectory::~VfsDirectory() = default;
 
 std::optional<u8> VfsFile::ReadByte(std::size_t offset) const {
     u8 out{};
-    const std::size_t size = Read(&out, sizeof(u8), offset);
-    if (size == 1) {
+    std::size_t size = Read(&out, 1, offset);
+    if (size == 1)
         return out;
-    }
 
-    return std::nullopt;
+    return {};
 }
 
 std::vector<u8> VfsFile::ReadBytes(std::size_t size, std::size_t offset) const {

src/core/file_sys/vfs_offset.cpp

@@ -58,11 +58,10 @@ std::size_t OffsetVfsFile::Write(const u8* data, std::size_t length, std::size_t
 }
 
 std::optional<u8> OffsetVfsFile::ReadByte(std::size_t r_offset) const {
-    if (r_offset >= size) {
-        return std::nullopt;
-    }
+    if (r_offset < size)
+        return file->ReadByte(offset + r_offset);
 
-    return file->ReadByte(offset + r_offset);
+    return {};
 }
 
 std::vector<u8> OffsetVfsFile::ReadBytes(std::size_t r_size, std::size_t r_offset) const {

src/core/file_sys/vfs_static.h

@@ -54,11 +54,9 @@ public:
     }
 
     std::optional<u8> ReadByte(std::size_t offset) const override {
-        if (offset >= size) {
-            return std::nullopt;
-        }
-
-        return value;
+        if (offset < size)
+            return value;
+        return {};
     }
 
     std::vector<u8> ReadBytes(std::size_t length, std::size_t offset) const override {

src/core/frontend/applets/controller.cpp

@@ -4,6 +4,7 @@
 
 #include "common/assert.h"
 #include "common/logging/log.h"
+#include "core/core.h"
 #include "core/frontend/applets/controller.h"
 #include "core/hle/service/hid/controllers/npad.h"
 #include "core/hle/service/hid/hid.h"
@@ -13,9 +14,6 @@ namespace Core::Frontend {
 
 ControllerApplet::~ControllerApplet() = default;
 
-DefaultControllerApplet::DefaultControllerApplet(Service::SM::ServiceManager& service_manager_)
-    : service_manager{service_manager_} {}
-
 DefaultControllerApplet::~DefaultControllerApplet() = default;
 
 void DefaultControllerApplet::ReconfigureControllers(std::function<void()> callback,
@@ -23,7 +21,9 @@ void DefaultControllerApplet::ReconfigureControllers(std::function<void()> callb
     LOG_INFO(Service_HID, "called, deducing the best configuration based on the given parameters!");
 
     auto& npad =
-        service_manager.GetService<Service::HID::Hid>("hid")
+        Core::System::GetInstance()
+            .ServiceManager()
+            .GetService<Service::HID::Hid>("hid")
             ->GetAppletResource()
             ->GetController<Service::HID::Controller_NPad>(Service::HID::HidController::NPad);
 

src/core/frontend/applets/controller.h

@@ -8,10 +8,6 @@
 
 #include "common/common_types.h"
 
-namespace Service::SM {
-class ServiceManager;
-}
-
 namespace Core::Frontend {
 
 using BorderColor = std::array<u8, 4>;
@@ -43,14 +39,10 @@ public:
 
 class DefaultControllerApplet final : public ControllerApplet {
 public:
-    explicit DefaultControllerApplet(Service::SM::ServiceManager& service_manager_);
     ~DefaultControllerApplet() override;
 
     void ReconfigureControllers(std::function<void()> callback,
                                 ControllerParameters parameters) const override;
-
-private:
-    Service::SM::ServiceManager& service_manager;
 };
 
 } // namespace Core::Frontend

src/core/frontend/input.h

@@ -33,9 +33,6 @@ public:
     virtual bool GetAnalogDirectionStatus(AnalogDirection direction) const {
         return {};
     }
-    virtual bool SetRumblePlay(f32 amp_high, f32 amp_low, f32 freq_high, f32 freq_low) const {
-        return {};
-    }
 };
 
 /// An abstract class template for a factory that can create input devices.
@@ -122,11 +119,11 @@ using ButtonDevice = InputDevice<bool>;
 using AnalogDevice = InputDevice<std::tuple<float, float>>;
 
 /**
- * A motion status is an object that returns a tuple of accelerometer state vector,
- * gyroscope state vector, rotation state vector and orientation state matrix.
+ * A motion device is an input device that returns a tuple of accelerometer state vector and
+ * gyroscope state vector.
  *
  * For both vectors:
- *   x+ is the same direction as RIGHT on D-pad.
+ *   x+ is the same direction as LEFT on D-pad.
  *   y+ is normal to the touch screen, pointing outward.
  *   z+ is the same direction as UP on D-pad.
  *
@@ -136,22 +133,8 @@ using AnalogDevice = InputDevice<std::tuple<float, float>>;
  * For gyroscope state vector:
  *   Orientation is determined by right-hand rule.
  *   Units: deg/sec
- *
- * For rotation state vector
- *   Units: rotations
- *
- * For orientation state matrix
- *   x vector
- *   y vector
- *   z vector
  */
-using MotionStatus = std::tuple<Common::Vec3<float>, Common::Vec3<float>, Common::Vec3<float>,
-                                std::array<Common::Vec3f, 3>>;
-
-/**
- * A motion device is an input device that returns a motion status object
- */
-using MotionDevice = InputDevice<MotionStatus>;
+using MotionDevice = InputDevice<std::tuple<Common::Vec3<float>, Common::Vec3<float>>>;
 
 /**
  * A touch device is an input device that returns a tuple of two floats and a bool. The floats are

src/core/hle/kernel/client_session.cpp

@@ -48,15 +48,14 @@ ResultVal<std::shared_ptr<ClientSession>> ClientSession::Create(KernelCore& kern
 }
 
 ResultCode ClientSession::SendSyncRequest(std::shared_ptr<Thread> thread,
-                                          Core::Memory::Memory& memory,
-                                          Core::Timing::CoreTiming& core_timing) {
+                                          Core::Memory::Memory& memory) {
     // Keep ServerSession alive until we're done working with it.
     if (!parent->Server()) {
         return ERR_SESSION_CLOSED_BY_REMOTE;
     }
 
     // Signal the server session that new data is available
-    return parent->Server()->HandleSyncRequest(std::move(thread), memory, core_timing);
+    return parent->Server()->HandleSyncRequest(std::move(thread), memory);
 }
 
 } // namespace Kernel

src/core/hle/kernel/client_session.h

@@ -16,10 +16,6 @@ namespace Core::Memory {
 class Memory;
 }
 
-namespace Core::Timing {
-class CoreTiming;
-}
-
 namespace Kernel {
 
 class KernelCore;
@@ -46,8 +42,7 @@ public:
         return HANDLE_TYPE;
     }
 
-    ResultCode SendSyncRequest(std::shared_ptr<Thread> thread, Core::Memory::Memory& memory,
-                               Core::Timing::CoreTiming& core_timing);
+    ResultCode SendSyncRequest(std::shared_ptr<Thread> thread, Core::Memory::Memory& memory);
 
     bool ShouldWait(const Thread* thread) const override;
 

src/core/hle/kernel/server_session.cpp

@@ -8,6 +8,7 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
+#include "core/core.h"
 #include "core/core_timing.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/client_port.h"
@@ -184,11 +185,10 @@ ResultCode ServerSession::CompleteSyncRequest() {
 }
 
 ResultCode ServerSession::HandleSyncRequest(std::shared_ptr<Thread> thread,
-                                            Core::Memory::Memory& memory,
-                                            Core::Timing::CoreTiming& core_timing) {
+                                            Core::Memory::Memory& memory) {
     const ResultCode result = QueueSyncRequest(std::move(thread), memory);
     const auto delay = std::chrono::nanoseconds{kernel.IsMulticore() ? 0 : 20000};
-    core_timing.ScheduleEvent(delay, request_event, {});
+    Core::System::GetInstance().CoreTiming().ScheduleEvent(delay, request_event, {});
     return result;
 }
 

src/core/hle/kernel/server_session.h

@@ -18,9 +18,8 @@ class Memory;
 }
 
 namespace Core::Timing {
-class CoreTiming;
 struct EventType;
-} // namespace Core::Timing
+}
 
 namespace Kernel {
 
@@ -88,14 +87,12 @@ public:
     /**
      * Handle a sync request from the emulated application.
      *
-     * @param thread      Thread that initiated the request.
-     * @param memory      Memory context to handle the sync request under.
-     * @param core_timing Core timing context to schedule the request event under.
+     * @param thread Thread that initiated the request.
+     * @param memory Memory context to handle the sync request under.
      *
      * @returns ResultCode from the operation.
      */
-    ResultCode HandleSyncRequest(std::shared_ptr<Thread> thread, Core::Memory::Memory& memory,
-                                 Core::Timing::CoreTiming& core_timing);
+    ResultCode HandleSyncRequest(std::shared_ptr<Thread> thread, Core::Memory::Memory& memory);
 
     bool ShouldWait(const Thread* thread) const override;
 

src/core/hle/kernel/svc.cpp

@@ -346,7 +346,7 @@ static ResultCode SendSyncRequest(Core::System& system, Handle handle) {
         SchedulerLock lock(system.Kernel());
         thread->InvalidateHLECallback();
         thread->SetStatus(ThreadStatus::WaitIPC);
-        session->SendSyncRequest(SharedFrom(thread), system.Memory(), system.CoreTiming());
+        session->SendSyncRequest(SharedFrom(thread), system.Memory());
     }
 
     if (thread->HasHLECallback()) {

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

@@ -774,17 +774,6 @@ void Module::Interface::ListQualifiedUsers(Kernel::HLERequestContext& ctx) {
     rb.Push(RESULT_SUCCESS);
 }
 
-void Module::Interface::LoadOpenContext(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_ACC, "(STUBBED) called");
-
-    // This is similar to GetBaasAccountManagerForApplication
-    // This command is used concurrently with ListOpenContextStoredUsers
-    // TODO: Find the differences between this and GetBaasAccountManagerForApplication
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IManagerForApplication>(profile_manager->GetLastOpenedUser());
-}
-
 void Module::Interface::ListOpenContextStoredUsers(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_ACC, "(STUBBED) called");
 

src/core/hle/service/acc/acc.h

@@ -34,7 +34,6 @@ public:
         void IsUserAccountSwitchLocked(Kernel::HLERequestContext& ctx);
         void GetProfileEditor(Kernel::HLERequestContext& ctx);
         void ListQualifiedUsers(Kernel::HLERequestContext& ctx);
-        void LoadOpenContext(Kernel::HLERequestContext& ctx);
         void ListOpenContextStoredUsers(Kernel::HLERequestContext& ctx);
 
     private:

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

@@ -29,7 +29,7 @@ ACC_U0::ACC_U0(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {110, nullptr, "StoreSaveDataThumbnail"},
         {111, nullptr, "ClearSaveDataThumbnail"},
         {120, nullptr, "CreateGuestLoginRequest"},
-        {130, &ACC_U0::LoadOpenContext, "LoadOpenContext"}, // 5.0.0+
+        {130, nullptr, "LoadOpenContext"}, // 5.0.0+
         {131, &ACC_U0::ListOpenContextStoredUsers, "ListOpenContextStoredUsers"}, // 6.0.0+
         {140, &ACC_U0::InitializeApplicationInfoRestricted, "InitializeApplicationInfoRestricted"}, // 6.0.0+
         {141, &ACC_U0::ListQualifiedUsers, "ListQualifiedUsers"}, // 6.0.0+

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

@@ -1192,7 +1192,7 @@ IApplicationFunctions::IApplicationFunctions(Core::System& system_)
         {120, nullptr, "ExecuteProgram"},
         {121, nullptr, "ClearUserChannel"},
         {122, nullptr, "UnpopToUserChannel"},
-        {123, &IApplicationFunctions::GetPreviousProgramIndex, "GetPreviousProgramIndex"},
+        {123, nullptr, "GetPreviousProgramIndex"},
         {124, nullptr, "EnableApplicationAllThreadDumpOnCrash"},
         {130, &IApplicationFunctions::GetGpuErrorDetectedSystemEvent, "GetGpuErrorDetectedSystemEvent"},
         {140, &IApplicationFunctions::GetFriendInvitationStorageChannelEvent, "GetFriendInvitationStorageChannelEvent"},
@@ -1554,14 +1554,6 @@ void IApplicationFunctions::QueryApplicationPlayStatisticsByUid(Kernel::HLEReque
     rb.Push<u32>(0);
 }
 
-void IApplicationFunctions::GetPreviousProgramIndex(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<s32>(previous_program_index);
-}
-
 void IApplicationFunctions::GetGpuErrorDetectedSystemEvent(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_AM, "(STUBBED) called");
 

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

@@ -288,13 +288,11 @@ private:
     void SetApplicationCopyrightVisibility(Kernel::HLERequestContext& ctx);
     void QueryApplicationPlayStatistics(Kernel::HLERequestContext& ctx);
     void QueryApplicationPlayStatisticsByUid(Kernel::HLERequestContext& ctx);
-    void GetPreviousProgramIndex(Kernel::HLERequestContext& ctx);
     void GetGpuErrorDetectedSystemEvent(Kernel::HLERequestContext& ctx);
     void GetFriendInvitationStorageChannelEvent(Kernel::HLERequestContext& ctx);
 
     bool launch_popped_application_specific = false;
     bool launch_popped_account_preselect = false;
-    s32 previous_program_index{-1};
     Kernel::EventPair gpu_error_detected_event;
     Kernel::EventPair friend_invitation_storage_channel_event;
     Core::System& system;

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

@@ -206,8 +206,7 @@ void AppletManager::SetDefaultAppletFrontendSet() {
 
 void AppletManager::SetDefaultAppletsIfMissing() {
     if (frontend.controller == nullptr) {
-        frontend.controller =
-            std::make_unique<Core::Frontend::DefaultControllerApplet>(system.ServiceManager());
+        frontend.controller = std::make_unique<Core::Frontend::DefaultControllerApplet>();
     }
 
     if (frontend.e_commerce == nullptr) {

src/core/hle/service/caps/caps_c.cpp

@@ -2,8 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "common/logging/log.h"
-#include "core/hle/ipc_helpers.h"
 #include "core/hle/service/caps/caps_c.h"
 
 namespace Service::Capture {
@@ -49,7 +47,7 @@ CAPS_C::CAPS_C() : ServiceFramework("caps:c") {
     static const FunctionInfo functions[] = {
         {1, nullptr, "CaptureRawImage"},
         {2, nullptr, "CaptureRawImageWithTimeout"},
-        {33, &CAPS_C::SetShimLibraryVersion, "SetShimLibraryVersion"},
+        {33, nullptr, "Unknown33"},
         {1001, nullptr, "RequestTakingScreenShot"},
         {1002, nullptr, "RequestTakingScreenShotWithTimeout"},
         {1011, nullptr, "NotifyTakingScreenShotRefused"},
@@ -74,16 +72,4 @@ CAPS_C::CAPS_C() : ServiceFramework("caps:c") {
 
 CAPS_C::~CAPS_C() = default;
 
-void CAPS_C::SetShimLibraryVersion(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto library_version{rp.Pop<u64>()};
-    const auto applet_resource_user_id{rp.Pop<u64>()};
-
-    LOG_WARNING(Service_Capture, "(STUBBED) called. library_version={}, applet_resource_user_id={}",
-                library_version, applet_resource_user_id);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
 } // namespace Service::Capture

src/core/hle/service/caps/caps_c.h

@@ -16,9 +16,6 @@ class CAPS_C final : public ServiceFramework<CAPS_C> {
 public:
     explicit CAPS_C();
     ~CAPS_C() override;
-
-private:
-    void SetShimLibraryVersion(Kernel::HLERequestContext& ctx);
 };
 
 } // namespace Service::Capture

src/core/hle/service/caps/caps_su.cpp

@@ -25,12 +25,7 @@ CAPS_SU::CAPS_SU() : ServiceFramework("caps:su") {
 CAPS_SU::~CAPS_SU() = default;
 
 void CAPS_SU::SetShimLibraryVersion(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto library_version{rp.Pop<u64>()};
-    const auto applet_resource_user_id{rp.Pop<u64>()};
-
-    LOG_WARNING(Service_Capture, "(STUBBED) called. library_version={}, applet_resource_user_id={}",
-                library_version, applet_resource_user_id);
+    LOG_WARNING(Service_Capture, "(STUBBED) called");
 
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);

src/core/hle/service/caps/caps_u.cpp

@@ -31,7 +31,8 @@ public:
 CAPS_U::CAPS_U() : ServiceFramework("caps:u") {
     // clang-format off
     static const FunctionInfo functions[] = {
-        {32, &CAPS_U::SetShimLibraryVersion, "SetShimLibraryVersion"},
+        {31, nullptr, "GetShimLibraryVersion"},
+        {32, nullptr, "SetShimLibraryVersion"},
         {102, &CAPS_U::GetAlbumContentsFileListForApplication, "GetAlbumContentsFileListForApplication"},
         {103, nullptr, "DeleteAlbumContentsFileForApplication"},
         {104, nullptr, "GetAlbumContentsFileSizeForApplication"},
@@ -52,18 +53,6 @@ CAPS_U::CAPS_U() : ServiceFramework("caps:u") {
 
 CAPS_U::~CAPS_U() = default;
 
-void CAPS_U::SetShimLibraryVersion(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto library_version{rp.Pop<u64>()};
-    const auto applet_resource_user_id{rp.Pop<u64>()};
-
-    LOG_WARNING(Service_Capture, "(STUBBED) called. library_version={}, applet_resource_user_id={}",
-                library_version, applet_resource_user_id);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
 void CAPS_U::GetAlbumContentsFileListForApplication(Kernel::HLERequestContext& ctx) {
     // Takes a type-0x6 output buffer containing an array of ApplicationAlbumFileEntry, a PID, an
     // u8 ContentType, two s64s, and an u64 AppletResourceUserId. Returns an output u64 for total

src/core/hle/service/caps/caps_u.h

@@ -18,7 +18,6 @@ public:
     ~CAPS_U() override;
 
 private:
-    void SetShimLibraryVersion(Kernel::HLERequestContext& ctx);
     void GetAlbumContentsFileListForApplication(Kernel::HLERequestContext& ctx);
 };
 

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

@@ -379,7 +379,7 @@ ResultVal<FileSys::VirtualFile> FileSystemController::OpenBISPartitionStorage(
         return FileSys::ERROR_ENTITY_NOT_FOUND;
     }
 
-    auto part = bis_factory->OpenPartitionStorage(id, system.GetFilesystem());
+    auto part = bis_factory->OpenPartitionStorage(id);
     if (part == nullptr) {
         return FileSys::ERROR_INVALID_ARGUMENT;
     }

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

@@ -31,10 +31,6 @@ public:
     virtual void OnUpdate(const Core::Timing::CoreTiming& core_timing, u8* data,
                           std::size_t size) = 0;
 
-    // When the controller is requesting a motion update for the shared memory
-    virtual void OnMotionUpdate(const Core::Timing::CoreTiming& core_timing, u8* data,
-                                std::size_t size) {}
-
     // Called when input devices should be loaded
     virtual void OnLoadInputDevices() = 0;
 

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

@@ -250,9 +250,6 @@ void Controller_NPad::OnLoadInputDevices() {
         std::transform(players[i].analogs.begin() + Settings::NativeAnalog::STICK_HID_BEGIN,
                        players[i].analogs.begin() + Settings::NativeAnalog::STICK_HID_END,
                        sticks[i].begin(), Input::CreateDevice<Input::AnalogDevice>);
-        std::transform(players[i].motions.begin() + Settings::NativeMotion::MOTION_HID_BEGIN,
-                       players[i].motions.begin() + Settings::NativeMotion::MOTION_HID_END,
-                       motions[i].begin(), Input::CreateDevice<Input::MotionDevice>);
     }
 }
 
@@ -260,7 +257,7 @@ void Controller_NPad::OnRelease() {}
 
 void Controller_NPad::RequestPadStateUpdate(u32 npad_id) {
     const auto controller_idx = NPadIdToIndex(npad_id);
-    const auto controller_type = connected_controllers[controller_idx].type;
+    [[maybe_unused]] const auto controller_type = connected_controllers[controller_idx].type;
     if (!connected_controllers[controller_idx].is_connected) {
         return;
     }
@@ -269,70 +266,60 @@ void Controller_NPad::RequestPadStateUpdate(u32 npad_id) {
     auto& rstick_entry = npad_pad_states[controller_idx].r_stick;
     const auto& button_state = buttons[controller_idx];
     const auto& analog_state = sticks[controller_idx];
-    const auto& motion_state = motions[controller_idx];
     const auto [stick_l_x_f, stick_l_y_f] =
         analog_state[static_cast<std::size_t>(JoystickId::Joystick_Left)]->GetStatus();
     const auto [stick_r_x_f, stick_r_y_f] =
         analog_state[static_cast<std::size_t>(JoystickId::Joystick_Right)]->GetStatus();
 
     using namespace Settings::NativeButton;
-    if (controller_type != NPadControllerType::JoyLeft) {
-        pad_state.a.Assign(button_state[A - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.b.Assign(button_state[B - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.x.Assign(button_state[X - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.y.Assign(button_state[Y - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.r_stick.Assign(button_state[RStick - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.r.Assign(button_state[R - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.zr.Assign(button_state[ZR - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.plus.Assign(button_state[Plus - BUTTON_HID_BEGIN]->GetStatus());
+    pad_state.a.Assign(button_state[A - BUTTON_HID_BEGIN]->GetStatus());
+    pad_state.b.Assign(button_state[B - BUTTON_HID_BEGIN]->GetStatus());
+    pad_state.x.Assign(button_state[X - BUTTON_HID_BEGIN]->GetStatus());
+    pad_state.y.Assign(button_state[Y - BUTTON_HID_BEGIN]->GetStatus());
+    pad_state.l_stick.Assign(button_state[LStick - BUTTON_HID_BEGIN]->GetStatus());
+    pad_state.r_stick.Assign(button_state[RStick - BUTTON_HID_BEGIN]->GetStatus());
+    pad_state.l.Assign(button_state[L - BUTTON_HID_BEGIN]->GetStatus());
+    pad_state.r.Assign(button_state[R - BUTTON_HID_BEGIN]->GetStatus());
+    pad_state.zl.Assign(button_state[ZL - BUTTON_HID_BEGIN]->GetStatus());
+    pad_state.zr.Assign(button_state[ZR - BUTTON_HID_BEGIN]->GetStatus());
+    pad_state.plus.Assign(button_state[Plus - BUTTON_HID_BEGIN]->GetStatus());
+    pad_state.minus.Assign(button_state[Minus - BUTTON_HID_BEGIN]->GetStatus());
 
-        pad_state.r_stick_right.Assign(
-            analog_state[static_cast<std::size_t>(JoystickId::Joystick_Right)]
-                ->GetAnalogDirectionStatus(Input::AnalogDirection::RIGHT));
-        pad_state.r_stick_left.Assign(
-            analog_state[static_cast<std::size_t>(JoystickId::Joystick_Right)]
-                ->GetAnalogDirectionStatus(Input::AnalogDirection::LEFT));
-        pad_state.r_stick_up.Assign(
-            analog_state[static_cast<std::size_t>(JoystickId::Joystick_Right)]
-                ->GetAnalogDirectionStatus(Input::AnalogDirection::UP));
-        pad_state.r_stick_down.Assign(
-            analog_state[static_cast<std::size_t>(JoystickId::Joystick_Right)]
-                ->GetAnalogDirectionStatus(Input::AnalogDirection::DOWN));
-        rstick_entry.x = static_cast<s32>(stick_r_x_f * HID_JOYSTICK_MAX);
-        rstick_entry.y = static_cast<s32>(stick_r_y_f * HID_JOYSTICK_MAX);
-    }
+    pad_state.d_left.Assign(button_state[DLeft - BUTTON_HID_BEGIN]->GetStatus());
+    pad_state.d_up.Assign(button_state[DUp - BUTTON_HID_BEGIN]->GetStatus());
+    pad_state.d_right.Assign(button_state[DRight - BUTTON_HID_BEGIN]->GetStatus());
+    pad_state.d_down.Assign(button_state[DDown - BUTTON_HID_BEGIN]->GetStatus());
 
-    if (controller_type != NPadControllerType::JoyRight) {
-        pad_state.d_left.Assign(button_state[DLeft - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.d_up.Assign(button_state[DUp - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.d_right.Assign(button_state[DRight - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.d_down.Assign(button_state[DDown - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.l_stick.Assign(button_state[LStick - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.l.Assign(button_state[L - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.zl.Assign(button_state[ZL - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.minus.Assign(button_state[Minus - BUTTON_HID_BEGIN]->GetStatus());
+    pad_state.l_stick_right.Assign(
+        analog_state[static_cast<std::size_t>(JoystickId::Joystick_Left)]->GetAnalogDirectionStatus(
+            Input::AnalogDirection::RIGHT));
+    pad_state.l_stick_left.Assign(
+        analog_state[static_cast<std::size_t>(JoystickId::Joystick_Left)]->GetAnalogDirectionStatus(
+            Input::AnalogDirection::LEFT));
+    pad_state.l_stick_up.Assign(
+        analog_state[static_cast<std::size_t>(JoystickId::Joystick_Left)]->GetAnalogDirectionStatus(
+            Input::AnalogDirection::UP));
+    pad_state.l_stick_down.Assign(
+        analog_state[static_cast<std::size_t>(JoystickId::Joystick_Left)]->GetAnalogDirectionStatus(
+            Input::AnalogDirection::DOWN));
 
-        pad_state.l_stick_right.Assign(
-            analog_state[static_cast<std::size_t>(JoystickId::Joystick_Left)]
-                ->GetAnalogDirectionStatus(Input::AnalogDirection::RIGHT));
-        pad_state.l_stick_left.Assign(
-            analog_state[static_cast<std::size_t>(JoystickId::Joystick_Left)]
-                ->GetAnalogDirectionStatus(Input::AnalogDirection::LEFT));
-        pad_state.l_stick_up.Assign(
-            analog_state[static_cast<std::size_t>(JoystickId::Joystick_Left)]
-                ->GetAnalogDirectionStatus(Input::AnalogDirection::UP));
-        pad_state.l_stick_down.Assign(
-            analog_state[static_cast<std::size_t>(JoystickId::Joystick_Left)]
-                ->GetAnalogDirectionStatus(Input::AnalogDirection::DOWN));
-        lstick_entry.x = static_cast<s32>(stick_l_x_f * HID_JOYSTICK_MAX);
-        lstick_entry.y = static_cast<s32>(stick_l_y_f * HID_JOYSTICK_MAX);
-    }
+    pad_state.r_stick_right.Assign(
+        analog_state[static_cast<std::size_t>(JoystickId::Joystick_Right)]
+            ->GetAnalogDirectionStatus(Input::AnalogDirection::RIGHT));
+    pad_state.r_stick_left.Assign(analog_state[static_cast<std::size_t>(JoystickId::Joystick_Right)]
+                                      ->GetAnalogDirectionStatus(Input::AnalogDirection::LEFT));
+    pad_state.r_stick_up.Assign(analog_state[static_cast<std::size_t>(JoystickId::Joystick_Right)]
+                                    ->GetAnalogDirectionStatus(Input::AnalogDirection::UP));
+    pad_state.r_stick_down.Assign(analog_state[static_cast<std::size_t>(JoystickId::Joystick_Right)]
+                                      ->GetAnalogDirectionStatus(Input::AnalogDirection::DOWN));
 
-    if (controller_type == NPadControllerType::JoyLeft ||
-        controller_type == NPadControllerType::JoyRight) {
-        pad_state.left_sl.Assign(button_state[SL - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.left_sr.Assign(button_state[SR - BUTTON_HID_BEGIN]->GetStatus());
-    }
+    pad_state.left_sl.Assign(button_state[SL - BUTTON_HID_BEGIN]->GetStatus());
+    pad_state.left_sr.Assign(button_state[SR - BUTTON_HID_BEGIN]->GetStatus());
+
+    lstick_entry.x = static_cast<s32>(stick_l_x_f * HID_JOYSTICK_MAX);
+    lstick_entry.y = static_cast<s32>(stick_l_y_f * HID_JOYSTICK_MAX);
+    rstick_entry.x = static_cast<s32>(stick_r_x_f * HID_JOYSTICK_MAX);
+    rstick_entry.y = static_cast<s32>(stick_r_y_f * HID_JOYSTICK_MAX);
 }
 
 void Controller_NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing, u8* data,
@@ -373,7 +360,6 @@ void Controller_NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing, u8*
             continue;
         }
         const u32 npad_index = static_cast<u32>(i);
-
         RequestPadStateUpdate(npad_index);
         auto& pad_state = npad_pad_states[npad_index];
 
@@ -391,18 +377,6 @@ void Controller_NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing, u8*
 
         libnx_entry.connection_status.raw = 0;
         libnx_entry.connection_status.IsConnected.Assign(1);
-        auto& full_sixaxis_entry =
-            npad.sixaxis_full.sixaxis[npad.sixaxis_full.common.last_entry_index];
-        auto& handheld_sixaxis_entry =
-            npad.sixaxis_handheld.sixaxis[npad.sixaxis_handheld.common.last_entry_index];
-        auto& dual_left_sixaxis_entry =
-            npad.sixaxis_dual_left.sixaxis[npad.sixaxis_dual_left.common.last_entry_index];
-        auto& dual_right_sixaxis_entry =
-            npad.sixaxis_dual_right.sixaxis[npad.sixaxis_dual_right.common.last_entry_index];
-        auto& left_sixaxis_entry =
-            npad.sixaxis_left.sixaxis[npad.sixaxis_left.common.last_entry_index];
-        auto& right_sixaxis_entry =
-            npad.sixaxis_right.sixaxis[npad.sixaxis_right.common.last_entry_index];
 
         switch (controller_type) {
         case NPadControllerType::None:
@@ -489,143 +463,6 @@ void Controller_NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing, u8*
                 shared_memory_entries.size() * sizeof(NPadEntry));
 }
 
-void Controller_NPad::OnMotionUpdate(const Core::Timing::CoreTiming& core_timing, u8* data,
-                                     std::size_t data_len) {
-    if (!IsControllerActivated()) {
-        return;
-    }
-    for (std::size_t i = 0; i < shared_memory_entries.size(); i++) {
-        auto& npad = shared_memory_entries[i];
-
-        const auto& controller_type = connected_controllers[i].type;
-
-        if (controller_type == NPadControllerType::None || !connected_controllers[i].is_connected) {
-            continue;
-        }
-
-        const std::array<SixAxisGeneric*, 6> controller_sixaxes{
-            &npad.sixaxis_full,       &npad.sixaxis_handheld, &npad.sixaxis_dual_left,
-            &npad.sixaxis_dual_right, &npad.sixaxis_left,     &npad.sixaxis_right,
-        };
-
-        for (auto* sixaxis_sensor : controller_sixaxes) {
-            sixaxis_sensor->common.entry_count = 16;
-            sixaxis_sensor->common.total_entry_count = 17;
-
-            const auto& last_entry =
-                sixaxis_sensor->sixaxis[sixaxis_sensor->common.last_entry_index];
-
-            sixaxis_sensor->common.timestamp = core_timing.GetCPUTicks();
-            sixaxis_sensor->common.last_entry_index =
-                (sixaxis_sensor->common.last_entry_index + 1) % 17;
-
-            auto& cur_entry = sixaxis_sensor->sixaxis[sixaxis_sensor->common.last_entry_index];
-
-            cur_entry.timestamp = last_entry.timestamp + 1;
-            cur_entry.timestamp2 = cur_entry.timestamp;
-        }
-
-        // Try to read sixaxis sensor states
-        std::array<MotionDevice, 2> motion_devices;
-
-        if (sixaxis_sensors_enabled && Settings::values.motion_enabled) {
-            sixaxis_at_rest = true;
-            for (std::size_t e = 0; e < motion_devices.size(); ++e) {
-                const auto& device = motions[i][e];
-                if (device) {
-                    std::tie(motion_devices[e].accel, motion_devices[e].gyro,
-                             motion_devices[e].rotation, motion_devices[e].orientation) =
-                        device->GetStatus();
-                    sixaxis_at_rest = sixaxis_at_rest && motion_devices[e].gyro.Length2() < 0.0001f;
-                }
-            }
-        }
-
-        auto& main_controller =
-            npad.main_controller_states.npad[npad.main_controller_states.common.last_entry_index];
-        auto& handheld_entry =
-            npad.handheld_states.npad[npad.handheld_states.common.last_entry_index];
-        auto& dual_entry = npad.dual_states.npad[npad.dual_states.common.last_entry_index];
-        auto& left_entry = npad.left_joy_states.npad[npad.left_joy_states.common.last_entry_index];
-        auto& right_entry =
-            npad.right_joy_states.npad[npad.right_joy_states.common.last_entry_index];
-        auto& pokeball_entry =
-            npad.pokeball_states.npad[npad.pokeball_states.common.last_entry_index];
-        auto& libnx_entry = npad.libnx.npad[npad.libnx.common.last_entry_index];
-
-        auto& full_sixaxis_entry =
-            npad.sixaxis_full.sixaxis[npad.sixaxis_full.common.last_entry_index];
-        auto& handheld_sixaxis_entry =
-            npad.sixaxis_handheld.sixaxis[npad.sixaxis_handheld.common.last_entry_index];
-        auto& dual_left_sixaxis_entry =
-            npad.sixaxis_dual_left.sixaxis[npad.sixaxis_dual_left.common.last_entry_index];
-        auto& dual_right_sixaxis_entry =
-            npad.sixaxis_dual_right.sixaxis[npad.sixaxis_dual_right.common.last_entry_index];
-        auto& left_sixaxis_entry =
-            npad.sixaxis_left.sixaxis[npad.sixaxis_left.common.last_entry_index];
-        auto& right_sixaxis_entry =
-            npad.sixaxis_right.sixaxis[npad.sixaxis_right.common.last_entry_index];
-
-        switch (controller_type) {
-        case NPadControllerType::None:
-            UNREACHABLE();
-            break;
-        case NPadControllerType::ProController:
-            if (sixaxis_sensors_enabled && motions[i][0]) {
-                full_sixaxis_entry.accel = motion_devices[0].accel;
-                full_sixaxis_entry.gyro = motion_devices[0].gyro;
-                full_sixaxis_entry.rotation = motion_devices[0].rotation;
-                full_sixaxis_entry.orientation = motion_devices[0].orientation;
-            }
-            break;
-        case NPadControllerType::Handheld:
-            if (sixaxis_sensors_enabled && motions[i][0]) {
-                handheld_sixaxis_entry.accel = motion_devices[0].accel;
-                handheld_sixaxis_entry.gyro = motion_devices[0].gyro;
-                handheld_sixaxis_entry.rotation = motion_devices[0].rotation;
-                handheld_sixaxis_entry.orientation = motion_devices[0].orientation;
-            }
-            break;
-        case NPadControllerType::JoyDual:
-            if (sixaxis_sensors_enabled && motions[i][0]) {
-                // Set motion for the left joycon
-                dual_left_sixaxis_entry.accel = motion_devices[0].accel;
-                dual_left_sixaxis_entry.gyro = motion_devices[0].gyro;
-                dual_left_sixaxis_entry.rotation = motion_devices[0].rotation;
-                dual_left_sixaxis_entry.orientation = motion_devices[0].orientation;
-            }
-            if (sixaxis_sensors_enabled && motions[i][1]) {
-                // Set motion for the right joycon
-                dual_right_sixaxis_entry.accel = motion_devices[1].accel;
-                dual_right_sixaxis_entry.gyro = motion_devices[1].gyro;
-                dual_right_sixaxis_entry.rotation = motion_devices[1].rotation;
-                dual_right_sixaxis_entry.orientation = motion_devices[1].orientation;
-            }
-            break;
-        case NPadControllerType::JoyLeft:
-            if (sixaxis_sensors_enabled && motions[i][0]) {
-                left_sixaxis_entry.accel = motion_devices[0].accel;
-                left_sixaxis_entry.gyro = motion_devices[0].gyro;
-                left_sixaxis_entry.rotation = motion_devices[0].rotation;
-                left_sixaxis_entry.orientation = motion_devices[0].orientation;
-            }
-            break;
-        case NPadControllerType::JoyRight:
-            if (sixaxis_sensors_enabled && motions[i][1]) {
-                right_sixaxis_entry.accel = motion_devices[1].accel;
-                right_sixaxis_entry.gyro = motion_devices[1].gyro;
-                right_sixaxis_entry.rotation = motion_devices[1].rotation;
-                right_sixaxis_entry.orientation = motion_devices[1].orientation;
-            }
-            break;
-        case NPadControllerType::Pokeball:
-            break;
-        }
-    }
-    std::memcpy(data + NPAD_OFFSET, shared_memory_entries.data(),
-                shared_memory_entries.size() * sizeof(NPadEntry));
-}
-
 void Controller_NPad::SetSupportedStyleSet(NPadType style_set) {
     style.raw = style_set.raw;
 }
@@ -658,14 +495,6 @@ Controller_NPad::NpadHoldType Controller_NPad::GetHoldType() const {
     return hold_type;
 }
 
-void Controller_NPad::SetNpadHandheldActivationMode(NpadHandheldActivationMode activation_mode) {
-    handheld_activation_mode = activation_mode;
-}
-
-Controller_NPad::NpadHandheldActivationMode Controller_NPad::GetNpadHandheldActivationMode() const {
-    return handheld_activation_mode;
-}
-
 void Controller_NPad::SetNpadMode(u32 npad_id, NPadAssignments assignment_mode) {
     const std::size_t npad_index = NPadIdToIndex(npad_id);
     ASSERT(npad_index < shared_memory_entries.size());
@@ -674,31 +503,20 @@ void Controller_NPad::SetNpadMode(u32 npad_id, NPadAssignments assignment_mode)
     }
 }
 
-void Controller_NPad::VibrateController(const std::vector<u32>& controllers,
+void Controller_NPad::VibrateController(const std::vector<u32>& controller_ids,
                                         const std::vector<Vibration>& vibrations) {
-    LOG_TRACE(Service_HID, "called");
+    LOG_DEBUG(Service_HID, "(STUBBED) called");
 
     if (!Settings::values.vibration_enabled || !can_controllers_vibrate) {
         return;
     }
-    bool success = true;
-    for (std::size_t i = 0; i < controllers.size(); ++i) {
-        if (!connected_controllers[i].is_connected) {
-            continue;
-        }
-        using namespace Settings::NativeButton;
-        const auto& button_state = buttons[i];
-        if (button_state[A - BUTTON_HID_BEGIN]) {
-            if (button_state[A - BUTTON_HID_BEGIN]->SetRumblePlay(
-                    vibrations[0].amp_high, vibrations[0].amp_low, vibrations[0].freq_high,
-                    vibrations[0].freq_low)) {
-                success = false;
-            }
+    for (std::size_t i = 0; i < controller_ids.size(); i++) {
+        std::size_t controller_pos = NPadIdToIndex(static_cast<u32>(i));
+        if (connected_controllers[controller_pos].is_connected) {
+            // TODO(ogniK): Vibrate the physical controller
         }
     }
-    if (success) {
-        last_processed_vibration = vibrations.back();
-    }
+    last_processed_vibration = vibrations.back();
 }
 
 Controller_NPad::Vibration Controller_NPad::GetLastVibration() const {
@@ -764,14 +582,6 @@ Controller_NPad::GyroscopeZeroDriftMode Controller_NPad::GetGyroscopeZeroDriftMo
     return gyroscope_zero_drift_mode;
 }
 
-bool Controller_NPad::IsSixAxisSensorAtRest() const {
-    return sixaxis_at_rest;
-}
-
-void Controller_NPad::SetSixAxisEnabled(bool six_axis_status) {
-    sixaxis_sensors_enabled = six_axis_status;
-}
-
 void Controller_NPad::MergeSingleJoyAsDualJoy(u32 npad_id_1, u32 npad_id_2) {
     const auto npad_index_1 = NPadIdToIndex(npad_id_1);
     const auto npad_index_2 = NPadIdToIndex(npad_id_2);
@@ -846,15 +656,6 @@ Controller_NPad::LedPattern Controller_NPad::GetLedPattern(u32 npad_id) {
     }
 }
 
-bool Controller_NPad::IsUnintendedHomeButtonInputProtectionEnabled(u32 npad_id) const {
-    return unintended_home_button_input_protection[NPadIdToIndex(npad_id)];
-}
-
-void Controller_NPad::SetUnintendedHomeButtonInputProtectionEnabled(bool is_protection_enabled,
-                                                                    u32 npad_id) {
-    unintended_home_button_input_protection[NPadIdToIndex(npad_id)] = is_protection_enabled;
-}
-
 void Controller_NPad::SetVibrationEnabled(bool can_vibrate) {
     can_controllers_vibrate = can_vibrate;
 }

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

@@ -32,10 +32,6 @@ public:
     // When the controller is requesting an update for the shared memory
     void OnUpdate(const Core::Timing::CoreTiming& core_timing, u8* data, std::size_t size) override;
 
-    // When the controller is requesting a motion update for the shared memory
-    void OnMotionUpdate(const Core::Timing::CoreTiming& core_timing, u8* data,
-                        std::size_t size) override;
-
     // Called when input devices should be loaded
     void OnLoadInputDevices() override;
 
@@ -78,12 +74,6 @@ public:
         Single = 1,
     };
 
-    enum class NpadHandheldActivationMode : u64 {
-        Dual = 0,
-        Single = 1,
-        None = 2,
-    };
-
     enum class NPadControllerType {
         None,
         ProController,
@@ -120,12 +110,9 @@ public:
     void SetHoldType(NpadHoldType joy_hold_type);
     NpadHoldType GetHoldType() const;
 
-    void SetNpadHandheldActivationMode(NpadHandheldActivationMode activation_mode);
-    NpadHandheldActivationMode GetNpadHandheldActivationMode() const;
-
     void SetNpadMode(u32 npad_id, NPadAssignments assignment_mode);
 
-    void VibrateController(const std::vector<u32>& controllers,
+    void VibrateController(const std::vector<u32>& controller_ids,
                            const std::vector<Vibration>& vibrations);
 
     Vibration GetLastVibration() const;
@@ -143,11 +130,7 @@ public:
 
     void SetGyroscopeZeroDriftMode(GyroscopeZeroDriftMode drift_mode);
     GyroscopeZeroDriftMode GetGyroscopeZeroDriftMode() const;
-    bool IsSixAxisSensorAtRest() const;
-    void SetSixAxisEnabled(bool six_axis_status);
     LedPattern GetLedPattern(u32 npad_id);
-    bool IsUnintendedHomeButtonInputProtectionEnabled(u32 npad_id) const;
-    void SetUnintendedHomeButtonInputProtectionEnabled(bool is_protection_enabled, u32 npad_id);
     void SetVibrationEnabled(bool can_vibrate);
     bool IsVibrationEnabled() const;
     void ClearAllConnectedControllers();
@@ -269,24 +252,6 @@ private:
     };
     static_assert(sizeof(NPadGeneric) == 0x350, "NPadGeneric is an invalid size");
 
-    struct SixAxisStates {
-        s64_le timestamp{};
-        INSERT_PADDING_WORDS(2);
-        s64_le timestamp2{};
-        Common::Vec3f accel{};
-        Common::Vec3f gyro{};
-        Common::Vec3f rotation{};
-        std::array<Common::Vec3f, 3> orientation{};
-        s64_le always_one{1};
-    };
-    static_assert(sizeof(SixAxisStates) == 0x68, "SixAxisStates is an invalid size");
-
-    struct SixAxisGeneric {
-        CommonHeader common{};
-        std::array<SixAxisStates, 17> sixaxis{};
-    };
-    static_assert(sizeof(SixAxisGeneric) == 0x708, "SixAxisGeneric is an invalid size");
-
     enum class ColorReadError : u32_le {
         ReadOk = 0,
         ColorDoesntExist = 1,
@@ -316,13 +281,6 @@ private:
         };
     };
 
-    struct MotionDevice {
-        Common::Vec3f accel;
-        Common::Vec3f gyro;
-        Common::Vec3f rotation;
-        std::array<Common::Vec3f, 3> orientation;
-    };
-
     struct NPadEntry {
         NPadType joy_styles;
         NPadAssignments pad_assignment;
@@ -342,12 +300,9 @@ private:
         NPadGeneric pokeball_states;
         NPadGeneric libnx; // TODO(ogniK): Find out what this actually is, libnx seems to only be
                            // relying on this for the time being
-        SixAxisGeneric sixaxis_full;
-        SixAxisGeneric sixaxis_handheld;
-        SixAxisGeneric sixaxis_dual_left;
-        SixAxisGeneric sixaxis_dual_right;
-        SixAxisGeneric sixaxis_left;
-        SixAxisGeneric sixaxis_right;
+        INSERT_PADDING_BYTES(
+            0x708 *
+            6); // TODO(ogniK): SixAxis states, require more information before implementation
         NPadDevice device_type;
         NPadProperties properties;
         INSERT_PADDING_WORDS(1);
@@ -370,30 +325,22 @@ private:
 
     NPadType style{};
     std::array<NPadEntry, 10> shared_memory_entries{};
-    using ButtonArray = std::array<
+    std::array<
         std::array<std::unique_ptr<Input::ButtonDevice>, Settings::NativeButton::NUM_BUTTONS_HID>,
-        10>;
-    using StickArray = std::array<
+        10>
+        buttons;
+    std::array<
         std::array<std::unique_ptr<Input::AnalogDevice>, Settings::NativeAnalog::NUM_STICKS_HID>,
-        10>;
-    using MotionArray = std::array<
-        std::array<std::unique_ptr<Input::MotionDevice>, Settings::NativeMotion::NUM_MOTION_HID>,
-        10>;
-    ButtonArray buttons;
-    StickArray sticks;
-    MotionArray motions;
+        10>
+        sticks;
     std::vector<u32> supported_npad_id_types{};
     NpadHoldType hold_type{NpadHoldType::Vertical};
-    NpadHandheldActivationMode handheld_activation_mode{NpadHandheldActivationMode::Dual};
     // Each controller should have their own styleset changed event
     std::array<Kernel::EventPair, 10> styleset_changed_events;
     Vibration last_processed_vibration{};
     std::array<ControllerHolder, 10> connected_controllers{};
-    std::array<bool, 10> unintended_home_button_input_protection{};
     GyroscopeZeroDriftMode gyroscope_zero_drift_mode{GyroscopeZeroDriftMode::Standard};
     bool can_controllers_vibrate{true};
-    bool sixaxis_sensors_enabled{true};
-    bool sixaxis_at_rest{true};
     std::array<ControllerPad, 10> npad_pad_states{};
     bool is_in_lr_assignment_mode{false};
     Core::System& system;

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

@@ -40,8 +40,7 @@ namespace Service::HID {
 // Updating period for each HID device.
 // HID is polled every 15ms, this value was derived from
 // https://github.com/dekuNukem/Nintendo_Switch_Reverse_Engineering#joy-con-status-data-packet
-constexpr auto pad_update_ns = std::chrono::nanoseconds{1000 * 1000};         // (1ms, 1000Hz)
-constexpr auto motion_update_ns = std::chrono::nanoseconds{15 * 1000 * 1000}; // (15ms, 66.666Hz)
+constexpr auto pad_update_ns = std::chrono::nanoseconds{15 * 1000 * 1000}; // (15ms, 66.6Hz)
 constexpr std::size_t SHARED_MEMORY_SIZE = 0x40000;
 
 IAppletResource::IAppletResource(Core::System& system)
@@ -80,14 +79,10 @@ IAppletResource::IAppletResource(Core::System& system)
         [this](std::uintptr_t user_data, std::chrono::nanoseconds ns_late) {
             UpdateControllers(user_data, ns_late);
         });
-    motion_update_event = Core::Timing::CreateEvent(
-        "HID::MotionPadCallback",
-        [this](std::uintptr_t user_data, std::chrono::nanoseconds ns_late) {
-            UpdateMotion(user_data, ns_late);
-        });
+
+    // TODO(shinyquagsire23): Other update callbacks? (accel, gyro?)
 
     system.CoreTiming().ScheduleEvent(pad_update_ns, pad_update_event);
-    system.CoreTiming().ScheduleEvent(motion_update_ns, motion_update_event);
 
     ReloadInputDevices();
 }
@@ -127,16 +122,6 @@ void IAppletResource::UpdateControllers(std::uintptr_t user_data,
     core_timing.ScheduleEvent(pad_update_ns - ns_late, pad_update_event);
 }
 
-void IAppletResource::UpdateMotion(std::uintptr_t user_data, std::chrono::nanoseconds ns_late) {
-    auto& core_timing = system.CoreTiming();
-
-    for (const auto& controller : controllers) {
-        controller->OnMotionUpdate(core_timing, shared_mem->GetPointer(), SHARED_MEMORY_SIZE);
-    }
-
-    core_timing.ScheduleEvent(motion_update_ns - ns_late, motion_update_event);
-}
-
 class IActiveVibrationDeviceList final : public ServiceFramework<IActiveVibrationDeviceList> {
 public:
     IActiveVibrationDeviceList() : ServiceFramework("IActiveVibrationDeviceList") {
@@ -179,8 +164,8 @@ Hid::Hid(Core::System& system) : ServiceFramework("hid"), system(system) {
         {56, nullptr, "ActivateJoyXpad"},
         {58, nullptr, "GetJoyXpadLifoHandle"},
         {59, nullptr, "GetJoyXpadIds"},
-        {60, &Hid::ActivateSixAxisSensor, "ActivateSixAxisSensor"},
-        {61, &Hid::DeactivateSixAxisSensor, "DeactivateSixAxisSensor"},
+        {60, nullptr, "ActivateSixAxisSensor"},
+        {61, nullptr, "DeactivateSixAxisSensor"},
         {62, nullptr, "GetSixAxisSensorLifoHandle"},
         {63, nullptr, "ActivateJoySixAxisSensor"},
         {64, nullptr, "DeactivateJoySixAxisSensor"},
@@ -188,7 +173,7 @@ Hid::Hid(Core::System& system) : ServiceFramework("hid"), system(system) {
         {66, &Hid::StartSixAxisSensor, "StartSixAxisSensor"},
         {67, &Hid::StopSixAxisSensor, "StopSixAxisSensor"},
         {68, nullptr, "IsSixAxisSensorFusionEnabled"},
-        {69, &Hid::EnableSixAxisSensorFusion, "EnableSixAxisSensorFusion"},
+        {69, nullptr, "EnableSixAxisSensorFusion"},
         {70, nullptr, "SetSixAxisSensorFusionParameters"},
         {71, nullptr, "GetSixAxisSensorFusionParameters"},
         {72, nullptr, "ResetSixAxisSensorFusionParameters"},
@@ -224,8 +209,8 @@ Hid::Hid(Core::System& system) : ServiceFramework("hid"), system(system) {
         {128, &Hid::SetNpadHandheldActivationMode, "SetNpadHandheldActivationMode"},
         {129, &Hid::GetNpadHandheldActivationMode, "GetNpadHandheldActivationMode"},
         {130, &Hid::SwapNpadAssignment, "SwapNpadAssignment"},
-        {131, &Hid::IsUnintendedHomeButtonInputProtectionEnabled, "IsUnintendedHomeButtonInputProtectionEnabled"},
-        {132, &Hid::EnableUnintendedHomeButtonInputProtection, "EnableUnintendedHomeButtonInputProtection"},
+        {131, nullptr, "IsUnintendedHomeButtonInputProtectionEnabled"},
+        {132, nullptr, "EnableUnintendedHomeButtonInputProtection"},
         {133, nullptr, "SetNpadJoyAssignmentModeSingleWithDestination"},
         {134, nullptr, "SetNpadAnalogStickUseCenterClamp"},
         {135, nullptr, "SetNpadCaptureButtonAssignment"},
@@ -344,31 +329,6 @@ void Hid::GetXpadIDs(Kernel::HLERequestContext& ctx) {
     rb.Push(0);
 }
 
-void Hid::ActivateSixAxisSensor(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto handle{rp.Pop<u32>()};
-    const auto applet_resource_user_id{rp.Pop<u64>()};
-    applet_resource->GetController<Controller_NPad>(HidController::NPad).SetSixAxisEnabled(true);
-    LOG_DEBUG(Service_HID, "called, handle={}, applet_resource_user_id={}", handle,
-              applet_resource_user_id);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
-void Hid::DeactivateSixAxisSensor(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto handle{rp.Pop<u32>()};
-    const auto applet_resource_user_id{rp.Pop<u64>()};
-    applet_resource->GetController<Controller_NPad>(HidController::NPad).SetSixAxisEnabled(false);
-
-    LOG_DEBUG(Service_HID, "called, handle={}, applet_resource_user_id={}", handle,
-              applet_resource_user_id);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
 void Hid::ActivateDebugPad(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const auto applet_resource_user_id{rp.Pop<u64>()};
@@ -473,19 +433,6 @@ void Hid::StopSixAxisSensor(Kernel::HLERequestContext& ctx) {
     rb.Push(RESULT_SUCCESS);
 }
 
-void Hid::EnableSixAxisSensorFusion(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto enable{rp.Pop<bool>()};
-    const auto handle{rp.Pop<u32>()};
-    const auto applet_resource_user_id{rp.Pop<u64>()};
-
-    LOG_WARNING(Service_HID, "(STUBBED) called, handle={}, applet_resource_user_id={}", handle,
-                applet_resource_user_id);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
 void Hid::SetGyroscopeZeroDriftMode(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const auto handle{rp.Pop<u32>()};
@@ -537,13 +484,13 @@ void Hid::IsSixAxisSensorAtRest(Kernel::HLERequestContext& ctx) {
     const auto handle{rp.Pop<u32>()};
     const auto applet_resource_user_id{rp.Pop<u64>()};
 
-    LOG_DEBUG(Service_HID, "called, handle={}, applet_resource_user_id={}", handle,
-              applet_resource_user_id);
+    LOG_WARNING(Service_HID, "(STUBBED) called, handle={}, applet_resource_user_id={}", handle,
+                applet_resource_user_id);
 
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
-    rb.Push(applet_resource->GetController<Controller_NPad>(HidController::NPad)
-                .IsSixAxisSensorAtRest());
+    // TODO (Hexagon12): Properly implement reading gyroscope values from controllers.
+    rb.Push(true);
 }
 
 void Hid::SetSupportedNpadStyleSet(Kernel::HLERequestContext& ctx) {
@@ -767,11 +714,8 @@ void Hid::SetNpadHandheldActivationMode(Kernel::HLERequestContext& ctx) {
     const auto applet_resource_user_id{rp.Pop<u64>()};
     const auto mode{rp.Pop<u64>()};
 
-    LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}, mode={}", applet_resource_user_id,
-              mode);
-
-    applet_resource->GetController<Controller_NPad>(HidController::NPad)
-        .SetNpadHandheldActivationMode(Controller_NPad::NpadHandheldActivationMode{mode});
+    LOG_WARNING(Service_HID, "(STUBBED) called, applet_resource_user_id={}, mode={}",
+                applet_resource_user_id, mode);
 
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
@@ -781,13 +725,11 @@ void Hid::GetNpadHandheldActivationMode(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const auto applet_resource_user_id{rp.Pop<u64>()};
 
-    LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
+    LOG_WARNING(Service_HID, "(STUBBED) called, applet_resource_user_id={}",
+                applet_resource_user_id);
 
-    IPC::ResponseBuilder rb{ctx, 4};
+    IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
-    rb.Push<u64>(
-        static_cast<u64>(applet_resource->GetController<Controller_NPad>(HidController::NPad)
-                             .GetNpadHandheldActivationMode()));
 }
 
 void Hid::SwapNpadAssignment(Kernel::HLERequestContext& ctx) {
@@ -809,40 +751,6 @@ void Hid::SwapNpadAssignment(Kernel::HLERequestContext& ctx) {
     }
 }
 
-void Hid::IsUnintendedHomeButtonInputProtectionEnabled(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto npad_id{rp.Pop<u32>()};
-    const auto applet_resource_user_id{rp.Pop<u64>()};
-
-    LOG_WARNING(Service_HID, "(STUBBED) called, npad_id={}, applet_resource_user_id={}", npad_id,
-                applet_resource_user_id);
-
-    auto& controller = applet_resource->GetController<Controller_NPad>(HidController::NPad);
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<bool>(controller.IsUnintendedHomeButtonInputProtectionEnabled(npad_id));
-}
-
-void Hid::EnableUnintendedHomeButtonInputProtection(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto unintended_home_button_input_protection{rp.Pop<bool>()};
-    const auto npad_id{rp.Pop<u32>()};
-    const auto applet_resource_user_id{rp.Pop<u64>()};
-
-    LOG_WARNING(Service_HID,
-                "(STUBBED) called, unintended_home_button_input_protection={}, npad_id={},"
-                "applet_resource_user_id={}",
-                npad_id, unintended_home_button_input_protection, applet_resource_user_id);
-
-    auto& controller = applet_resource->GetController<Controller_NPad>(HidController::NPad);
-    controller.SetUnintendedHomeButtonInputProtectionEnabled(
-        unintended_home_button_input_protection, npad_id);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
 void Hid::BeginPermitVibrationSession(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const auto applet_resource_user_id{rp.Pop<u64>()};
@@ -864,18 +772,18 @@ void Hid::EndPermitVibrationSession(Kernel::HLERequestContext& ctx) {
 
 void Hid::SendVibrationValue(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    const auto controller{rp.Pop<u32>()};
+    const auto controller_id{rp.Pop<u32>()};
     const auto vibration_values{rp.PopRaw<Controller_NPad::Vibration>()};
     const auto applet_resource_user_id{rp.Pop<u64>()};
 
-    LOG_DEBUG(Service_HID, "called, controller={}, applet_resource_user_id={}", controller,
+    LOG_DEBUG(Service_HID, "called, controller_id={}, applet_resource_user_id={}", controller_id,
               applet_resource_user_id);
 
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
 
     applet_resource->GetController<Controller_NPad>(HidController::NPad)
-        .VibrateController({controller}, {vibration_values});
+        .VibrateController({controller_id}, {vibration_values});
 }
 
 void Hid::SendVibrationValues(Kernel::HLERequestContext& ctx) {
@@ -893,6 +801,8 @@ void Hid::SendVibrationValues(Kernel::HLERequestContext& ctx) {
 
     std::memcpy(controller_list.data(), controllers.data(), controllers.size());
     std::memcpy(vibration_list.data(), vibrations.data(), vibrations.size());
+    std::transform(controller_list.begin(), controller_list.end(), controller_list.begin(),
+                   [](u32 controller_id) { return controller_id - 3; });
 
     applet_resource->GetController<Controller_NPad>(HidController::NPad)
         .VibrateController(controller_list, vibration_list);

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

@@ -65,12 +65,10 @@ private:
 
     void GetSharedMemoryHandle(Kernel::HLERequestContext& ctx);
     void UpdateControllers(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
-    void UpdateMotion(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
 
     std::shared_ptr<Kernel::SharedMemory> shared_mem;
 
     std::shared_ptr<Core::Timing::EventType> pad_update_event;
-    std::shared_ptr<Core::Timing::EventType> motion_update_event;
     Core::System& system;
 
     std::array<std::unique_ptr<ControllerBase>, static_cast<size_t>(HidController::MaxControllers)>
@@ -88,8 +86,6 @@ private:
     void CreateAppletResource(Kernel::HLERequestContext& ctx);
     void ActivateXpad(Kernel::HLERequestContext& ctx);
     void GetXpadIDs(Kernel::HLERequestContext& ctx);
-    void ActivateSixAxisSensor(Kernel::HLERequestContext& ctx);
-    void DeactivateSixAxisSensor(Kernel::HLERequestContext& ctx);
     void ActivateDebugPad(Kernel::HLERequestContext& ctx);
     void ActivateTouchScreen(Kernel::HLERequestContext& ctx);
     void ActivateMouse(Kernel::HLERequestContext& ctx);
@@ -99,7 +95,6 @@ private:
     void ActivateNpadWithRevision(Kernel::HLERequestContext& ctx);
     void StartSixAxisSensor(Kernel::HLERequestContext& ctx);
     void StopSixAxisSensor(Kernel::HLERequestContext& ctx);
-    void EnableSixAxisSensorFusion(Kernel::HLERequestContext& ctx);
     void SetGyroscopeZeroDriftMode(Kernel::HLERequestContext& ctx);
     void GetGyroscopeZeroDriftMode(Kernel::HLERequestContext& ctx);
     void ResetGyroscopeZeroDriftMode(Kernel::HLERequestContext& ctx);
@@ -123,8 +118,6 @@ private:
     void SetNpadHandheldActivationMode(Kernel::HLERequestContext& ctx);
     void GetNpadHandheldActivationMode(Kernel::HLERequestContext& ctx);
     void SwapNpadAssignment(Kernel::HLERequestContext& ctx);
-    void IsUnintendedHomeButtonInputProtectionEnabled(Kernel::HLERequestContext& ctx);
-    void EnableUnintendedHomeButtonInputProtection(Kernel::HLERequestContext& ctx);
     void BeginPermitVibrationSession(Kernel::HLERequestContext& ctx);
     void EndPermitVibrationSession(Kernel::HLERequestContext& ctx);
     void SendVibrationValue(Kernel::HLERequestContext& ctx);

src/core/hle/service/nfp/nfp.cpp

@@ -2,7 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <array>
 #include <atomic>
 
 #include "common/logging/log.h"
@@ -73,10 +72,10 @@ private:
         std::array<u8, 10> uuid;
         u8 uuid_length; // TODO(ogniK): Figure out if this is actual the uuid length or does it
                         // mean something else
-        std::array<u8, 0x15> padding_1;
+        INSERT_PADDING_BYTES(0x15);
         u32_le protocol;
         u32_le tag_type;
-        std::array<u8, 0x2c> padding_2;
+        INSERT_PADDING_BYTES(0x2c);
     };
     static_assert(sizeof(TagInfo) == 0x54, "TagInfo is an invalid size");
 
@@ -214,15 +213,13 @@ private:
         LOG_DEBUG(Service_NFP, "called");
 
         IPC::ResponseBuilder rb{ctx, 2};
-        const auto& amiibo = nfp_interface.GetAmiiboBuffer();
-        const TagInfo tag_info{
-            .uuid = amiibo.uuid,
-            .uuid_length = static_cast<u8>(tag_info.uuid.size()),
-            .padding_1 = {},
-            .protocol = 1, // TODO(ogniK): Figure out actual values
-            .tag_type = 2,
-            .padding_2 = {},
-        };
+        auto amiibo = nfp_interface.GetAmiiboBuffer();
+        TagInfo tag_info{};
+        tag_info.uuid = amiibo.uuid;
+        tag_info.uuid_length = static_cast<u8>(tag_info.uuid.size());
+
+        tag_info.protocol = 1; // TODO(ogniK): Figure out actual values
+        tag_info.tag_type = 2;
         ctx.WriteBuffer(tag_info);
         rb.Push(RESULT_SUCCESS);
     }
@@ -239,7 +236,7 @@ private:
         LOG_DEBUG(Service_NFP, "called");
 
         IPC::ResponseBuilder rb{ctx, 2};
-        const auto& amiibo = nfp_interface.GetAmiiboBuffer();
+        auto amiibo = nfp_interface.GetAmiiboBuffer();
         ctx.WriteBuffer(amiibo.model_info);
         rb.Push(RESULT_SUCCESS);
     }

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

@@ -265,7 +265,7 @@ std::optional<nvhost_as_gpu::BufferMap> nvhost_as_gpu::FindBufferMap(GPUVAddr gp
         }
     }
 
-    return std::nullopt;
+    return {};
 }
 
 void nvhost_as_gpu::AddBufferMap(GPUVAddr gpu_addr, std::size_t size, VAddr cpu_addr,
@@ -286,7 +286,7 @@ std::optional<std::size_t> nvhost_as_gpu::RemoveBufferMap(GPUVAddr gpu_addr) {
         return size;
     }
 
-    return std::nullopt;
+    return {};
 }
 
 } // namespace Service::Nvidia::Devices

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

@@ -54,7 +54,7 @@ struct EventInterface {
             }
             mask = mask >> 1;
         }
-        return std::nullopt;
+        return {};
     }
     void SetEventStatus(const u32 event_id, EventState new_status) {
         EventState old_status = status[event_id];

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

@@ -114,7 +114,7 @@ std::optional<u64> NVFlinger::OpenDisplay(std::string_view name) {
                      [&](const VI::Display& display) { return display.GetName() == name; });
 
     if (itr == displays.end()) {
-        return std::nullopt;
+        return {};
     }
 
     return itr->GetID();
@@ -124,7 +124,7 @@ std::optional<u64> NVFlinger::CreateLayer(u64 display_id) {
     auto* const display = FindDisplay(display_id);
 
     if (display == nullptr) {
-        return std::nullopt;
+        return {};
     }
 
     const u64 layer_id = next_layer_id++;
@@ -144,7 +144,7 @@ std::optional<u32> NVFlinger::FindBufferQueueId(u64 display_id, u64 layer_id) co
     const auto* const layer = FindLayer(display_id, layer_id);
 
     if (layer == nullptr) {
-        return std::nullopt;
+        return {};
     }
 
     return layer->GetBufferQueue().GetId();

src/core/hle/service/service.cpp

@@ -89,6 +89,8 @@ namespace Service {
     return function_string;
 }
 
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 ServiceFrameworkBase::ServiceFrameworkBase(const char* service_name, u32 max_sessions,
                                            InvokerFn* handler_invoker)
     : service_name(service_name), max_sessions(max_sessions), handler_invoker(handler_invoker) {}
@@ -103,9 +105,10 @@ void ServiceFrameworkBase::InstallAsService(SM::ServiceManager& service_manager)
     port_installed = true;
 }
 
-void ServiceFrameworkBase::InstallAsNamedPort(Kernel::KernelCore& kernel) {
+void ServiceFrameworkBase::InstallAsNamedPort() {
     ASSERT(!port_installed);
 
+    auto& kernel = Core::System::GetInstance().Kernel();
     auto [server_port, client_port] =
         Kernel::ServerPort::CreatePortPair(kernel, max_sessions, service_name);
     server_port->SetHleHandler(shared_from_this());
@@ -113,9 +116,10 @@ void ServiceFrameworkBase::InstallAsNamedPort(Kernel::KernelCore& kernel) {
     port_installed = true;
 }
 
-std::shared_ptr<Kernel::ClientPort> ServiceFrameworkBase::CreatePort(Kernel::KernelCore& kernel) {
+std::shared_ptr<Kernel::ClientPort> ServiceFrameworkBase::CreatePort() {
     ASSERT(!port_installed);
 
+    auto& kernel = Core::System::GetInstance().Kernel();
     auto [server_port, client_port] =
         Kernel::ServerPort::CreatePortPair(kernel, max_sessions, service_name);
     auto port = MakeResult(std::move(server_port)).Unwrap();
@@ -187,6 +191,9 @@ ResultCode ServiceFrameworkBase::HandleSyncRequest(Kernel::HLERequestContext& co
     return RESULT_SUCCESS;
 }
 
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Module interface
+
 /// Initialize ServiceManager
 void Init(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system) {
     // NVFlinger needs to be accessed by several services like Vi and AppletOE so we instantiate it

src/core/hle/service/service.h

@@ -63,9 +63,9 @@ public:
     /// Creates a port pair and registers this service with the given ServiceManager.
     void InstallAsService(SM::ServiceManager& service_manager);
     /// Creates a port pair and registers it on the kernel's global port registry.
-    void InstallAsNamedPort(Kernel::KernelCore& kernel);
+    void InstallAsNamedPort();
     /// Creates and returns an unregistered port for the service.
-    std::shared_ptr<Kernel::ClientPort> CreatePort(Kernel::KernelCore& kernel);
+    std::shared_ptr<Kernel::ClientPort> CreatePort();
 
     void InvokeRequest(Kernel::HLERequestContext& ctx);
 

src/core/hle/service/sm/sm.cpp

@@ -19,7 +19,7 @@ constexpr ResultCode ERR_ALREADY_REGISTERED(ErrorModule::SM, 4);
 constexpr ResultCode ERR_INVALID_NAME(ErrorModule::SM, 6);
 constexpr ResultCode ERR_SERVICE_NOT_REGISTERED(ErrorModule::SM, 7);
 
-ServiceManager::ServiceManager(Kernel::KernelCore& kernel_) : kernel{kernel_} {}
+ServiceManager::ServiceManager() = default;
 ServiceManager::~ServiceManager() = default;
 
 void ServiceManager::InvokeControlRequest(Kernel::HLERequestContext& context) {
@@ -27,11 +27,11 @@ void ServiceManager::InvokeControlRequest(Kernel::HLERequestContext& context) {
 }
 
 static ResultCode ValidateServiceName(const std::string& name) {
-    if (name.empty() || name.size() > 8) {
+    if (name.size() <= 0 || name.size() > 8) {
         LOG_ERROR(Service_SM, "Invalid service name! service={}", name);
         return ERR_INVALID_NAME;
     }
-    if (name.rfind('\0') != std::string::npos) {
+    if (name.find('\0') != std::string::npos) {
         LOG_ERROR(Service_SM, "A non null terminated service was passed");
         return ERR_INVALID_NAME;
     }
@@ -43,13 +43,13 @@ void ServiceManager::InstallInterfaces(std::shared_ptr<ServiceManager> self,
     ASSERT(self->sm_interface.expired());
 
     auto sm = std::make_shared<SM>(self, kernel);
-    sm->InstallAsNamedPort(kernel);
+    sm->InstallAsNamedPort();
     self->sm_interface = sm;
     self->controller_interface = std::make_unique<Controller>();
 }
 
-ResultVal<std::shared_ptr<Kernel::ServerPort>> ServiceManager::RegisterService(std::string name,
-                                                                               u32 max_sessions) {
+ResultVal<std::shared_ptr<Kernel::ServerPort>> ServiceManager::RegisterService(
+    std::string name, unsigned int max_sessions) {
 
     CASCADE_CODE(ValidateServiceName(name));
 
@@ -58,6 +58,7 @@ ResultVal<std::shared_ptr<Kernel::ServerPort>> ServiceManager::RegisterService(s
         return ERR_ALREADY_REGISTERED;
     }
 
+    auto& kernel = Core::System::GetInstance().Kernel();
     auto [server_port, client_port] =
         Kernel::ServerPort::CreatePortPair(kernel, max_sessions, name);
 

src/core/hle/service/sm/sm.h

@@ -48,11 +48,11 @@ class ServiceManager {
 public:
     static void InstallInterfaces(std::shared_ptr<ServiceManager> self, Kernel::KernelCore& kernel);
 
-    explicit ServiceManager(Kernel::KernelCore& kernel_);
+    ServiceManager();
     ~ServiceManager();
 
     ResultVal<std::shared_ptr<Kernel::ServerPort>> RegisterService(std::string name,
-                                                                   u32 max_sessions);
+                                                                   unsigned int max_sessions);
     ResultCode UnregisterService(const std::string& name);
     ResultVal<std::shared_ptr<Kernel::ClientPort>> GetServicePort(const std::string& name);
     ResultVal<std::shared_ptr<Kernel::ClientSession>> ConnectToService(const std::string& name);
@@ -79,9 +79,6 @@ private:
 
     /// Map of registered services, retrieved using GetServicePort or ConnectToService.
     std::unordered_map<std::string, std::shared_ptr<Kernel::ClientPort>> registered_services;
-
-    /// Kernel context
-    Kernel::KernelCore& kernel;
 };
 
 } // namespace Service::SM

src/core/hle/service/sockets/bsd.cpp

@@ -497,7 +497,7 @@ std::pair<s32, Errno> BSD::PollImpl(std::vector<u8>& write_buffer, std::vector<u
             return {0, Errno::SUCCESS};
         }
 
-        const std::optional<FileDescriptor>& descriptor = file_descriptors[pollfd.fd];
+        std::optional<FileDescriptor>& descriptor = file_descriptors[pollfd.fd];
         if (!descriptor) {
             LOG_ERROR(Service, "File descriptor handle={} is not allocated", pollfd.fd);
             pollfd.revents = POLL_NVAL;

src/core/loader/deconstructed_rom_directory.cpp

@@ -89,7 +89,7 @@ FileType AppLoader_DeconstructedRomDirectory::IdentifyType(const FileSys::Virtua
 }
 
 AppLoader_DeconstructedRomDirectory::LoadResult AppLoader_DeconstructedRomDirectory::Load(
-    Kernel::Process& process, Core::System& system) {
+    Kernel::Process& process) {
     if (is_loaded) {
         return {ResultStatus::ErrorAlreadyLoaded, {}};
     }
@@ -141,9 +141,9 @@ AppLoader_DeconstructedRomDirectory::LoadResult AppLoader_DeconstructedRomDirect
             continue;
         }
 
-        const bool should_pass_arguments = std::strcmp(module, "rtld") == 0;
-        const auto tentative_next_load_addr = AppLoader_NSO::LoadModule(
-            process, system, *module_file, code_size, should_pass_arguments, false);
+        const bool should_pass_arguments{std::strcmp(module, "rtld") == 0};
+        const auto tentative_next_load_addr{AppLoader_NSO::LoadModule(
+            process, *module_file, code_size, should_pass_arguments, false)};
         if (!tentative_next_load_addr) {
             return {ResultStatus::ErrorLoadingNSO, {}};
         }
@@ -168,9 +168,9 @@ AppLoader_DeconstructedRomDirectory::LoadResult AppLoader_DeconstructedRomDirect
         }
 
         const VAddr load_addr{next_load_addr};
-        const bool should_pass_arguments = std::strcmp(module, "rtld") == 0;
-        const auto tentative_next_load_addr = AppLoader_NSO::LoadModule(
-            process, system, *module_file, load_addr, should_pass_arguments, true, pm);
+        const bool should_pass_arguments{std::strcmp(module, "rtld") == 0};
+        const auto tentative_next_load_addr{AppLoader_NSO::LoadModule(
+            process, *module_file, load_addr, should_pass_arguments, true, pm)};
         if (!tentative_next_load_addr) {
             return {ResultStatus::ErrorLoadingNSO, {}};
         }
@@ -192,8 +192,8 @@ AppLoader_DeconstructedRomDirectory::LoadResult AppLoader_DeconstructedRomDirect
     // Register the RomFS if a ".romfs" file was found
     if (romfs_iter != files.end() && *romfs_iter != nullptr) {
         romfs = *romfs_iter;
-        system.GetFileSystemController().RegisterRomFS(std::make_unique<FileSys::RomFSFactory>(
-            *this, system.GetContentProvider(), system.GetFileSystemController()));
+        Core::System::GetInstance().GetFileSystemController().RegisterRomFS(
+            std::make_unique<FileSys::RomFSFactory>(*this));
     }
 
     is_loaded = true;

src/core/loader/deconstructed_rom_directory.h

@@ -9,10 +9,6 @@
 #include "core/file_sys/program_metadata.h"
 #include "core/loader/loader.h"
 
-namespace Core {
-class System;
-}
-
 namespace Loader {
 
 /**
@@ -41,7 +37,7 @@ public:
         return IdentifyType(file);
     }
 
-    LoadResult Load(Kernel::Process& process, Core::System& system) override;
+    LoadResult Load(Kernel::Process& process) override;
 
     ResultStatus ReadRomFS(FileSys::VirtualFile& dir) override;
     ResultStatus ReadIcon(std::vector<u8>& buffer) override;

src/core/loader/elf.cpp

@@ -383,8 +383,7 @@ FileType AppLoader_ELF::IdentifyType(const FileSys::VirtualFile& file) {
     return FileType::Error;
 }
 
-AppLoader_ELF::LoadResult AppLoader_ELF::Load(Kernel::Process& process,
-                                              [[maybe_unused]] Core::System& system) {
+AppLoader_ELF::LoadResult AppLoader_ELF::Load(Kernel::Process& process) {
     if (is_loaded) {
         return {ResultStatus::ErrorAlreadyLoaded, {}};
     }

src/core/loader/elf.h

@@ -8,10 +8,6 @@
 #include "common/common_types.h"
 #include "core/loader/loader.h"
 
-namespace Core {
-class System;
-}
-
 namespace Loader {
 
 /// Loads an ELF/AXF file
@@ -30,7 +26,7 @@ public:
         return IdentifyType(file);
     }
 
-    LoadResult Load(Kernel::Process& process, Core::System& system) override;
+    LoadResult Load(Kernel::Process& process) override;
 };
 
 } // namespace Loader

src/core/loader/kip.cpp

@@ -43,8 +43,7 @@ FileType AppLoader_KIP::GetFileType() const {
                                                                          : FileType::Error;
 }
 
-AppLoader::LoadResult AppLoader_KIP::Load(Kernel::Process& process,
-                                          [[maybe_unused]] Core::System& system) {
+AppLoader::LoadResult AppLoader_KIP::Load(Kernel::Process& process) {
     if (is_loaded) {
         return {ResultStatus::ErrorAlreadyLoaded, {}};
     }

src/core/loader/kip.h

@@ -6,10 +6,6 @@
 
 #include "core/loader/loader.h"
 
-namespace Core {
-class System;
-}
-
 namespace FileSys {
 class KIP;
 }
@@ -30,7 +26,7 @@ public:
 
     FileType GetFileType() const override;
 
-    LoadResult Load(Kernel::Process& process, Core::System& system) override;
+    LoadResult Load(Kernel::Process& process) override;
 
 private:
     std::unique_ptr<FileSys::KIP> kip;

src/core/loader/loader.h

@@ -15,10 +15,6 @@
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/vfs.h"
 
-namespace Core {
-class System;
-}
-
 namespace FileSys {
 class NACP;
 } // namespace FileSys
@@ -158,10 +154,9 @@ public:
     /**
      * Load the application and return the created Process instance
      * @param process The newly created process.
-     * @param system  The system that this process is being loaded under.
      * @return The status result of the operation.
      */
-    virtual LoadResult Load(Kernel::Process& process, Core::System& system) = 0;
+    virtual LoadResult Load(Kernel::Process& process) = 0;
 
     /**
      * Get the code (typically .code section) of the application

src/core/loader/nax.cpp

@@ -41,8 +41,7 @@ FileType AppLoader_NAX::GetFileType() const {
     return IdentifyTypeImpl(*nax);
 }
 
-AppLoader_NAX::LoadResult AppLoader_NAX::Load(Kernel::Process& process,
-                                              [[maybe_unused]] Core::System& system) {
+AppLoader_NAX::LoadResult AppLoader_NAX::Load(Kernel::Process& process) {
     if (is_loaded) {
         return {ResultStatus::ErrorAlreadyLoaded, {}};
     }
@@ -66,7 +65,7 @@ AppLoader_NAX::LoadResult AppLoader_NAX::Load(Kernel::Process& process,
         return {nca_status, {}};
     }
 
-    const auto result = nca_loader->Load(process, system);
+    const auto result = nca_loader->Load(process);
     if (result.first != ResultStatus::Success) {
         return result;
     }

src/core/loader/nax.h

@@ -8,12 +8,10 @@
 #include "common/common_types.h"
 #include "core/loader/loader.h"
 
-namespace Core {
-class System;
-}
-
 namespace FileSys {
+
 class NAX;
+
 } // namespace FileSys
 
 namespace Loader {
@@ -35,7 +33,7 @@ public:
 
     FileType GetFileType() const override;
 
-    LoadResult Load(Kernel::Process& process, Core::System& system) override;
+    LoadResult Load(Kernel::Process& process) override;
 
     ResultStatus ReadRomFS(FileSys::VirtualFile& dir) override;
     u64 ReadRomFSIVFCOffset() const override;

src/core/loader/nca.cpp

@@ -31,7 +31,7 @@ FileType AppLoader_NCA::IdentifyType(const FileSys::VirtualFile& file) {
     return FileType::Error;
 }
 
-AppLoader_NCA::LoadResult AppLoader_NCA::Load(Kernel::Process& process, Core::System& system) {
+AppLoader_NCA::LoadResult AppLoader_NCA::Load(Kernel::Process& process) {
     if (is_loaded) {
         return {ResultStatus::ErrorAlreadyLoaded, {}};
     }
@@ -52,14 +52,14 @@ AppLoader_NCA::LoadResult AppLoader_NCA::Load(Kernel::Process& process, Core::Sy
 
     directory_loader = std::make_unique<AppLoader_DeconstructedRomDirectory>(exefs, true);
 
-    const auto load_result = directory_loader->Load(process, system);
+    const auto load_result = directory_loader->Load(process);
     if (load_result.first != ResultStatus::Success) {
         return load_result;
     }
 
     if (nca->GetRomFS() != nullptr && nca->GetRomFS()->GetSize() > 0) {
-        system.GetFileSystemController().RegisterRomFS(std::make_unique<FileSys::RomFSFactory>(
-            *this, system.GetContentProvider(), system.GetFileSystemController()));
+        Core::System::GetInstance().GetFileSystemController().RegisterRomFS(
+            std::make_unique<FileSys::RomFSFactory>(*this));
     }
 
     is_loaded = true;

src/core/loader/nca.h

@@ -8,10 +8,6 @@
 #include "core/file_sys/vfs.h"
 #include "core/loader/loader.h"
 
-namespace Core {
-class System;
-}
-
 namespace FileSys {
 class NCA;
 }
@@ -37,7 +33,7 @@ public:
         return IdentifyType(file);
     }
 
-    LoadResult Load(Kernel::Process& process, Core::System& system) override;
+    LoadResult Load(Kernel::Process& process) override;
 
     ResultStatus ReadRomFS(FileSys::VirtualFile& dir) override;
     u64 ReadRomFSIVFCOffset() const override;