Add a message about SRGBA -> RGBA conversion

kernel/timer: Make data members private where applicable

.gitignore

@@ -11,7 +11,7 @@ src/common/scm_rev.cpp
 .idea/
 .vs/
 .vscode/
-CMakeLists.txt.user
+CMakeLists.txt.user*
 
 # *nix related
 # Common convention for backup or temporary files

src/common/logging/backend.cpp

@@ -173,6 +173,7 @@ void FileBackend::Write(const Entry& entry) {
     SUB(Service, Friend)                                                                           \
     SUB(Service, FS)                                                                               \
     SUB(Service, HID)                                                                              \
+    SUB(Service, LDN)                                                                              \
     SUB(Service, LM)                                                                               \
     SUB(Service, MM)                                                                               \
     SUB(Service, NFP)                                                                              \

src/common/logging/log.h

@@ -60,6 +60,7 @@ enum class Class : ClassType {
     Service_Friend,    ///< The friend service
     Service_FS,        ///< The FS (Filesystem) service
     Service_HID,       ///< The HID (Human interface device) service
+    Service_LDN,       ///< The LDN (Local domain network) service
     Service_LM,        ///< The LM (Logger) service
     Service_MM,        ///< The MM (Multimedia) service
     Service_NFP,       ///< The NFP service

src/core/CMakeLists.txt

@@ -10,6 +10,8 @@ add_library(core STATIC
     core_cpu.h
     core_timing.cpp
     core_timing.h
+    core_timing_util.cpp
+    core_timing_util.h
     file_sys/content_archive.cpp
     file_sys/content_archive.h
     file_sys/control_metadata.cpp
@@ -114,26 +116,32 @@ add_library(core STATIC
     hle/service/apm/apm.h
     hle/service/apm/interface.cpp
     hle/service/apm/interface.h
-    hle/service/audio/audio.cpp
-    hle/service/audio/audio.h
     hle/service/audio/audin_u.cpp
     hle/service/audio/audin_u.h
+    hle/service/audio/audio.cpp
+    hle/service/audio/audio.h
     hle/service/audio/audout_u.cpp
     hle/service/audio/audout_u.h
     hle/service/audio/audrec_u.cpp
     hle/service/audio/audrec_u.h
     hle/service/audio/audren_u.cpp
-    hle/service/audio/audren_u.h
     hle/service/audio/audren_u.cpp
     hle/service/audio/audren_u.h
+    hle/service/audio/audren_u.h
     hle/service/audio/codecctl.cpp
     hle/service/audio/codecctl.h
     hle/service/audio/hwopus.cpp
     hle/service/audio/hwopus.h
-    hle/service/bcat/module.cpp
-    hle/service/bcat/module.h
     hle/service/bcat/bcat.cpp
     hle/service/bcat/bcat.h
+    hle/service/bcat/module.cpp
+    hle/service/bcat/module.h
+    hle/service/erpt/erpt.cpp
+    hle/service/erpt/erpt.h
+    hle/service/es/es.cpp
+    hle/service/es/es.h
+    hle/service/eupld/eupld.cpp
+    hle/service/eupld/eupld.h
     hle/service/fatal/fatal.cpp
     hle/service/fatal/fatal.h
     hle/service/fatal/fatal_p.cpp
@@ -146,28 +154,32 @@ add_library(core STATIC
     hle/service/filesystem/fsp_srv.h
     hle/service/friend/friend.cpp
     hle/service/friend/friend.h
-    hle/service/friend/friend_a.cpp
-    hle/service/friend/friend_a.h
-    hle/service/friend/friend_u.cpp
-    hle/service/friend/friend_u.h
+    hle/service/friend/interface.cpp
+    hle/service/friend/interface.h
+    hle/service/grc/grc.cpp
+    hle/service/grc/grc.h
     hle/service/hid/hid.cpp
     hle/service/hid/hid.h
+    hle/service/hid/irs.cpp
+    hle/service/hid/irs.h
+    hle/service/hid/xcd.cpp
+    hle/service/hid/xcd.h
+    hle/service/ldn/ldn.cpp
+    hle/service/ldn/ldn.h
+    hle/service/ldr/ldr.cpp
+    hle/service/ldr/ldr.h
     hle/service/lm/lm.cpp
     hle/service/lm/lm.h
     hle/service/mm/mm_u.cpp
     hle/service/mm/mm_u.h
-    hle/service/nifm/nifm.cpp
-    hle/service/nifm/nifm.h
-    hle/service/nifm/nifm_a.cpp
-    hle/service/nifm/nifm_a.h
-    hle/service/nifm/nifm_s.cpp
-    hle/service/nifm/nifm_s.h
-    hle/service/nifm/nifm_u.cpp
-    hle/service/nifm/nifm_u.h
     hle/service/nfp/nfp.cpp
     hle/service/nfp/nfp.h
     hle/service/nfp/nfp_user.cpp
     hle/service/nfp/nfp_user.h
+    hle/service/nifm/nifm.cpp
+    hle/service/nifm/nifm.h
+    hle/service/nim/nim.cpp
+    hle/service/nim/nim.h
     hle/service/ns/ns.cpp
     hle/service/ns/ns.h
     hle/service/ns/pl_u.cpp
@@ -201,6 +213,8 @@ add_library(core STATIC
     hle/service/pctl/module.h
     hle/service/pctl/pctl.cpp
     hle/service/pctl/pctl.h
+    hle/service/pm/pm.cpp
+    hle/service/pm/pm.h
     hle/service/prepo/prepo.cpp
     hle/service/prepo/prepo.h
     hle/service/service.cpp
@@ -221,6 +235,8 @@ add_library(core STATIC
     hle/service/sm/sm.h
     hle/service/sockets/bsd.cpp
     hle/service/sockets/bsd.h
+    hle/service/sockets/ethc.cpp
+    hle/service/sockets/ethc.h
     hle/service/sockets/nsd.cpp
     hle/service/sockets/nsd.h
     hle/service/sockets/sfdnsres.cpp
@@ -235,12 +251,10 @@ add_library(core STATIC
     hle/service/spl/spl.h
     hle/service/ssl/ssl.cpp
     hle/service/ssl/ssl.h
+    hle/service/time/interface.cpp
+    hle/service/time/interface.h
     hle/service/time/time.cpp
     hle/service/time/time.h
-    hle/service/time/time_s.cpp
-    hle/service/time/time_s.h
-    hle/service/time/time_u.cpp
-    hle/service/time/time_u.h
     hle/service/vi/vi.cpp
     hle/service/vi/vi.h
     hle/service/vi/vi_m.cpp

src/core/core_timing.cpp

@@ -5,17 +5,15 @@
 #include "core/core_timing.h"
 
 #include <algorithm>
-#include <cinttypes>
-#include <limits>
 #include <mutex>
 #include <string>
 #include <tuple>
 #include <unordered_map>
 #include <vector>
 #include "common/assert.h"
-#include "common/logging/log.h"
 #include "common/thread.h"
 #include "common/threadsafe_queue.h"
+#include "core/core_timing_util.h"
 
 namespace CoreTiming {
 
@@ -59,7 +57,6 @@ static u64 event_fifo_id;
 static Common::MPSCQueue<Event, false> ts_queue;
 
 constexpr int MAX_SLICE_LENGTH = 20000;
-constexpr u64 MAX_VALUE_TO_MULTIPLY = std::numeric_limits<s64>::max() / BASE_CLOCK_RATE;
 
 static s64 idled_cycles;
 
@@ -72,54 +69,6 @@ static EventType* ev_lost = nullptr;
 
 static void EmptyTimedCallback(u64 userdata, s64 cyclesLate) {}
 
-s64 usToCycles(s64 us) {
-    if (us / 1000000 > MAX_VALUE_TO_MULTIPLY) {
-        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
-        return std::numeric_limits<s64>::max();
-    }
-    if (us > MAX_VALUE_TO_MULTIPLY) {
-        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return BASE_CLOCK_RATE * (us / 1000000);
-    }
-    return (BASE_CLOCK_RATE * us) / 1000000;
-}
-
-s64 usToCycles(u64 us) {
-    if (us / 1000000 > MAX_VALUE_TO_MULTIPLY) {
-        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
-        return std::numeric_limits<s64>::max();
-    }
-    if (us > MAX_VALUE_TO_MULTIPLY) {
-        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return BASE_CLOCK_RATE * static_cast<s64>(us / 1000000);
-    }
-    return (BASE_CLOCK_RATE * static_cast<s64>(us)) / 1000000;
-}
-
-s64 nsToCycles(s64 ns) {
-    if (ns / 1000000000 > MAX_VALUE_TO_MULTIPLY) {
-        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
-        return std::numeric_limits<s64>::max();
-    }
-    if (ns > MAX_VALUE_TO_MULTIPLY) {
-        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return BASE_CLOCK_RATE * (ns / 1000000000);
-    }
-    return (BASE_CLOCK_RATE * ns) / 1000000000;
-}
-
-s64 nsToCycles(u64 ns) {
-    if (ns / 1000000000 > MAX_VALUE_TO_MULTIPLY) {
-        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
-        return std::numeric_limits<s64>::max();
-    }
-    if (ns > MAX_VALUE_TO_MULTIPLY) {
-        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return BASE_CLOCK_RATE * (static_cast<s64>(ns) / 1000000000);
-    }
-    return (BASE_CLOCK_RATE * static_cast<s64>(ns)) / 1000000000;
-}
-
 EventType* RegisterEvent(const std::string& name, TimedCallback callback) {
     // check for existing type with same name.
     // we want event type names to remain unique so that we can use them for serialization.

src/core/core_timing.h

@@ -23,59 +23,6 @@
 
 namespace CoreTiming {
 
-// The below clock rate is based on Switch's clockspeed being widely known as 1.020GHz
-// The exact value used is of course unverified.
-constexpr u64 BASE_CLOCK_RATE = 1019215872; // Switch clock speed is 1020MHz un/docked
-
-inline s64 msToCycles(int ms) {
-    // since ms is int there is no way to overflow
-    return BASE_CLOCK_RATE * static_cast<s64>(ms) / 1000;
-}
-
-inline s64 msToCycles(float ms) {
-    return static_cast<s64>(BASE_CLOCK_RATE * (0.001f) * ms);
-}
-
-inline s64 msToCycles(double ms) {
-    return static_cast<s64>(BASE_CLOCK_RATE * (0.001) * ms);
-}
-
-inline s64 usToCycles(float us) {
-    return static_cast<s64>(BASE_CLOCK_RATE * (0.000001f) * us);
-}
-
-inline s64 usToCycles(int us) {
-    return (BASE_CLOCK_RATE * static_cast<s64>(us) / 1000000);
-}
-
-s64 usToCycles(s64 us);
-
-s64 usToCycles(u64 us);
-
-inline s64 nsToCycles(float ns) {
-    return static_cast<s64>(BASE_CLOCK_RATE * (0.000000001f) * ns);
-}
-
-inline s64 nsToCycles(int ns) {
-    return BASE_CLOCK_RATE * static_cast<s64>(ns) / 1000000000;
-}
-
-s64 nsToCycles(s64 ns);
-
-s64 nsToCycles(u64 ns);
-
-inline u64 cyclesToNs(s64 cycles) {
-    return cycles * 1000000000 / BASE_CLOCK_RATE;
-}
-
-inline s64 cyclesToUs(s64 cycles) {
-    return cycles * 1000000 / BASE_CLOCK_RATE;
-}
-
-inline u64 cyclesToMs(s64 cycles) {
-    return cycles * 1000 / BASE_CLOCK_RATE;
-}
-
 /**
  * CoreTiming begins at the boundary of timing slice -1. An initial call to Advance() is
  * required to end slice -1 and start slice 0 before the first cycle of code is executed.

src/core/core_timing_util.cpp

@@ -0,0 +1,63 @@
+// Copyright 2008 Dolphin Emulator Project / 2017 Citra Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include "core/core_timing_util.h"
+
+#include <cinttypes>
+#include <limits>
+#include "common/logging/log.h"
+
+namespace CoreTiming {
+
+constexpr u64 MAX_VALUE_TO_MULTIPLY = std::numeric_limits<s64>::max() / BASE_CLOCK_RATE;
+
+s64 usToCycles(s64 us) {
+    if (us / 1000000 > MAX_VALUE_TO_MULTIPLY) {
+        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
+        return std::numeric_limits<s64>::max();
+    }
+    if (us > MAX_VALUE_TO_MULTIPLY) {
+        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
+        return BASE_CLOCK_RATE * (us / 1000000);
+    }
+    return (BASE_CLOCK_RATE * us) / 1000000;
+}
+
+s64 usToCycles(u64 us) {
+    if (us / 1000000 > MAX_VALUE_TO_MULTIPLY) {
+        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
+        return std::numeric_limits<s64>::max();
+    }
+    if (us > MAX_VALUE_TO_MULTIPLY) {
+        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
+        return BASE_CLOCK_RATE * static_cast<s64>(us / 1000000);
+    }
+    return (BASE_CLOCK_RATE * static_cast<s64>(us)) / 1000000;
+}
+
+s64 nsToCycles(s64 ns) {
+    if (ns / 1000000000 > MAX_VALUE_TO_MULTIPLY) {
+        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
+        return std::numeric_limits<s64>::max();
+    }
+    if (ns > MAX_VALUE_TO_MULTIPLY) {
+        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
+        return BASE_CLOCK_RATE * (ns / 1000000000);
+    }
+    return (BASE_CLOCK_RATE * ns) / 1000000000;
+}
+
+s64 nsToCycles(u64 ns) {
+    if (ns / 1000000000 > MAX_VALUE_TO_MULTIPLY) {
+        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
+        return std::numeric_limits<s64>::max();
+    }
+    if (ns > MAX_VALUE_TO_MULTIPLY) {
+        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
+        return BASE_CLOCK_RATE * (static_cast<s64>(ns) / 1000000000);
+    }
+    return (BASE_CLOCK_RATE * static_cast<s64>(ns)) / 1000000000;
+}
+
+} // namespace CoreTiming

src/core/core_timing_util.h

@@ -0,0 +1,64 @@
+// Copyright 2008 Dolphin Emulator Project / 2017 Citra Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/common_types.h"
+
+namespace CoreTiming {
+
+// The below clock rate is based on Switch's clockspeed being widely known as 1.020GHz
+// The exact value used is of course unverified.
+constexpr u64 BASE_CLOCK_RATE = 1019215872; // Switch clock speed is 1020MHz un/docked
+
+inline s64 msToCycles(int ms) {
+    // since ms is int there is no way to overflow
+    return BASE_CLOCK_RATE * static_cast<s64>(ms) / 1000;
+}
+
+inline s64 msToCycles(float ms) {
+    return static_cast<s64>(BASE_CLOCK_RATE * (0.001f) * ms);
+}
+
+inline s64 msToCycles(double ms) {
+    return static_cast<s64>(BASE_CLOCK_RATE * (0.001) * ms);
+}
+
+inline s64 usToCycles(float us) {
+    return static_cast<s64>(BASE_CLOCK_RATE * (0.000001f) * us);
+}
+
+inline s64 usToCycles(int us) {
+    return (BASE_CLOCK_RATE * static_cast<s64>(us) / 1000000);
+}
+
+s64 usToCycles(s64 us);
+
+s64 usToCycles(u64 us);
+
+inline s64 nsToCycles(float ns) {
+    return static_cast<s64>(BASE_CLOCK_RATE * (0.000000001f) * ns);
+}
+
+inline s64 nsToCycles(int ns) {
+    return BASE_CLOCK_RATE * static_cast<s64>(ns) / 1000000000;
+}
+
+s64 nsToCycles(s64 ns);
+
+s64 nsToCycles(u64 ns);
+
+inline u64 cyclesToNs(s64 cycles) {
+    return cycles * 1000000000 / BASE_CLOCK_RATE;
+}
+
+inline s64 cyclesToUs(s64 cycles) {
+    return cycles * 1000000 / BASE_CLOCK_RATE;
+}
+
+inline u64 cyclesToMs(s64 cycles) {
+    return cycles * 1000 / BASE_CLOCK_RATE;
+}
+
+} // namespace CoreTiming

src/core/hle/ipc_helpers.h

@@ -300,6 +300,14 @@ public:
     template <typename First, typename... Other>
     void Pop(First& first_value, Other&... other_values);
 
+    template <typename T>
+    T PopEnum() {
+        static_assert(std::is_enum_v<T>, "T must be an enum type within a PopEnum call.");
+        static_assert(!std::is_convertible_v<T, int>,
+                      "enum type in PopEnum must be a strongly typed enum.");
+        return static_cast<T>(Pop<std::underlying_type_t<T>>());
+    }
+
     /**
      * @brief Reads the next normal parameters as a struct, by copying it
      * @note: The output class must be correctly packed/padded to fit hardware layout.

src/core/hle/kernel/svc.cpp

@@ -40,7 +40,9 @@ static ResultCode SetHeapSize(VAddr* heap_addr, u64 heap_size) {
 }
 
 static ResultCode SetMemoryAttribute(VAddr addr, u64 size, u32 state0, u32 state1) {
-    LOG_WARNING(Kernel_SVC, "(STUBBED) called, addr=0x{:X}", addr);
+    LOG_WARNING(Kernel_SVC,
+                "(STUBBED) called, addr=0x{:X}, size=0x{:X}, state0=0x{:X}, state1=0x{:X}", addr,
+                size, state0, state1);
     return RESULT_SUCCESS;
 }
 
@@ -165,11 +167,14 @@ static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64
     using ObjectPtr = SharedPtr<WaitObject>;
     std::vector<ObjectPtr> objects(handle_count);
 
-    for (int i = 0; i < handle_count; ++i) {
-        Handle handle = Memory::Read32(handles_address + i * sizeof(Handle));
-        auto object = g_handle_table.Get<WaitObject>(handle);
-        if (object == nullptr)
+    for (u64 i = 0; i < handle_count; ++i) {
+        const Handle handle = Memory::Read32(handles_address + i * sizeof(Handle));
+        const auto object = g_handle_table.Get<WaitObject>(handle);
+
+        if (object == nullptr) {
             return ERR_INVALID_HANDLE;
+        }
+
         objects[i] = object;
     }
 

src/core/hle/kernel/thread.cpp

@@ -14,6 +14,7 @@
 #include "core/arm/arm_interface.h"
 #include "core/core.h"
 #include "core/core_timing.h"
+#include "core/core_timing_util.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/kernel.h"

src/core/hle/kernel/timer.cpp

@@ -6,6 +6,7 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/core_timing.h"
+#include "core/core_timing_util.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/thread.h"

src/core/hle/kernel/timer.h

@@ -32,13 +32,17 @@ public:
         return HANDLE_TYPE;
     }
 
-    ResetType reset_type; ///< The ResetType of this timer
+    ResetType GetResetType() const {
+        return reset_type;
+    }
 
-    bool signaled;    ///< Whether the timer has been signaled or not
-    std::string name; ///< Name of timer (optional)
+    u64 GetInitialDelay() const {
+        return initial_delay;
+    }
 
-    u64 initial_delay;  ///< The delay until the timer fires for the first time
-    u64 interval_delay; ///< The delay until the timer fires after the first time
+    u64 GetIntervalDelay() const {
+        return interval_delay;
+    }
 
     bool ShouldWait(Thread* thread) const override;
     void Acquire(Thread* thread) override;
@@ -67,6 +71,14 @@ private:
     Timer();
     ~Timer() override;
 
+    ResetType reset_type; ///< The ResetType of this timer
+
+    u64 initial_delay;  ///< The delay until the timer fires for the first time
+    u64 interval_delay; ///< The delay until the timer fires after the first time
+
+    bool signaled;    ///< Whether the timer has been signaled or not
+    std::string name; ///< Name of timer (optional)
+
     /// Handle used as userdata to reference this object when inserting into the CoreTiming queue.
     Handle callback_handle;
 };

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

@@ -6,6 +6,7 @@
 #include <vector>
 #include "common/logging/log.h"
 #include "core/core_timing.h"
+#include "core/core_timing_util.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/event.h"
 #include "core/hle/kernel/hle_ipc.h"

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

@@ -7,6 +7,7 @@
 #include "common/alignment.h"
 #include "common/logging/log.h"
 #include "core/core_timing.h"
+#include "core/core_timing_util.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/event.h"
 #include "core/hle/kernel/hle_ipc.h"

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

@@ -0,0 +1,51 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <memory>
+
+#include "core/hle/service/erpt/erpt.h"
+#include "core/hle/service/service.h"
+#include "core/hle/service/sm/sm.h"
+
+namespace Service::ERPT {
+
+class ErrorReportContext final : public ServiceFramework<ErrorReportContext> {
+public:
+    explicit ErrorReportContext() : ServiceFramework{"erpt:c"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "SubmitContext"},
+            {1, nullptr, "CreateReport"},
+            {2, nullptr, "Unknown1"},
+            {3, nullptr, "Unknown2"},
+            {4, nullptr, "Unknown3"},
+            {5, nullptr, "Unknown4"},
+            {6, nullptr, "Unknown5"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class ErrorReportSession final : public ServiceFramework<ErrorReportSession> {
+public:
+    explicit ErrorReportSession() : ServiceFramework{"erpt:r"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "OpenReport"},
+            {1, nullptr, "OpenManager"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+void InstallInterfaces(SM::ServiceManager& sm) {
+    std::make_shared<ErrorReportContext>()->InstallAsService(sm);
+    std::make_shared<ErrorReportSession>()->InstallAsService(sm);
+}
+
+} // namespace Service::ERPT

src/core/hle/service/erpt/erpt.h

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

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

@@ -0,0 +1,57 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/service/service.h"
+
+namespace Service::ES {
+
+class ETicket final : public ServiceFramework<ETicket> {
+public:
+    explicit ETicket() : ServiceFramework{"es"} {
+        static const FunctionInfo functions[] = {
+            {1, nullptr, "ImportTicket"},
+            {2, nullptr, "ImportTicketCertificateSet"},
+            {3, nullptr, "DeleteTicket"},
+            {4, nullptr, "DeletePersonalizedTicket"},
+            {5, nullptr, "DeleteAllCommonTicket"},
+            {6, nullptr, "DeleteAllPersonalizedTicket"},
+            {7, nullptr, "DeleteAllPersonalizedTicketEx"},
+            {8, nullptr, "GetTitleKey"},
+            {9, nullptr, "CountCommonTicket"},
+            {10, nullptr, "CountPersonalizedTicket"},
+            {11, nullptr, "ListCommonTicket"},
+            {12, nullptr, "ListPersonalizedTicket"},
+            {13, nullptr, "ListMissingPersonalizedTicket"},
+            {14, nullptr, "GetCommonTicketSize"},
+            {15, nullptr, "GetPersonalizedTicketSize"},
+            {16, nullptr, "GetCommonTicketData"},
+            {17, nullptr, "GetPersonalizedTicketData"},
+            {18, nullptr, "OwnTicket"},
+            {19, nullptr, "GetTicketInfo"},
+            {20, nullptr, "ListLightTicketInfo"},
+            {21, nullptr, "SignData"},
+            {22, nullptr, "GetCommonTicketAndCertificateSize"},
+            {23, nullptr, "GetCommonTicketAndCertificateData"},
+            {24, nullptr, "ImportPrepurchaseRecord"},
+            {25, nullptr, "DeletePrepurchaseRecord"},
+            {26, nullptr, "DeleteAllPrepurchaseRecord"},
+            {27, nullptr, "CountPrepurchaseRecord"},
+            {28, nullptr, "ListPrepurchaseRecord"},
+            {29, nullptr, "ListPrepurchaseRecordInfo"},
+            {30, nullptr, "Unknown1"},
+            {31, nullptr, "Unknown2"},
+            {32, nullptr, "Unknown3"},
+            {33, nullptr, "Unknown4"},
+            {34, nullptr, "Unknown5"},
+            {35, nullptr, "Unknown6"},
+        };
+        RegisterHandlers(functions);
+    }
+};
+
+void InstallInterfaces(SM::ServiceManager& service_manager) {
+    std::make_shared<ETicket>()->InstallAsService(service_manager);
+}
+
+} // namespace Service::ES

src/core/hle/service/es/es.h

@@ -0,0 +1,16 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+namespace Service::SM {
+class ServiceManager;
+}
+
+namespace Service::ES {
+
+/// Registers all ES services with the specified service manager.
+void InstallInterfaces(SM::ServiceManager& service_manager);
+
+} // namespace Service::ES

src/core/hle/service/eupld/eupld.cpp

@@ -0,0 +1,52 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <memory>
+
+#include "core/hle/service/eupld/eupld.h"
+#include "core/hle/service/service.h"
+#include "core/hle/service/sm/sm.h"
+
+namespace Service::EUPLD {
+
+class ErrorUploadContext final : public ServiceFramework<ErrorUploadContext> {
+public:
+    explicit ErrorUploadContext() : ServiceFramework{"eupld:c"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "SetUrl"},
+            {1, nullptr, "ImportCrt"},
+            {2, nullptr, "ImportPki"},
+            {3, nullptr, "SetAutoUpload"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class ErrorUploadRequest final : public ServiceFramework<ErrorUploadRequest> {
+public:
+    explicit ErrorUploadRequest() : ServiceFramework{"eupld:r"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "Initialize"},
+            {1, nullptr, "UploadAll"},
+            {2, nullptr, "UploadSelected"},
+            {3, nullptr, "GetUploadStatus"},
+            {4, nullptr, "CancelUpload"},
+            {5, nullptr, "GetResult"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+void InstallInterfaces(SM::ServiceManager& sm) {
+    std::make_shared<ErrorUploadContext>()->InstallAsService(sm);
+    std::make_shared<ErrorUploadRequest>()->InstallAsService(sm);
+}
+
+} // namespace Service::EUPLD

src/core/hle/service/eupld/eupld.h

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

src/core/hle/service/friend/friend.cpp

@@ -5,8 +5,7 @@
 #include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/friend/friend.h"
-#include "core/hle/service/friend/friend_a.h"
-#include "core/hle/service/friend/friend_u.h"
+#include "core/hle/service/friend/interface.h"
 
 namespace Service::Friend {
 
@@ -21,8 +20,11 @@ Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
 
 void InstallInterfaces(SM::ServiceManager& service_manager) {
     auto module = std::make_shared<Module>();
-    std::make_shared<Friend_A>(module)->InstallAsService(service_manager);
-    std::make_shared<Friend_U>(module)->InstallAsService(service_manager);
+    std::make_shared<Friend>(module, "friend:a")->InstallAsService(service_manager);
+    std::make_shared<Friend>(module, "friend:m")->InstallAsService(service_manager);
+    std::make_shared<Friend>(module, "friend:s")->InstallAsService(service_manager);
+    std::make_shared<Friend>(module, "friend:u")->InstallAsService(service_manager);
+    std::make_shared<Friend>(module, "friend:v")->InstallAsService(service_manager);
 }
 
 } // namespace Service::Friend

src/core/hle/service/friend/friend_u.cpp

@@ -1,18 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/service/friend/friend_u.h"
-
-namespace Service::Friend {
-
-Friend_U::Friend_U(std::shared_ptr<Module> module)
-    : Module::Interface(std::move(module), "friend:u") {
-    static const FunctionInfo functions[] = {
-        {0, &Friend_U::CreateFriendService, "CreateFriendService"},
-        {1, nullptr, "CreateNotificationService"},
-    };
-    RegisterHandlers(functions);
-}
-
-} // namespace Service::Friend

src/core/hle/service/friend/friend_u.h

@@ -1,16 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/friend/friend.h"
-
-namespace Service::Friend {
-
-class Friend_U final : public Module::Interface {
-public:
-    explicit Friend_U(std::shared_ptr<Module> module);
-};
-
-} // namespace Service::Friend

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

@@ -2,15 +2,16 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "core/hle/service/friend/friend_a.h"
+#include "core/hle/service/friend/interface.h"
 
 namespace Service::Friend {
 
-Friend_A::Friend_A(std::shared_ptr<Module> module)
-    : Module::Interface(std::move(module), "friend:a") {
+Friend::Friend(std::shared_ptr<Module> module, const char* name)
+    : Interface(std::move(module), name) {
     static const FunctionInfo functions[] = {
-        {0, &Friend_A::CreateFriendService, "CreateFriendService"},
+        {0, &Friend::CreateFriendService, "CreateFriendService"},
         {1, nullptr, "CreateNotificationService"},
+        {2, nullptr, "CreateDaemonSuspendSessionService"},
     };
     RegisterHandlers(functions);
 }

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

@@ -8,9 +8,9 @@
 
 namespace Service::Friend {
 
-class Friend_A final : public Module::Interface {
+class Friend final : public Module::Interface {
 public:
-    explicit Friend_A(std::shared_ptr<Module> module);
+    explicit Friend(std::shared_ptr<Module> module, const char* name);
 };
 
 } // namespace Service::Friend

src/core/hle/service/grc/grc.cpp

@@ -0,0 +1,31 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <memory>
+
+#include "core/hle/service/grc/grc.h"
+#include "core/hle/service/service.h"
+#include "core/hle/service/sm/sm.h"
+
+namespace Service::GRC {
+
+class GRC final : public ServiceFramework<GRC> {
+public:
+    explicit GRC() : ServiceFramework{"grc:c"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {1, nullptr, "OpenContinuousRecorder"},
+            {2, nullptr, "OpenGameMovieTrimmer"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+void InstallInterfaces(SM::ServiceManager& sm) {
+    std::make_shared<GRC>()->InstallAsService(sm);
+}
+
+} // namespace Service::GRC

src/core/hle/service/grc/grc.h

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

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

@@ -5,6 +5,7 @@
 #include <atomic>
 #include "common/logging/log.h"
 #include "core/core_timing.h"
+#include "core/core_timing_util.h"
 #include "core/frontend/emu_window.h"
 #include "core/frontend/input.h"
 #include "core/hle/ipc_helpers.h"
@@ -13,6 +14,8 @@
 #include "core/hle/kernel/event.h"
 #include "core/hle/kernel/shared_memory.h"
 #include "core/hle/service/hid/hid.h"
+#include "core/hle/service/hid/irs.h"
+#include "core/hle/service/hid/xcd.h"
 #include "core/hle/service/service.h"
 
 namespace Service::HID {
@@ -554,10 +557,233 @@ private:
     }
 };
 
+class HidDbg final : public ServiceFramework<HidDbg> {
+public:
+    explicit HidDbg() : ServiceFramework{"hid:dbg"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "DeactivateDebugPad"},
+            {1, nullptr, "SetDebugPadAutoPilotState"},
+            {2, nullptr, "UnsetDebugPadAutoPilotState"},
+            {10, nullptr, "DeactivateTouchScreen"},
+            {11, nullptr, "SetTouchScreenAutoPilotState"},
+            {12, nullptr, "UnsetTouchScreenAutoPilotState"},
+            {20, nullptr, "DeactivateMouse"},
+            {21, nullptr, "SetMouseAutoPilotState"},
+            {22, nullptr, "UnsetMouseAutoPilotState"},
+            {30, nullptr, "DeactivateKeyboard"},
+            {31, nullptr, "SetKeyboardAutoPilotState"},
+            {32, nullptr, "UnsetKeyboardAutoPilotState"},
+            {50, nullptr, "DeactivateXpad"},
+            {51, nullptr, "SetXpadAutoPilotState"},
+            {52, nullptr, "UnsetXpadAutoPilotState"},
+            {60, nullptr, "DeactivateJoyXpad"},
+            {91, nullptr, "DeactivateGesture"},
+            {110, nullptr, "DeactivateHomeButton"},
+            {111, nullptr, "SetHomeButtonAutoPilotState"},
+            {112, nullptr, "UnsetHomeButtonAutoPilotState"},
+            {120, nullptr, "DeactivateSleepButton"},
+            {121, nullptr, "SetSleepButtonAutoPilotState"},
+            {122, nullptr, "UnsetSleepButtonAutoPilotState"},
+            {123, nullptr, "DeactivateInputDetector"},
+            {130, nullptr, "DeactivateCaptureButton"},
+            {131, nullptr, "SetCaptureButtonAutoPilotState"},
+            {132, nullptr, "UnsetCaptureButtonAutoPilotState"},
+            {133, nullptr, "SetShiftAccelerometerCalibrationValue"},
+            {134, nullptr, "GetShiftAccelerometerCalibrationValue"},
+            {135, nullptr, "SetShiftGyroscopeCalibrationValue"},
+            {136, nullptr, "GetShiftGyroscopeCalibrationValue"},
+            {140, nullptr, "DeactivateConsoleSixAxisSensor"},
+            {141, nullptr, "GetConsoleSixAxisSensorSamplingFrequency"},
+            {142, nullptr, "DeactivateSevenSixAxisSensor"},
+            {201, nullptr, "ActivateFirmwareUpdate"},
+            {202, nullptr, "DeactivateFirmwareUpdate"},
+            {203, nullptr, "StartFirmwareUpdate"},
+            {204, nullptr, "GetFirmwareUpdateStage"},
+            {205, nullptr, "GetFirmwareVersion"},
+            {206, nullptr, "GetDestinationFirmwareVersion"},
+            {207, nullptr, "DiscardFirmwareInfoCacheForRevert"},
+            {208, nullptr, "StartFirmwareUpdateForRevert"},
+            {209, nullptr, "GetAvailableFirmwareVersionForRevert"},
+            {210, nullptr, "IsFirmwareUpdatingDevice"},
+            {221, nullptr, "UpdateControllerColor"},
+            {222, nullptr, "ConnectUsbPadsAsync"},
+            {223, nullptr, "DisconnectUsbPadsAsync"},
+            {224, nullptr, "UpdateDesignInfo"},
+            {225, nullptr, "GetUniquePadDriverState"},
+            {226, nullptr, "GetSixAxisSensorDriverStates"},
+            {301, nullptr, "GetAbstractedPadHandles"},
+            {302, nullptr, "GetAbstractedPadState"},
+            {303, nullptr, "GetAbstractedPadsState"},
+            {321, nullptr, "SetAutoPilotVirtualPadState"},
+            {322, nullptr, "UnsetAutoPilotVirtualPadState"},
+            {323, nullptr, "UnsetAllAutoPilotVirtualPadState"},
+            {350, nullptr, "AddRegisteredDevice"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class HidSys final : public ServiceFramework<HidSys> {
+public:
+    explicit HidSys() : ServiceFramework{"hid:sys"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {31, nullptr, "SendKeyboardLockKeyEvent"},
+            {101, nullptr, "AcquireHomeButtonEventHandle"},
+            {111, nullptr, "ActivateHomeButton"},
+            {121, nullptr, "AcquireSleepButtonEventHandle"},
+            {131, nullptr, "ActivateSleepButton"},
+            {141, nullptr, "AcquireCaptureButtonEventHandle"},
+            {151, nullptr, "ActivateCaptureButton"},
+            {210, nullptr, "AcquireNfcDeviceUpdateEventHandle"},
+            {211, nullptr, "GetNpadsWithNfc"},
+            {212, nullptr, "AcquireNfcActivateEventHandle"},
+            {213, nullptr, "ActivateNfc"},
+            {214, nullptr, "GetXcdHandleForNpadWithNfc"},
+            {215, nullptr, "IsNfcActivated"},
+            {230, nullptr, "AcquireIrSensorEventHandle"},
+            {231, nullptr, "ActivateIrSensor"},
+            {301, nullptr, "ActivateNpadSystem"},
+            {303, nullptr, "ApplyNpadSystemCommonPolicy"},
+            {304, nullptr, "EnableAssigningSingleOnSlSrPress"},
+            {305, nullptr, "DisableAssigningSingleOnSlSrPress"},
+            {306, nullptr, "GetLastActiveNpad"},
+            {307, nullptr, "GetNpadSystemExtStyle"},
+            {308, nullptr, "ApplyNpadSystemCommonPolicyFull"},
+            {309, nullptr, "GetNpadFullKeyGripColor"},
+            {311, nullptr, "SetNpadPlayerLedBlinkingDevice"},
+            {321, nullptr, "GetUniquePadsFromNpad"},
+            {322, nullptr, "GetIrSensorState"},
+            {323, nullptr, "GetXcdHandleForNpadWithIrSensor"},
+            {500, nullptr, "SetAppletResourceUserId"},
+            {501, nullptr, "RegisterAppletResourceUserId"},
+            {502, nullptr, "UnregisterAppletResourceUserId"},
+            {503, nullptr, "EnableAppletToGetInput"},
+            {504, nullptr, "SetAruidValidForVibration"},
+            {505, nullptr, "EnableAppletToGetSixAxisSensor"},
+            {510, nullptr, "SetVibrationMasterVolume"},
+            {511, nullptr, "GetVibrationMasterVolume"},
+            {512, nullptr, "BeginPermitVibrationSession"},
+            {513, nullptr, "EndPermitVibrationSession"},
+            {520, nullptr, "EnableHandheldHids"},
+            {521, nullptr, "DisableHandheldHids"},
+            {540, nullptr, "AcquirePlayReportControllerUsageUpdateEvent"},
+            {541, nullptr, "GetPlayReportControllerUsages"},
+            {542, nullptr, "AcquirePlayReportRegisteredDeviceUpdateEvent"},
+            {543, nullptr, "GetRegisteredDevicesOld"},
+            {544, nullptr, "AcquireConnectionTriggerTimeoutEvent"},
+            {545, nullptr, "SendConnectionTrigger"},
+            {546, nullptr, "AcquireDeviceRegisteredEventForControllerSupport"},
+            {547, nullptr, "GetAllowedBluetoothLinksCount"},
+            {548, nullptr, "GetRegisteredDevices"},
+            {700, nullptr, "ActivateUniquePad"},
+            {702, nullptr, "AcquireUniquePadConnectionEventHandle"},
+            {703, nullptr, "GetUniquePadIds"},
+            {751, nullptr, "AcquireJoyDetachOnBluetoothOffEventHandle"},
+            {800, nullptr, "ListSixAxisSensorHandles"},
+            {801, nullptr, "IsSixAxisSensorUserCalibrationSupported"},
+            {802, nullptr, "ResetSixAxisSensorCalibrationValues"},
+            {803, nullptr, "StartSixAxisSensorUserCalibration"},
+            {804, nullptr, "CancelSixAxisSensorUserCalibration"},
+            {805, nullptr, "GetUniquePadBluetoothAddress"},
+            {806, nullptr, "DisconnectUniquePad"},
+            {807, nullptr, "GetUniquePadType"},
+            {808, nullptr, "GetUniquePadInterface"},
+            {809, nullptr, "GetUniquePadSerialNumber"},
+            {810, nullptr, "GetUniquePadControllerNumber"},
+            {811, nullptr, "GetSixAxisSensorUserCalibrationStage"},
+            {821, nullptr, "StartAnalogStickManualCalibration"},
+            {822, nullptr, "RetryCurrentAnalogStickManualCalibrationStage"},
+            {823, nullptr, "CancelAnalogStickManualCalibration"},
+            {824, nullptr, "ResetAnalogStickManualCalibration"},
+            {825, nullptr, "GetAnalogStickState"},
+            {826, nullptr, "GetAnalogStickManualCalibrationStage"},
+            {827, nullptr, "IsAnalogStickButtonPressed"},
+            {828, nullptr, "IsAnalogStickInReleasePosition"},
+            {829, nullptr, "IsAnalogStickInCircumference"},
+            {850, nullptr, "IsUsbFullKeyControllerEnabled"},
+            {851, nullptr, "EnableUsbFullKeyController"},
+            {852, nullptr, "IsUsbConnected"},
+            {900, nullptr, "ActivateInputDetector"},
+            {901, nullptr, "NotifyInputDetector"},
+            {1000, nullptr, "InitializeFirmwareUpdate"},
+            {1001, nullptr, "GetFirmwareVersion"},
+            {1002, nullptr, "GetAvailableFirmwareVersion"},
+            {1003, nullptr, "IsFirmwareUpdateAvailable"},
+            {1004, nullptr, "CheckFirmwareUpdateRequired"},
+            {1005, nullptr, "StartFirmwareUpdate"},
+            {1006, nullptr, "AbortFirmwareUpdate"},
+            {1007, nullptr, "GetFirmwareUpdateState"},
+            {1008, nullptr, "ActivateAudioControl"},
+            {1009, nullptr, "AcquireAudioControlEventHandle"},
+            {1010, nullptr, "GetAudioControlStates"},
+            {1011, nullptr, "DeactivateAudioControl"},
+            {1050, nullptr, "IsSixAxisSensorAccurateUserCalibrationSupported"},
+            {1051, nullptr, "StartSixAxisSensorAccurateUserCalibration"},
+            {1052, nullptr, "CancelSixAxisSensorAccurateUserCalibration"},
+            {1053, nullptr, "GetSixAxisSensorAccurateUserCalibrationState"},
+            {1100, nullptr, "GetHidbusSystemServiceObject"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class HidTmp final : public ServiceFramework<HidTmp> {
+public:
+    explicit HidTmp() : ServiceFramework{"hid:tmp"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetConsoleSixAxisSensorCalibrationValues"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class HidBus final : public ServiceFramework<HidBus> {
+public:
+    explicit HidBus() : ServiceFramework{"hidbus"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {1, nullptr, "GetBusHandle"},
+            {2, nullptr, "IsExternalDeviceConnected"},
+            {3, nullptr, "Initialize"},
+            {4, nullptr, "Finalize"},
+            {5, nullptr, "EnableExternalDevice"},
+            {6, nullptr, "GetExternalDeviceId"},
+            {7, nullptr, "SendCommandAsync"},
+            {8, nullptr, "GetSendCommandAsynceResult"},
+            {9, nullptr, "SetEventForSendCommandAsycResult"},
+            {10, nullptr, "GetSharedMemoryHandle"},
+            {11, nullptr, "EnableJoyPollingReceiveMode"},
+            {12, nullptr, "DisableJoyPollingReceiveMode"},
+            {13, nullptr, "GetPollingData"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
 void ReloadInputDevices() {}
 
 void InstallInterfaces(SM::ServiceManager& service_manager) {
     std::make_shared<Hid>()->InstallAsService(service_manager);
+    std::make_shared<HidBus>()->InstallAsService(service_manager);
+    std::make_shared<HidDbg>()->InstallAsService(service_manager);
+    std::make_shared<HidSys>()->InstallAsService(service_manager);
+    std::make_shared<HidTmp>()->InstallAsService(service_manager);
+
+    std::make_shared<IRS>()->InstallAsService(service_manager);
+    std::make_shared<IRS_SYS>()->InstallAsService(service_manager);
+
+    std::make_shared<XCD_SYS>()->InstallAsService(service_manager);
 }
 
 } // namespace Service::HID

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

@@ -0,0 +1,49 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/service/hid/irs.h"
+
+namespace Service::HID {
+
+IRS::IRS() : ServiceFramework{"irs"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {302, nullptr, "ActivateIrsensor"},
+        {303, nullptr, "DeactivateIrsensor"},
+        {304, nullptr, "GetIrsensorSharedMemoryHandle"},
+        {305, nullptr, "StopImageProcessor"},
+        {306, nullptr, "RunMomentProcessor"},
+        {307, nullptr, "RunClusteringProcessor"},
+        {308, nullptr, "RunImageTransferProcessor"},
+        {309, nullptr, "GetImageTransferProcessorState"},
+        {310, nullptr, "RunTeraPluginProcessor"},
+        {311, nullptr, "GetNpadIrCameraHandle"},
+        {312, nullptr, "RunPointingProcessor"},
+        {313, nullptr, "SuspendImageProcessor"},
+        {314, nullptr, "CheckFirmwareVersion"},
+        {315, nullptr, "SetFunctionLevel"},
+        {316, nullptr, "RunImageTransferExProcessor"},
+        {317, nullptr, "RunIrLedProcessor"},
+        {318, nullptr, "StopImageProcessorAsync"},
+        {319, nullptr, "ActivateIrsensorWithFunctionLevel"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+IRS_SYS::IRS_SYS() : ServiceFramework{"irs:sys"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {500, nullptr, "SetAppletResourceUserId"},
+        {501, nullptr, "RegisterAppletResourceUserId"},
+        {502, nullptr, "UnregisterAppletResourceUserId"},
+        {503, nullptr, "EnableAppletToGetInput"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+} // namespace Service::HID

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

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

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

@@ -0,0 +1,37 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/service/hid/xcd.h"
+
+namespace Service::HID {
+
+XCD_SYS::XCD_SYS() : ServiceFramework{"xcd:sys"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "GetDataFormat"},
+        {1, nullptr, "SetDataFormat"},
+        {2, nullptr, "GetMcuState"},
+        {3, nullptr, "SetMcuState"},
+        {4, nullptr, "GetMcuVersionForNfc"},
+        {5, nullptr, "CheckNfcDevicePower"},
+        {10, nullptr, "SetNfcEvent"},
+        {11, nullptr, "GetNfcInfo"},
+        {12, nullptr, "StartNfcDiscovery"},
+        {13, nullptr, "StopNfcDiscovery"},
+        {14, nullptr, "StartNtagRead"},
+        {15, nullptr, "StartNtagWrite"},
+        {16, nullptr, "SendNfcRawData"},
+        {17, nullptr, "RegisterMifareKey"},
+        {18, nullptr, "ClearMifareKey"},
+        {19, nullptr, "StartMifareRead"},
+        {20, nullptr, "StartMifareWrite"},
+        {101, nullptr, "GetAwakeTriggerReasonForLeftRail"},
+        {102, nullptr, "GetAwakeTriggerReasonForRightRail"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+} // namespace Service::HID

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

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

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

@@ -0,0 +1,142 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <memory>
+
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/result.h"
+#include "core/hle/service/ldn/ldn.h"
+#include "core/hle/service/sm/sm.h"
+
+namespace Service::LDN {
+
+class IMonitorService final : public ServiceFramework<IMonitorService> {
+public:
+    explicit IMonitorService() : ServiceFramework{"IMonitorService"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetStateForMonitor"},
+            {1, nullptr, "GetNetworkInfoForMonitor"},
+            {2, nullptr, "GetIpv4AddressForMonitor"},
+            {3, nullptr, "GetDisconnectReasonForMonitor"},
+            {4, nullptr, "GetSecurityParameterForMonitor"},
+            {5, nullptr, "GetNetworkConfigForMonitor"},
+            {100, nullptr, "InitializeMonitor"},
+            {101, nullptr, "FinalizeMonitor"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class LDNM final : public ServiceFramework<LDNM> {
+public:
+    explicit LDNM() : ServiceFramework{"ldn:m"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &LDNM::CreateMonitorService, "CreateMonitorService"}
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+
+    void CreateMonitorService(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<IMonitorService>();
+
+        LOG_DEBUG(Service_LDN, "called");
+    }
+};
+
+class ILocalCommunicationService final : public ServiceFramework<ILocalCommunicationService> {
+public:
+    explicit ILocalCommunicationService(const char* name) : ServiceFramework{name} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetState"},
+            {1, nullptr, "GetNetworkInfo"},
+            {2, nullptr, "GetIpv4Address"},
+            {3, nullptr, "GetDisconnectReason"},
+            {4, nullptr, "GetSecurityParameter"},
+            {5, nullptr, "GetNetworkConfig"},
+            {100, nullptr, "AttachStateChangeEvent"},
+            {101, nullptr, "GetNetworkInfoLatestUpdate"},
+            {102, nullptr, "Scan"},
+            {103, nullptr, "ScanPrivate"},
+            {200, nullptr, "OpenAccessPoint"},
+            {201, nullptr, "CloseAccessPoint"},
+            {202, nullptr, "CreateNetwork"},
+            {203, nullptr, "CreateNetworkPrivate"},
+            {204, nullptr, "DestroyNetwork"},
+            {205, nullptr, "Reject"},
+            {206, nullptr, "SetAdvertiseData"},
+            {207, nullptr, "SetStationAcceptPolicy"},
+            {208, nullptr, "AddAcceptFilterEntry"},
+            {209, nullptr, "ClearAcceptFilter"},
+            {300, nullptr, "OpenStation"},
+            {301, nullptr, "CloseStation"},
+            {302, nullptr, "Connect"},
+            {303, nullptr, "ConnectPrivate"},
+            {304, nullptr, "Disconnect"},
+            {400, nullptr, "InitializeSystem"},
+            {401, nullptr, "FinalizeSystem"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class LDNS final : public ServiceFramework<LDNS> {
+public:
+    explicit LDNS() : ServiceFramework{"ldn:s"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &LDNS::CreateSystemLocalCommunicationService, "CreateSystemLocalCommunicationService"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+
+    void CreateSystemLocalCommunicationService(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<ILocalCommunicationService>("ISystemLocalCommunicationService");
+
+        LOG_DEBUG(Service_LDN, "called");
+    }
+};
+
+class LDNU final : public ServiceFramework<LDNU> {
+public:
+    explicit LDNU() : ServiceFramework{"ldn:u"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &LDNU::CreateUserLocalCommunicationService, "CreateUserLocalCommunicationService"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+
+    void CreateUserLocalCommunicationService(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<ILocalCommunicationService>("IUserLocalCommunicationService");
+
+        LOG_DEBUG(Service_LDN, "called");
+    }
+};
+
+void InstallInterfaces(SM::ServiceManager& sm) {
+    std::make_shared<LDNM>()->InstallAsService(sm);
+    std::make_shared<LDNS>()->InstallAsService(sm);
+    std::make_shared<LDNU>()->InstallAsService(sm);
+}
+
+} // namespace Service::LDN

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

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

src/core/hle/service/ldr/ldr.cpp

@@ -0,0 +1,81 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <memory>
+
+#include "core/hle/service/ldr/ldr.h"
+#include "core/hle/service/service.h"
+
+namespace Service::LDR {
+
+class DebugMonitor final : public ServiceFramework<DebugMonitor> {
+public:
+    explicit DebugMonitor() : ServiceFramework{"ldr:dmnt"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "AddProcessToDebugLaunchQueue"},
+            {1, nullptr, "ClearDebugLaunchQueue"},
+            {2, nullptr, "GetNsoInfos"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class ProcessManager final : public ServiceFramework<ProcessManager> {
+public:
+    explicit ProcessManager() : ServiceFramework{"ldr:pm"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "CreateProcess"},
+            {1, nullptr, "GetProgramInfo"},
+            {2, nullptr, "RegisterTitle"},
+            {3, nullptr, "UnregisterTitle"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class Shell final : public ServiceFramework<Shell> {
+public:
+    explicit Shell() : ServiceFramework{"ldr:shel"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "AddProcessToLaunchQueue"},
+            {1, nullptr, "ClearLaunchQueue"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class RelocatableObject final : public ServiceFramework<RelocatableObject> {
+public:
+    explicit RelocatableObject() : ServiceFramework{"ldr:ro"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "LoadNro"},
+            {1, nullptr, "UnloadNro"},
+            {2, nullptr, "LoadNrr"},
+            {3, nullptr, "UnloadNrr"},
+            {4, nullptr, "Initialize"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+void InstallInterfaces(SM::ServiceManager& sm) {
+    std::make_shared<DebugMonitor>()->InstallAsService(sm);
+    std::make_shared<ProcessManager>()->InstallAsService(sm);
+    std::make_shared<Shell>()->InstallAsService(sm);
+    std::make_shared<RelocatableObject>()->InstallAsService(sm);
+}
+
+} // namespace Service::LDR

src/core/hle/service/ldr/ldr.h

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

src/core/hle/service/lm/lm.cpp

@@ -4,10 +4,12 @@
 
 #include <sstream>
 #include <string>
+
 #include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/client_session.h"
 #include "core/hle/service/lm/lm.h"
+#include "core/hle/service/service.h"
+#include "core/memory.h"
 
 namespace Service::LM {
 
@@ -15,13 +17,12 @@ class Logger final : public ServiceFramework<Logger> {
 public:
     Logger() : ServiceFramework("Logger") {
         static const FunctionInfo functions[] = {
-            {0x00000000, &Logger::Log, "Log"},
+            {0x00000000, &Logger::Initialize, "Initialize"},
+            {0x00000001, nullptr, "SetDestination"},
         };
         RegisterHandlers(functions);
     }
 
-    ~Logger() = default;
-
 private:
     struct MessageHeader {
         enum Flags : u32_le {
@@ -66,13 +67,13 @@ private:
     };
 
     /**
-     * LM::Log service function
+     * ILogger::Initialize service function
      *  Inputs:
      *      0: 0x00000000
      *  Outputs:
      *      0: ResultCode
      */
-    void Log(Kernel::HLERequestContext& ctx) {
+    void Initialize(Kernel::HLERequestContext& ctx) {
         // This function only succeeds - Get that out of the way
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
@@ -162,30 +163,33 @@ private:
     std::ostringstream log_stream;
 };
 
+class LM final : public ServiceFramework<LM> {
+public:
+    explicit LM() : ServiceFramework{"lm"} {
+        static const FunctionInfo functions[] = {
+            {0x00000000, &LM::OpenLogger, "OpenLogger"},
+        };
+        RegisterHandlers(functions);
+    }
+
+    /**
+     * LM::OpenLogger service function
+     *  Inputs:
+     *      0: 0x00000000
+     *  Outputs:
+     *      0: ResultCode
+     */
+    void OpenLogger(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<Logger>();
+
+        LOG_DEBUG(Service_LM, "called");
+    }
+};
+
 void InstallInterfaces(SM::ServiceManager& service_manager) {
     std::make_shared<LM>()->InstallAsService(service_manager);
 }
 
-/**
- * LM::Initialize service function
- *  Inputs:
- *      0: 0x00000000
- *  Outputs:
- *      0: ResultCode
- */
-void LM::Initialize(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<Logger>();
-
-    LOG_DEBUG(Service_LM, "called");
-}
-
-LM::LM() : ServiceFramework("lm") {
-    static const FunctionInfo functions[] = {
-        {0x00000000, &LM::Initialize, "Initialize"},
-    };
-    RegisterHandlers(functions);
-}
-
 } // namespace Service::LM

src/core/hle/service/lm/lm.h

@@ -4,21 +4,12 @@
 
 #pragma once
 
-#include <vector>
-#include "core/hle/kernel/kernel.h"
-#include "core/hle/service/service.h"
+namespace Service::SM {
+class ServiceManager;
+}
 
 namespace Service::LM {
 
-class LM final : public ServiceFramework<LM> {
-public:
-    LM();
-    ~LM() = default;
-
-private:
-    void Initialize(Kernel::HLERequestContext& ctx);
-};
-
 /// Registers all LM services with the specified service manager.
 void InstallInterfaces(SM::ServiceManager& service_manager);
 

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

@@ -5,9 +5,7 @@
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/event.h"
 #include "core/hle/service/nifm/nifm.h"
-#include "core/hle/service/nifm/nifm_a.h"
-#include "core/hle/service/nifm/nifm_s.h"
-#include "core/hle/service/nifm/nifm_u.h"
+#include "core/hle/service/service.h"
 
 namespace Service::NIFM {
 
@@ -210,28 +208,35 @@ IGeneralService::IGeneralService() : ServiceFramework("IGeneralService") {
     RegisterHandlers(functions);
 }
 
-void Module::Interface::CreateGeneralServiceOld(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IGeneralService>();
-    LOG_DEBUG(Service_NIFM, "called");
-}
+class NetworkInterface final : public ServiceFramework<NetworkInterface> {
+public:
+    explicit NetworkInterface(const char* name) : ServiceFramework{name} {
+        static const FunctionInfo functions[] = {
+            {4, &NetworkInterface::CreateGeneralServiceOld, "CreateGeneralServiceOld"},
+            {5, &NetworkInterface::CreateGeneralService, "CreateGeneralService"},
+        };
+        RegisterHandlers(functions);
+    }
 
-void Module::Interface::CreateGeneralService(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IGeneralService>();
-    LOG_DEBUG(Service_NIFM, "called");
-}
+    void CreateGeneralServiceOld(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<IGeneralService>();
+        LOG_DEBUG(Service_NIFM, "called");
+    }
 
-Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
-    : ServiceFramework(name), module(std::move(module)) {}
+    void CreateGeneralService(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<IGeneralService>();
+        LOG_DEBUG(Service_NIFM, "called");
+    }
+};
 
 void InstallInterfaces(SM::ServiceManager& service_manager) {
-    auto module = std::make_shared<Module>();
-    std::make_shared<NIFM_A>(module)->InstallAsService(service_manager);
-    std::make_shared<NIFM_S>(module)->InstallAsService(service_manager);
-    std::make_shared<NIFM_U>(module)->InstallAsService(service_manager);
+    std::make_shared<NetworkInterface>("nifm:a")->InstallAsService(service_manager);
+    std::make_shared<NetworkInterface>("nifm:s")->InstallAsService(service_manager);
+    std::make_shared<NetworkInterface>("nifm:u")->InstallAsService(service_manager);
 }
 
 } // namespace Service::NIFM

src/core/hle/service/nifm/nifm.h

@@ -4,24 +4,13 @@
 
 #pragma once
 
-#include "core/hle/service/service.h"
+namespace Service::SM {
+class ServiceManager;
+}
 
 namespace Service::NIFM {
 
-class Module final {
-public:
-    class Interface : public ServiceFramework<Interface> {
-    public:
-        explicit Interface(std::shared_ptr<Module> module, const char* name);
-
-        void CreateGeneralServiceOld(Kernel::HLERequestContext& ctx);
-        void CreateGeneralService(Kernel::HLERequestContext& ctx);
-
-    protected:
-        std::shared_ptr<Module> module;
-    };
-};
-
+/// Registers all NIFM services with the specified service manager.
 void InstallInterfaces(SM::ServiceManager& service_manager);
 
 } // namespace Service::NIFM

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

@@ -1,17 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/service/nifm/nifm_a.h"
-
-namespace Service::NIFM {
-
-NIFM_A::NIFM_A(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "nifm:a") {
-    static const FunctionInfo functions[] = {
-        {4, &NIFM_A::CreateGeneralServiceOld, "CreateGeneralServiceOld"},
-        {5, &NIFM_A::CreateGeneralService, "CreateGeneralService"},
-    };
-    RegisterHandlers(functions);
-}
-
-} // namespace Service::NIFM

src/core/hle/service/nifm/nifm_a.h

@@ -1,16 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/nifm/nifm.h"
-
-namespace Service::NIFM {
-
-class NIFM_A final : public Module::Interface {
-public:
-    explicit NIFM_A(std::shared_ptr<Module> module);
-};
-
-} // namespace Service::NIFM

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

@@ -1,17 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/service/nifm/nifm_s.h"
-
-namespace Service::NIFM {
-
-NIFM_S::NIFM_S(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "nifm:s") {
-    static const FunctionInfo functions[] = {
-        {4, &NIFM_S::CreateGeneralServiceOld, "CreateGeneralServiceOld"},
-        {5, &NIFM_S::CreateGeneralService, "CreateGeneralService"},
-    };
-    RegisterHandlers(functions);
-}
-
-} // namespace Service::NIFM

src/core/hle/service/nifm/nifm_s.h

@@ -1,16 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/nifm/nifm.h"
-
-namespace Service::NIFM {
-
-class NIFM_S final : public Module::Interface {
-public:
-    explicit NIFM_S(std::shared_ptr<Module> module);
-};
-
-} // namespace Service::NIFM

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

@@ -1,17 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/service/nifm/nifm_u.h"
-
-namespace Service::NIFM {
-
-NIFM_U::NIFM_U(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "nifm:u") {
-    static const FunctionInfo functions[] = {
-        {4, &NIFM_U::CreateGeneralServiceOld, "CreateGeneralServiceOld"},
-        {5, &NIFM_U::CreateGeneralService, "CreateGeneralService"},
-    };
-    RegisterHandlers(functions);
-}
-
-} // namespace Service::NIFM

src/core/hle/service/nifm/nifm_u.h

@@ -1,16 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/nifm/nifm.h"
-
-namespace Service::NIFM {
-
-class NIFM_U final : public Module::Interface {
-public:
-    explicit NIFM_U(std::shared_ptr<Module> module);
-};
-
-} // namespace Service::NIFM

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

@@ -0,0 +1,124 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/service/nim/nim.h"
+#include "core/hle/service/service.h"
+#include "core/hle/service/sm/sm.h"
+
+namespace Service::NIM {
+
+class NIM final : public ServiceFramework<NIM> {
+public:
+    explicit NIM() : ServiceFramework{"nim"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "CreateSystemUpdateTask"},
+            {1, nullptr, "DestroySystemUpdateTask"},
+            {2, nullptr, "ListSystemUpdateTask"},
+            {3, nullptr, "RequestSystemUpdateTaskRun"},
+            {4, nullptr, "GetSystemUpdateTaskInfo"},
+            {5, nullptr, "CommitSystemUpdateTask"},
+            {6, nullptr, "CreateNetworkInstallTask"},
+            {7, nullptr, "DestroyNetworkInstallTask"},
+            {8, nullptr, "ListNetworkInstallTask"},
+            {9, nullptr, "RequestNetworkInstallTaskRun"},
+            {10, nullptr, "GetNetworkInstallTaskInfo"},
+            {11, nullptr, "CommitNetworkInstallTask"},
+            {12, nullptr, "RequestLatestSystemUpdateMeta"},
+            {14, nullptr, "ListApplicationNetworkInstallTask"},
+            {15, nullptr, "ListNetworkInstallTaskContentMeta"},
+            {16, nullptr, "RequestLatestVersion"},
+            {17, nullptr, "SetNetworkInstallTaskAttribute"},
+            {18, nullptr, "AddNetworkInstallTaskContentMeta"},
+            {19, nullptr, "GetDownloadedSystemDataPath"},
+            {20, nullptr, "CalculateNetworkInstallTaskRequiredSize"},
+            {21, nullptr, "IsExFatDriverIncluded"},
+            {22, nullptr, "GetBackgroundDownloadStressTaskInfo"},
+            {23, nullptr, "RequestDeviceAuthenticationToken"},
+            {24, nullptr, "RequestGameCardRegistrationStatus"},
+            {25, nullptr, "RequestRegisterGameCard"},
+            {26, nullptr, "RequestRegisterNotificationToken"},
+            {27, nullptr, "RequestDownloadTaskList"},
+            {28, nullptr, "RequestApplicationControl"},
+            {29, nullptr, "RequestLatestApplicationControl"},
+            {30, nullptr, "RequestVersionList"},
+            {31, nullptr, "CreateApplyDeltaTask"},
+            {32, nullptr, "DestroyApplyDeltaTask"},
+            {33, nullptr, "ListApplicationApplyDeltaTask"},
+            {34, nullptr, "RequestApplyDeltaTaskRun"},
+            {35, nullptr, "GetApplyDeltaTaskInfo"},
+            {36, nullptr, "ListApplyDeltaTask"},
+            {37, nullptr, "CommitApplyDeltaTask"},
+            {38, nullptr, "CalculateApplyDeltaTaskRequiredSize"},
+            {39, nullptr, "PrepareShutdown"},
+            {40, nullptr, "ListApplyDeltaTask"},
+            {41, nullptr, "ClearNotEnoughSpaceStateOfApplyDeltaTask"},
+            {42, nullptr, "Unknown1"},
+            {43, nullptr, "Unknown2"},
+            {44, nullptr, "Unknown3"},
+            {45, nullptr, "Unknown4"},
+            {46, nullptr, "Unknown5"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class NIM_SHP final : public ServiceFramework<NIM_SHP> {
+public:
+    explicit NIM_SHP() : ServiceFramework{"nim:shp"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "RequestDeviceAuthenticationToken"},
+            {1, nullptr, "RequestCachedDeviceAuthenticationToken"},
+            {100, nullptr, "RequestRegisterDeviceAccount"},
+            {101, nullptr, "RequestUnregisterDeviceAccount"},
+            {102, nullptr, "RequestDeviceAccountStatus"},
+            {103, nullptr, "GetDeviceAccountInfo"},
+            {104, nullptr, "RequestDeviceRegistrationInfo"},
+            {105, nullptr, "RequestTransferDeviceAccount"},
+            {106, nullptr, "RequestSyncRegistration"},
+            {107, nullptr, "IsOwnDeviceId"},
+            {200, nullptr, "RequestRegisterNotificationToken"},
+            {300, nullptr, "RequestUnlinkDevice"},
+            {301, nullptr, "RequestUnlinkDeviceIntegrated"},
+            {302, nullptr, "RequestLinkDevice"},
+            {303, nullptr, "HasDeviceLink"},
+            {304, nullptr, "RequestUnlinkDeviceAll"},
+            {305, nullptr, "RequestCreateVirtualAccount"},
+            {306, nullptr, "RequestDeviceLinkStatus"},
+            {400, nullptr, "GetAccountByVirtualAccount"},
+            {500, nullptr, "RequestSyncTicket"},
+            {501, nullptr, "RequestDownloadTicket"},
+            {502, nullptr, "RequestDownloadTicketForPrepurchasedContents"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class NTC final : public ServiceFramework<NTC> {
+public:
+    explicit NTC() : ServiceFramework{"ntc"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "OpenEnsureNetworkClockAvailabilityService"},
+            {100, nullptr, "SuspendAutonomicTimeCorrection"},
+            {101, nullptr, "ResumeAutonomicTimeCorrection"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+void InstallInterfaces(SM::ServiceManager& sm) {
+    std::make_shared<NIM>()->InstallAsService(sm);
+    std::make_shared<NIM_SHP>()->InstallAsService(sm);
+    std::make_shared<NTC>()->InstallAsService(sm);
+}
+
+} // namespace Service::NIM

src/core/hle/service/nim/nim.h

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

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

@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <utility>
+
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/nvdrv/devices/nvdevice.h"
 #include "core/hle/service/nvdrv/devices/nvdisp_disp0.h"
@@ -40,14 +42,14 @@ Module::Module() {
     devices["/dev/nvhost-nvdec"] = std::make_shared<Devices::nvhost_nvdec>();
 }
 
-u32 Module::Open(std::string device_name) {
+u32 Module::Open(const std::string& device_name) {
     ASSERT_MSG(devices.find(device_name) != devices.end(), "Trying to open unknown device {}",
                device_name);
 
     auto device = devices[device_name];
-    u32 fd = next_fd++;
+    const u32 fd = next_fd++;
 
-    open_files[fd] = device;
+    open_files[fd] = std::move(device);
 
     return fd;
 }
@@ -56,7 +58,7 @@ u32 Module::Ioctl(u32 fd, u32_le command, const std::vector<u8>& input, std::vec
     auto itr = open_files.find(fd);
     ASSERT_MSG(itr != open_files.end(), "Tried to talk to an invalid device");
 
-    auto device = itr->second;
+    auto& device = itr->second;
     return device->ioctl({command}, input, output);
 }
 

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

@@ -38,7 +38,7 @@ public:
     }
 
     /// Opens a device node and returns a file descriptor to it.
-    u32 Open(std::string device_name);
+    u32 Open(const std::string& device_name);
     /// Sends an ioctl command to the specified file descriptor.
     u32 Ioctl(u32 fd, u32 command, const std::vector<u8>& input, std::vector<u8>& output);
     /// Closes a device file descriptor and returns operation success.

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

@@ -9,6 +9,7 @@
 #include "common/scope_exit.h"
 #include "core/core.h"
 #include "core/core_timing.h"
+#include "core/core_timing_util.h"
 #include "core/hle/service/nvdrv/devices/nvdisp_disp0.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
 #include "core/hle/service/nvflinger/buffer_queue.h"

src/core/hle/service/pm/pm.cpp

@@ -0,0 +1,70 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/service/service.h"
+
+namespace Service::PM {
+
+class BootMode final : public ServiceFramework<BootMode> {
+public:
+    explicit BootMode() : ServiceFramework{"pm:bm"} {
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetBootMode"},
+            {1, nullptr, "SetMaintenanceBoot"},
+        };
+        RegisterHandlers(functions);
+    }
+};
+
+class DebugMonitor final : public ServiceFramework<DebugMonitor> {
+public:
+    explicit DebugMonitor() : ServiceFramework{"pm:dmnt"} {
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "IsDebugMode"},
+            {1, nullptr, "GetDebugProcesses"},
+            {2, nullptr, "StartDebugProcess"},
+            {3, nullptr, "GetTitlePid"},
+            {4, nullptr, "EnableDebugForTitleId"},
+            {5, nullptr, "GetApplicationPid"},
+            {6, nullptr, "EnableDebugForApplication"},
+        };
+        RegisterHandlers(functions);
+    }
+};
+
+class Info final : public ServiceFramework<Info> {
+public:
+    explicit Info() : ServiceFramework{"pm:info"} {
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetTitleId"},
+        };
+        RegisterHandlers(functions);
+    }
+};
+
+class Shell final : public ServiceFramework<Shell> {
+public:
+    explicit Shell() : ServiceFramework{"pm:shell"} {
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "LaunchProcess"},
+            {1, nullptr, "TerminateProcessByPid"},
+            {2, nullptr, "TerminateProcessByTitleId"},
+            {3, nullptr, "GetProcessEventWaiter"},
+            {4, nullptr, "GetProcessEventType"},
+            {5, nullptr, "NotifyBootFinished"},
+            {6, nullptr, "GetApplicationPid"},
+            {7, nullptr, "BoostSystemMemoryResourceLimit"},
+        };
+        RegisterHandlers(functions);
+    }
+};
+
+void InstallInterfaces(SM::ServiceManager& sm) {
+    std::make_shared<BootMode>()->InstallAsService(sm);
+    std::make_shared<DebugMonitor>()->InstallAsService(sm);
+    std::make_shared<Info>()->InstallAsService(sm);
+    std::make_shared<Shell>()->InstallAsService(sm);
+}
+
+} // namespace Service::PM

src/core/hle/service/pm/pm.h

@@ -0,0 +1,16 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+namespace Service::SM {
+class ServiceManager;
+}
+
+namespace Service::PM {
+
+/// Registers all PM services with the specified service manager.
+void InstallInterfaces(SM::ServiceManager& service_manager);
+
+} // namespace Service::PM

src/core/hle/service/service.cpp

@@ -21,17 +21,25 @@
 #include "core/hle/service/apm/apm.h"
 #include "core/hle/service/audio/audio.h"
 #include "core/hle/service/bcat/bcat.h"
+#include "core/hle/service/erpt/erpt.h"
+#include "core/hle/service/es/es.h"
+#include "core/hle/service/eupld/eupld.h"
 #include "core/hle/service/fatal/fatal.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/friend/friend.h"
+#include "core/hle/service/grc/grc.h"
 #include "core/hle/service/hid/hid.h"
+#include "core/hle/service/ldn/ldn.h"
+#include "core/hle/service/ldr/ldr.h"
 #include "core/hle/service/lm/lm.h"
 #include "core/hle/service/mm/mm_u.h"
 #include "core/hle/service/nfp/nfp.h"
 #include "core/hle/service/nifm/nifm.h"
+#include "core/hle/service/nim/nim.h"
 #include "core/hle/service/ns/ns.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
 #include "core/hle/service/pctl/pctl.h"
+#include "core/hle/service/pm/pm.h"
 #include "core/hle/service/prepo/prepo.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/set/settings.h"
@@ -187,18 +195,26 @@ void Init(std::shared_ptr<SM::ServiceManager>& sm) {
     APM::InstallInterfaces(*sm);
     BCAT::InstallInterfaces(*sm);
     Audio::InstallInterfaces(*sm);
+    ERPT::InstallInterfaces(*sm);
+    ES::InstallInterfaces(*sm);
+    EUPLD::InstallInterfaces(*sm);
     Fatal::InstallInterfaces(*sm);
     FileSystem::InstallInterfaces(*sm);
     Friend::InstallInterfaces(*sm);
+    GRC::InstallInterfaces(*sm);
     HID::InstallInterfaces(*sm);
+    LDN::InstallInterfaces(*sm);
+    LDR::InstallInterfaces(*sm);
     LM::InstallInterfaces(*sm);
     MM::InstallInterfaces(*sm);
     NFP::InstallInterfaces(*sm);
     NIFM::InstallInterfaces(*sm);
+    NIM::InstallInterfaces(*sm);
     NS::InstallInterfaces(*sm);
     Nvidia::InstallInterfaces(*sm);
     PCTL::InstallInterfaces(*sm);
     PlayReport::InstallInterfaces(*sm);
+    PM::InstallInterfaces(*sm);
     Sockets::InstallInterfaces(*sm);
     SPL::InstallInterfaces(*sm);
     SSL::InstallInterfaces(*sm);

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

@@ -10,13 +10,22 @@
 namespace Service::Set {
 
 void SET_SYS::GetColorSetId(Kernel::HLERequestContext& ctx) {
-
     IPC::ResponseBuilder rb{ctx, 3};
 
     rb.Push(RESULT_SUCCESS);
-    rb.Push<u32>(0);
+    rb.PushEnum(color_set);
 
-    LOG_WARNING(Service_SET, "(STUBBED) called");
+    LOG_DEBUG(Service_SET, "called");
+}
+
+void SET_SYS::SetColorSetId(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    color_set = rp.PopEnum<ColorSet>();
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+
+    LOG_DEBUG(Service_SET, "called");
 }
 
 SET_SYS::SET_SYS() : ServiceFramework("set:sys") {
@@ -44,7 +53,7 @@ SET_SYS::SET_SYS() : ServiceFramework("set:sys") {
         {21, nullptr, "GetEulaVersions"},
         {22, nullptr, "SetEulaVersions"},
         {23, &SET_SYS::GetColorSetId, "GetColorSetId"},
-        {24, nullptr, "SetColorSetId"},
+        {24, &SET_SYS::SetColorSetId, "SetColorSetId"},
         {25, nullptr, "GetConsoleInformationUploadFlag"},
         {26, nullptr, "SetConsoleInformationUploadFlag"},
         {27, nullptr, "GetAutomaticApplicationDownloadFlag"},
@@ -172,4 +181,6 @@ SET_SYS::SET_SYS() : ServiceFramework("set:sys") {
     RegisterHandlers(functions);
 }
 
+SET_SYS::~SET_SYS() = default;
+
 } // namespace Service::Set

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

@@ -11,10 +11,19 @@ namespace Service::Set {
 class SET_SYS final : public ServiceFramework<SET_SYS> {
 public:
     explicit SET_SYS();
-    ~SET_SYS() = default;
+    ~SET_SYS() override;
 
 private:
+    /// Indicates the current theme set by the system settings
+    enum class ColorSet : u32 {
+        BasicWhite = 0,
+        BasicBlack = 1,
+    };
+
     void GetColorSetId(Kernel::HLERequestContext& ctx);
+    void SetColorSetId(Kernel::HLERequestContext& ctx);
+
+    ColorSet color_set = ColorSet::BasicWhite;
 };
 
 } // namespace Service::Set

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

@@ -109,4 +109,26 @@ BSD::BSD(const char* name) : ServiceFramework(name) {
     RegisterHandlers(functions);
 }
 
+BSDCFG::BSDCFG() : ServiceFramework{"bsdcfg"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "SetIfUp"},
+        {1, nullptr, "SetIfUpWithEvent"},
+        {2, nullptr, "CancelIf"},
+        {3, nullptr, "SetIfDown"},
+        {4, nullptr, "GetIfState"},
+        {5, nullptr, "DhcpRenew"},
+        {6, nullptr, "AddStaticArpEntry"},
+        {7, nullptr, "RemoveArpEntry"},
+        {8, nullptr, "LookupArpEntry"},
+        {9, nullptr, "LookupArpEntry2"},
+        {10, nullptr, "ClearArpEntries"},
+        {11, nullptr, "ClearArpEntries2"},
+        {12, nullptr, "PrintArpEntries"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
 } // namespace Service::Sockets

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

@@ -26,4 +26,9 @@ private:
     u32 next_fd = 1;
 };
 
+class BSDCFG final : public ServiceFramework<BSDCFG> {
+public:
+    explicit BSDCFG();
+};
+
 } // namespace Service::Sockets

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

@@ -0,0 +1,38 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/service/sockets/ethc.h"
+
+namespace Service::Sockets {
+
+ETHC_C::ETHC_C() : ServiceFramework{"ethc:c"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "Initialize"},
+        {1, nullptr, "Cancel"},
+        {2, nullptr, "GetResult"},
+        {3, nullptr, "GetMediaList"},
+        {4, nullptr, "SetMediaType"},
+        {5, nullptr, "GetMediaType"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+ETHC_I::ETHC_I() : ServiceFramework{"ethc:i"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "GetReadableHandle"},
+        {1, nullptr, "Cancel"},
+        {2, nullptr, "GetResult"},
+        {3, nullptr, "GetInterfaceList"},
+        {4, nullptr, "GetInterfaceCount"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+} // namespace Service::Sockets

src/core/hle/service/sockets/ethc.h

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

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

@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.
 
 #include "core/hle/service/sockets/bsd.h"
+#include "core/hle/service/sockets/ethc.h"
 #include "core/hle/service/sockets/nsd.h"
 #include "core/hle/service/sockets/sfdnsres.h"
 #include "core/hle/service/sockets/sockets.h"
@@ -12,8 +13,14 @@ namespace Service::Sockets {
 void InstallInterfaces(SM::ServiceManager& service_manager) {
     std::make_shared<BSD>("bsd:s")->InstallAsService(service_manager);
     std::make_shared<BSD>("bsd:u")->InstallAsService(service_manager);
+    std::make_shared<BSDCFG>()->InstallAsService(service_manager);
+
+    std::make_shared<ETHC_C>()->InstallAsService(service_manager);
+    std::make_shared<ETHC_I>()->InstallAsService(service_manager);
+
     std::make_shared<NSD>("nsd:a")->InstallAsService(service_manager);
     std::make_shared<NSD>("nsd:u")->InstallAsService(service_manager);
+
     std::make_shared<SFDNSRES>()->InstallAsService(service_manager);
 }
 

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

@@ -2,17 +2,18 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "core/hle/service/time/time_s.h"
+#include "core/hle/service/time/interface.h"
 
 namespace Service::Time {
 
-TIME_S::TIME_S(std::shared_ptr<Module> time) : Module::Interface(std::move(time), "time:s") {
+Time::Time(std::shared_ptr<Module> time, const char* name)
+    : Module::Interface(std::move(time), name) {
     static const FunctionInfo functions[] = {
-        {0, &TIME_S::GetStandardUserSystemClock, "GetStandardUserSystemClock"},
-        {1, &TIME_S::GetStandardNetworkSystemClock, "GetStandardNetworkSystemClock"},
-        {2, &TIME_S::GetStandardSteadyClock, "GetStandardSteadyClock"},
-        {3, &TIME_S::GetTimeZoneService, "GetTimeZoneService"},
-        {4, &TIME_S::GetStandardLocalSystemClock, "GetStandardLocalSystemClock"},
+        {0, &Time::GetStandardUserSystemClock, "GetStandardUserSystemClock"},
+        {1, &Time::GetStandardNetworkSystemClock, "GetStandardNetworkSystemClock"},
+        {2, &Time::GetStandardSteadyClock, "GetStandardSteadyClock"},
+        {3, &Time::GetTimeZoneService, "GetTimeZoneService"},
+        {4, &Time::GetStandardLocalSystemClock, "GetStandardLocalSystemClock"},
         {5, nullptr, "GetEphemeralNetworkSystemClock"},
         {50, nullptr, "SetStandardSteadyClockInternalOffset"},
         {100, nullptr, "IsStandardUserSystemClockAutomaticCorrectionEnabled"},

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

@@ -8,9 +8,9 @@
 
 namespace Service::Time {
 
-class TIME_S final : public Module::Interface {
+class Time final : public Module::Interface {
 public:
-    explicit TIME_S(std::shared_ptr<Module> time);
+    explicit Time(std::shared_ptr<Module> time, const char* name);
 };
 
 } // namespace Service::Time

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

@@ -6,12 +6,12 @@
 #include <ctime>
 #include "common/logging/log.h"
 #include "core/core_timing.h"
+#include "core/core_timing_util.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/client_session.h"
+#include "core/hle/service/time/interface.h"
 #include "core/hle/service/time/time.h"
-#include "core/hle/service/time/time_s.h"
-#include "core/hle/service/time/time_u.h"
 
 namespace Service::Time {
 
@@ -212,8 +212,9 @@ Module::Interface::Interface(std::shared_ptr<Module> time, const char* name)
 
 void InstallInterfaces(SM::ServiceManager& service_manager) {
     auto time = std::make_shared<Module>();
-    std::make_shared<TIME_S>(time)->InstallAsService(service_manager);
-    std::make_shared<TIME_U>(time)->InstallAsService(service_manager);
+    std::make_shared<Time>(time, "time:a")->InstallAsService(service_manager);
+    std::make_shared<Time>(time, "time:s")->InstallAsService(service_manager);
+    std::make_shared<Time>(time, "time:u")->InstallAsService(service_manager);
 }
 
 } // namespace Service::Time

src/core/hle/service/time/time_u.cpp

@@ -1,31 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/service/time/time_u.h"
-
-namespace Service::Time {
-
-TIME_U::TIME_U(std::shared_ptr<Module> time) : Module::Interface(std::move(time), "time:u") {
-    static const FunctionInfo functions[] = {
-        {0, &TIME_U::GetStandardUserSystemClock, "GetStandardUserSystemClock"},
-        {1, &TIME_U::GetStandardNetworkSystemClock, "GetStandardNetworkSystemClock"},
-        {2, &TIME_U::GetStandardSteadyClock, "GetStandardSteadyClock"},
-        {3, &TIME_U::GetTimeZoneService, "GetTimeZoneService"},
-        {4, &TIME_U::GetStandardLocalSystemClock, "GetStandardLocalSystemClock"},
-        {5, nullptr, "GetEphemeralNetworkSystemClock"},
-        {50, nullptr, "SetStandardSteadyClockInternalOffset"},
-        {100, nullptr, "IsStandardUserSystemClockAutomaticCorrectionEnabled"},
-        {101, nullptr, "SetStandardUserSystemClockAutomaticCorrectionEnabled"},
-        {102, nullptr, "GetStandardUserSystemClockInitialYear"},
-        {200, nullptr, "IsStandardNetworkSystemClockAccuracySufficient"},
-        {300, nullptr, "CalculateMonotonicSystemClockBaseTimePoint"},
-        {400, nullptr, "GetClockSnapshot"},
-        {401, nullptr, "GetClockSnapshotFromSystemClockContext"},
-        {500, nullptr, "CalculateStandardUserSystemClockDifferenceByUser"},
-        {501, nullptr, "CalculateSpanBetween"},
-    };
-    RegisterHandlers(functions);
-}
-
-} // namespace Service::Time

src/core/hle/service/time/time_u.h

@@ -1,16 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/time/time.h"
-
-namespace Service::Time {
-
-class TIME_U final : public Module::Interface {
-public:
-    explicit TIME_U(std::shared_ptr<Module> time);
-};
-
-} // namespace Service::Time

src/core/loader/deconstructed_rom_directory.cpp

@@ -6,7 +6,6 @@
 #include "common/common_funcs.h"
 #include "common/file_util.h"
 #include "common/logging/log.h"
-#include "common/string_util.h"
 #include "core/file_sys/content_archive.h"
 #include "core/gdbstub/gdbstub.h"
 #include "core/hle/kernel/process.h"
@@ -18,34 +17,6 @@
 
 namespace Loader {
 
-static std::string FindRomFS(const std::string& directory) {
-    std::string filepath_romfs;
-    const auto callback = [&filepath_romfs](u64*, const std::string& directory,
-                                            const std::string& virtual_name) -> bool {
-        const std::string physical_name = directory + virtual_name;
-        if (FileUtil::IsDirectory(physical_name)) {
-            // Skip directories
-            return true;
-        }
-
-        // Verify extension
-        const std::string extension = physical_name.substr(physical_name.find_last_of(".") + 1);
-        if (Common::ToLower(extension) != "romfs") {
-            return true;
-        }
-
-        // Found it - we are done
-        filepath_romfs = std::move(physical_name);
-        return false;
-    };
-
-    // Search the specified directory recursively, looking for the first .romfs file, which will
-    // be used for the RomFS
-    FileUtil::ForeachDirectoryEntry(nullptr, directory, callback);
-
-    return filepath_romfs;
-}
-
 AppLoader_DeconstructedRomDirectory::AppLoader_DeconstructedRomDirectory(FileSys::VirtualFile file)
     : AppLoader(std::move(file)) {}
 

src/video_core/engines/maxwell_3d.cpp

@@ -75,14 +75,6 @@ void Maxwell3D::WriteReg(u32 method, u32 value, u32 remaining_params) {
         ProcessMacroUpload(value);
         break;
     }
-    case MAXWELL3D_REG_INDEX(code_address.code_address_high):
-    case MAXWELL3D_REG_INDEX(code_address.code_address_low): {
-        // Note: For some reason games (like Puyo Puyo Tetris) seem to write 0 to the CODE_ADDRESS
-        // register, we do not currently know if that's intended or a bug, so we assert it lest
-        // stuff breaks in other places (like the shader address calculation).
-        ASSERT_MSG(regs.code_address.CodeAddress() == 0, "Unexpected CODE_ADDRESS register value.");
-        break;
-    }
     case MAXWELL3D_REG_INDEX(const_buffer.cb_data[0]):
     case MAXWELL3D_REG_INDEX(const_buffer.cb_data[1]):
     case MAXWELL3D_REG_INDEX(const_buffer.cb_data[2]):

src/video_core/gpu.h

@@ -23,7 +23,14 @@ enum class RenderTargetFormat : u32 {
     RGB10_A2_UNORM = 0xD1,
     RGBA8_UNORM = 0xD5,
     RGBA8_SRGB = 0xD6,
+    RG16_UNORM = 0xDA,
+    RG16_SNORM = 0xDB,
+    RG16_SINT = 0xDC,
+    RG16_UINT = 0xDD,
+    RG16_FLOAT = 0xDE,
     R11G11B10_FLOAT = 0xE0,
+    R16_FLOAT = 0xF2,
+    R8_UNORM = 0xF3,
 };
 
 enum class DepthFormat : u32 {
@@ -33,6 +40,7 @@ enum class DepthFormat : u32 {
     Z24_X8_UNORM = 0x15,
     Z24_S8_UNORM = 0x16,
     Z24_C8_UNORM = 0x18,
+    Z32_S8_X24_FLOAT = 0x19,
 };
 
 /// Returns the number of bytes per pixel of each rendertarget format.

src/video_core/memory_manager.cpp

@@ -13,8 +13,10 @@ GPUVAddr MemoryManager::AllocateSpace(u64 size, u64 align) {
     ASSERT(gpu_addr);
 
     for (u64 offset = 0; offset < size; offset += PAGE_SIZE) {
-        ASSERT(PageSlot(*gpu_addr + offset) == static_cast<u64>(PageStatus::Unmapped));
-        PageSlot(*gpu_addr + offset) = static_cast<u64>(PageStatus::Allocated);
+        VAddr& slot = PageSlot(*gpu_addr + offset);
+
+        ASSERT(slot == static_cast<u64>(PageStatus::Unmapped));
+        slot = static_cast<u64>(PageStatus::Allocated);
     }
 
     return *gpu_addr;
@@ -22,8 +24,10 @@ GPUVAddr MemoryManager::AllocateSpace(u64 size, u64 align) {
 
 GPUVAddr MemoryManager::AllocateSpace(GPUVAddr gpu_addr, u64 size, u64 align) {
     for (u64 offset = 0; offset < size; offset += PAGE_SIZE) {
-        ASSERT(PageSlot(gpu_addr + offset) == static_cast<u64>(PageStatus::Unmapped));
-        PageSlot(gpu_addr + offset) = static_cast<u64>(PageStatus::Allocated);
+        VAddr& slot = PageSlot(gpu_addr + offset);
+
+        ASSERT(slot == static_cast<u64>(PageStatus::Unmapped));
+        slot = static_cast<u64>(PageStatus::Allocated);
     }
 
     return gpu_addr;
@@ -34,8 +38,10 @@ GPUVAddr MemoryManager::MapBufferEx(VAddr cpu_addr, u64 size) {
     ASSERT(gpu_addr);
 
     for (u64 offset = 0; offset < size; offset += PAGE_SIZE) {
-        ASSERT(PageSlot(*gpu_addr + offset) == static_cast<u64>(PageStatus::Unmapped));
-        PageSlot(*gpu_addr + offset) = cpu_addr + offset;
+        VAddr& slot = PageSlot(*gpu_addr + offset);
+
+        ASSERT(slot == static_cast<u64>(PageStatus::Unmapped));
+        slot = cpu_addr + offset;
     }
 
     MappedRegion region{cpu_addr, *gpu_addr, size};
@@ -48,8 +54,10 @@ GPUVAddr MemoryManager::MapBufferEx(VAddr cpu_addr, GPUVAddr gpu_addr, u64 size)
     ASSERT((gpu_addr & PAGE_MASK) == 0);
 
     for (u64 offset = 0; offset < size; offset += PAGE_SIZE) {
-        ASSERT(PageSlot(gpu_addr + offset) == static_cast<u64>(PageStatus::Allocated));
-        PageSlot(gpu_addr + offset) = cpu_addr + offset;
+        VAddr& slot = PageSlot(gpu_addr + offset);
+
+        ASSERT(slot == static_cast<u64>(PageStatus::Allocated));
+        slot = cpu_addr + offset;
     }
 
     MappedRegion region{cpu_addr, gpu_addr, size};
@@ -62,9 +70,11 @@ GPUVAddr MemoryManager::UnmapBuffer(GPUVAddr gpu_addr, u64 size) {
     ASSERT((gpu_addr & PAGE_MASK) == 0);
 
     for (u64 offset = 0; offset < size; offset += PAGE_SIZE) {
-        ASSERT(PageSlot(gpu_addr + offset) != static_cast<u64>(PageStatus::Allocated) &&
-               PageSlot(gpu_addr + offset) != static_cast<u64>(PageStatus::Unmapped));
-        PageSlot(gpu_addr + offset) = static_cast<u64>(PageStatus::Unmapped);
+        VAddr& slot = PageSlot(gpu_addr + offset);
+
+        ASSERT(slot != static_cast<u64>(PageStatus::Allocated) &&
+               slot != static_cast<u64>(PageStatus::Unmapped));
+        slot = static_cast<u64>(PageStatus::Unmapped);
     }
 
     // Delete the region mappings that are contained within the unmapped region
@@ -128,9 +138,7 @@ VAddr& MemoryManager::PageSlot(GPUVAddr gpu_addr) {
     auto& block = page_table[(gpu_addr >> (PAGE_BITS + PAGE_TABLE_BITS)) & PAGE_TABLE_MASK];
     if (!block) {
         block = std::make_unique<PageBlock>();
-        for (unsigned index = 0; index < PAGE_BLOCK_SIZE; index++) {
-            (*block)[index] = static_cast<u64>(PageStatus::Unmapped);
-        }
+        block->fill(static_cast<VAddr>(PageStatus::Unmapped));
     }
     return (*block)[(gpu_addr >> PAGE_BITS) & PAGE_BLOCK_MASK];
 }

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -5,6 +5,7 @@
 #include <algorithm>
 #include <memory>
 #include <string>
+#include <string_view>
 #include <tuple>
 #include <utility>
 #include <glad/glad.h>
@@ -37,11 +38,6 @@ MICROPROFILE_DEFINE(OpenGL_Blits, "OpenGL", "Blits", MP_RGB(100, 100, 255));
 MICROPROFILE_DEFINE(OpenGL_CacheManagement, "OpenGL", "Cache Mgmt", MP_RGB(100, 255, 100));
 
 RasterizerOpenGL::RasterizerOpenGL() {
-    has_ARB_buffer_storage = false;
-    has_ARB_direct_state_access = false;
-    has_ARB_separate_shader_objects = false;
-    has_ARB_vertex_attrib_binding = false;
-
     // Create sampler objects
     for (size_t i = 0; i < texture_samplers.size(); ++i) {
         texture_samplers[i].Create();
@@ -59,7 +55,8 @@ RasterizerOpenGL::RasterizerOpenGL() {
     GLint ext_num;
     glGetIntegerv(GL_NUM_EXTENSIONS, &ext_num);
     for (GLint i = 0; i < ext_num; i++) {
-        std::string extension{reinterpret_cast<const char*>(glGetStringi(GL_EXTENSIONS, i))};
+        const std::string_view extension{
+            reinterpret_cast<const char*>(glGetStringi(GL_EXTENSIONS, i))};
 
         if (extension == "GL_ARB_buffer_storage") {
             has_ARB_buffer_storage = true;
@@ -110,8 +107,6 @@ RasterizerOpenGL::RasterizerOpenGL() {
         glBindBufferBase(GL_UNIFORM_BUFFER, index, buffer.handle);
     }
 
-    accelerate_draw = AccelDraw::Disabled;
-
     glEnable(GL_BLEND);
 
     LOG_CRITICAL(Render_OpenGL, "Sync fixed function OpenGL state here!");
@@ -694,10 +689,12 @@ u32 RasterizerOpenGL::SetupConstBuffers(Maxwell::ShaderStage stage, GLuint progr
         glBindBuffer(GL_UNIFORM_BUFFER, 0);
 
         // Now configure the bindpoint of the buffer inside the shader
-        std::string buffer_name = used_buffer.GetName();
-        GLuint index = glGetProgramResourceIndex(program, GL_UNIFORM_BLOCK, buffer_name.c_str());
-        if (index != -1)
+        const std::string buffer_name = used_buffer.GetName();
+        const GLuint index =
+            glGetProgramResourceIndex(program, GL_UNIFORM_BLOCK, buffer_name.c_str());
+        if (index != GL_INVALID_INDEX) {
             glUniformBlockBinding(program, index, buffer_draw_state.bindpoint);
+        }
     }
 
     state.Apply();

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -135,10 +135,10 @@ private:
     /// Syncs the blend state to match the guest state
     void SyncBlendState();
 
-    bool has_ARB_buffer_storage;
-    bool has_ARB_direct_state_access;
-    bool has_ARB_separate_shader_objects;
-    bool has_ARB_vertex_attrib_binding;
+    bool has_ARB_buffer_storage = false;
+    bool has_ARB_direct_state_access = false;
+    bool has_ARB_separate_shader_objects = false;
+    bool has_ARB_vertex_attrib_binding = false;
 
     OpenGLState state;
 
@@ -167,5 +167,5 @@ private:
     void SetupShaders(u8* buffer_ptr, GLintptr buffer_offset);
 
     enum class AccelDraw { Disabled, Arrays, Indexed };
-    AccelDraw accelerate_draw;
+    AccelDraw accelerate_draw = AccelDraw::Disabled;
 };

src/video_core/renderer_opengl/gl_rasterizer_cache.cpp

@@ -104,15 +104,21 @@ static constexpr std::array<FormatTuple, SurfaceParams::MaxPixelFormat> tex_form
      true},                                                                                 // DXT45
     {GL_COMPRESSED_RED_RGTC1, GL_RED, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm, true}, // DXN1
     {GL_COMPRESSED_RGBA_BPTC_UNORM_ARB, GL_RGB, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
-     true},                                                             // BC7U
-    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_4X4
-    {GL_RG8, GL_RG, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},     // G8R8
-    {GL_RGBA8, GL_BGRA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // BGRA8
-    {GL_RGBA32F, GL_RGBA, GL_FLOAT, ComponentType::Float, false},       // RGBA32F
-    {GL_RG32F, GL_RG, GL_FLOAT, ComponentType::Float, false},           // RG32F
-    {GL_R32F, GL_RED, GL_FLOAT, ComponentType::Float, false},           // R32F
-    {GL_R16F, GL_RED, GL_HALF_FLOAT, ComponentType::Float, false},      // R16F
-    {GL_R16, GL_RED, GL_UNSIGNED_SHORT, ComponentType::UNorm, false},   // R16UNORM
+     true},                                                                    // BC7U
+    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},        // ASTC_2D_4X4
+    {GL_RG8, GL_RG, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},            // G8R8
+    {GL_RGBA8, GL_BGRA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},        // BGRA8
+    {GL_RGBA32F, GL_RGBA, GL_FLOAT, ComponentType::Float, false},              // RGBA32F
+    {GL_RG32F, GL_RG, GL_FLOAT, ComponentType::Float, false},                  // RG32F
+    {GL_R32F, GL_RED, GL_FLOAT, ComponentType::Float, false},                  // R32F
+    {GL_R16F, GL_RED, GL_HALF_FLOAT, ComponentType::Float, false},             // R16F
+    {GL_R16, GL_RED, GL_UNSIGNED_SHORT, ComponentType::UNorm, false},          // R16UNORM
+    {GL_RG16, GL_RG, GL_UNSIGNED_SHORT, ComponentType::UNorm, false},          // RG16
+    {GL_RG16F, GL_RG, GL_HALF_FLOAT, ComponentType::Float, false},             // RG16F
+    {GL_RG16UI, GL_RG_INTEGER, GL_UNSIGNED_SHORT, ComponentType::UInt, false}, // RG16UI
+    {GL_RG16I, GL_RG_INTEGER, GL_SHORT, ComponentType::SInt, false},           // RG16I
+    {GL_RG16_SNORM, GL_RG, GL_SHORT, ComponentType::SNorm, false},             // RG16S
+    {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, ComponentType::UNorm, false}, // SRGBA8
 
     // DepthStencil formats
     {GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, ComponentType::UNorm,
@@ -122,6 +128,8 @@ static constexpr std::array<FormatTuple, SurfaceParams::MaxPixelFormat> tex_form
     {GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_FLOAT, ComponentType::Float, false}, // Z32F
     {GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, ComponentType::UNorm,
      false}, // Z16
+    {GL_DEPTH32F_STENCIL8, GL_DEPTH_STENCIL, GL_FLOAT_32_UNSIGNED_INT_24_8_REV,
+     ComponentType::Float, false}, // Z32FS8
 }};
 
 static const FormatTuple& GetFormatTuple(PixelFormat pixel_format, ComponentType component_type) {
@@ -207,9 +215,12 @@ static constexpr std::array<void (*)(u32, u32, u32, u8*, Tegra::GPUVAddr),
         MortonCopy<true, PixelFormat::G8R8>,         MortonCopy<true, PixelFormat::BGRA8>,
         MortonCopy<true, PixelFormat::RGBA32F>,      MortonCopy<true, PixelFormat::RG32F>,
         MortonCopy<true, PixelFormat::R32F>,         MortonCopy<true, PixelFormat::R16F>,
-        MortonCopy<true, PixelFormat::R16UNORM>,     MortonCopy<true, PixelFormat::Z24S8>,
+        MortonCopy<true, PixelFormat::R16UNORM>,     MortonCopy<true, PixelFormat::RG16>,
+        MortonCopy<true, PixelFormat::RG16F>,        MortonCopy<true, PixelFormat::RG16UI>,
+        MortonCopy<true, PixelFormat::RG16I>,        MortonCopy<true, PixelFormat::RG16S>,
+        MortonCopy<true, PixelFormat::SRGBA8>,       MortonCopy<true, PixelFormat::Z24S8>,
         MortonCopy<true, PixelFormat::S8Z24>,        MortonCopy<true, PixelFormat::Z32F>,
-        MortonCopy<true, PixelFormat::Z16>,
+        MortonCopy<true, PixelFormat::Z16>,          MortonCopy<true, PixelFormat::Z32FS8>,
 };
 
 static constexpr std::array<void (*)(u32, u32, u32, u8*, Tegra::GPUVAddr),
@@ -237,10 +248,17 @@ static constexpr std::array<void (*)(u32, u32, u32, u8*, Tegra::GPUVAddr),
         MortonCopy<false, PixelFormat::R32F>,
         MortonCopy<false, PixelFormat::R16F>,
         MortonCopy<false, PixelFormat::R16UNORM>,
+        MortonCopy<false, PixelFormat::RG16>,
+        MortonCopy<false, PixelFormat::RG16F>,
+        MortonCopy<false, PixelFormat::RG16UI>,
+        MortonCopy<false, PixelFormat::RG16I>,
+        MortonCopy<false, PixelFormat::RG16S>,
+        MortonCopy<false, PixelFormat::SRGBA8>,
         MortonCopy<false, PixelFormat::Z24S8>,
         MortonCopy<false, PixelFormat::S8Z24>,
         MortonCopy<false, PixelFormat::Z32F>,
         MortonCopy<false, PixelFormat::Z16>,
+        MortonCopy<false, PixelFormat::Z32FS8>,
 };
 
 // Allocate an uninitialized texture of appropriate size and format for the surface

src/video_core/renderer_opengl/gl_rasterizer_cache.h

@@ -43,14 +43,21 @@ struct SurfaceParams {
         R32F = 18,
         R16F = 19,
         R16UNORM = 20,
+        RG16 = 21,
+        RG16F = 22,
+        RG16UI = 23,
+        RG16I = 24,
+        RG16S = 25,
+        SRGBA8 = 26,
 
         MaxColorFormat,
 
         // DepthStencil formats
-        Z24S8 = 21,
-        S8Z24 = 22,
-        Z32F = 23,
-        Z16 = 24,
+        Z24S8 = 27,
+        S8Z24 = 28,
+        Z32F = 29,
+        Z16 = 30,
+        Z32FS8 = 31,
 
         MaxDepthStencilFormat,
 
@@ -109,10 +116,17 @@ struct SurfaceParams {
             1, // R32F
             1, // R16F
             1, // R16UNORM
+            1, // RG16
+            1, // RG16F
+            1, // RG16UI
+            1, // RG16I
+            1, // RG16S
+            1, // SRGBA8
             1, // Z24S8
             1, // S8Z24
             1, // Z32F
             1, // Z16
+            1, // Z32FS8
         }};
 
         ASSERT(static_cast<size_t>(format) < compression_factor_table.size());
@@ -145,10 +159,17 @@ struct SurfaceParams {
             32,  // R32F
             16,  // R16F
             16,  // R16UNORM
+            32,  // RG16
+            32,  // RG16F
+            32,  // RG16UI
+            32,  // RG16I
+            32,  // RG16S
+            32,  // SRGBA8
             32,  // Z24S8
             32,  // S8Z24
             32,  // Z32F
             16,  // Z16
+            64,  // Z32FS8
         }};
 
         ASSERT(static_cast<size_t>(format) < bpp_table.size());
@@ -169,6 +190,8 @@ struct SurfaceParams {
             return PixelFormat::Z32F;
         case Tegra::DepthFormat::Z16_UNORM:
             return PixelFormat::Z16;
+        case Tegra::DepthFormat::Z32_S8_X24_FLOAT:
+            return PixelFormat::Z32FS8;
         default:
             LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
             UNREACHABLE();
@@ -177,8 +200,10 @@ struct SurfaceParams {
 
     static PixelFormat PixelFormatFromRenderTargetFormat(Tegra::RenderTargetFormat format) {
         switch (format) {
-        case Tegra::RenderTargetFormat::RGBA8_UNORM:
+        // TODO (Hexagon12): Converting SRGBA to RGBA is a hack and doesn't completely correct the
+        // gamma.
         case Tegra::RenderTargetFormat::RGBA8_SRGB:
+        case Tegra::RenderTargetFormat::RGBA8_UNORM:
             return PixelFormat::ABGR8;
         case Tegra::RenderTargetFormat::BGRA8_UNORM:
             return PixelFormat::BGRA8;
@@ -194,6 +219,20 @@ struct SurfaceParams {
             return PixelFormat::R11FG11FB10F;
         case Tegra::RenderTargetFormat::RGBA32_UINT:
             return PixelFormat::RGBA32UI;
+        case Tegra::RenderTargetFormat::R8_UNORM:
+            return PixelFormat::R8;
+        case Tegra::RenderTargetFormat::RG16_FLOAT:
+            return PixelFormat::RG16F;
+        case Tegra::RenderTargetFormat::RG16_UINT:
+            return PixelFormat::RG16UI;
+        case Tegra::RenderTargetFormat::RG16_SINT:
+            return PixelFormat::RG16I;
+        case Tegra::RenderTargetFormat::RG16_UNORM:
+            return PixelFormat::RG16;
+        case Tegra::RenderTargetFormat::RG16_SNORM:
+            return PixelFormat::RG16S;
+        case Tegra::RenderTargetFormat::R16_FLOAT:
+            return PixelFormat::R16F;
         default:
             LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
             UNREACHABLE();
@@ -244,6 +283,10 @@ struct SurfaceParams {
             UNREACHABLE();
         case Tegra::Texture::TextureFormat::R32:
             return PixelFormat::R32F;
+        case Tegra::Texture::TextureFormat::ZF32:
+            return PixelFormat::Z32F;
+        case Tegra::Texture::TextureFormat::Z24S8:
+            return PixelFormat::Z24S8;
         case Tegra::Texture::TextureFormat::DXT1:
             return PixelFormat::DXT1;
         case Tegra::Texture::TextureFormat::DXT23:
@@ -256,6 +299,22 @@ struct SurfaceParams {
             return PixelFormat::BC7U;
         case Tegra::Texture::TextureFormat::ASTC_2D_4X4:
             return PixelFormat::ASTC_2D_4X4;
+        case Tegra::Texture::TextureFormat::R16_G16:
+            switch (component_type) {
+            case Tegra::Texture::ComponentType::FLOAT:
+                return PixelFormat::RG16F;
+            case Tegra::Texture::ComponentType::UNORM:
+                return PixelFormat::RG16;
+            case Tegra::Texture::ComponentType::SNORM:
+                return PixelFormat::RG16S;
+            case Tegra::Texture::ComponentType::UINT:
+                return PixelFormat::RG16UI;
+            case Tegra::Texture::ComponentType::SINT:
+                return PixelFormat::RG16I;
+            }
+            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
+                         static_cast<u32>(component_type));
+            UNREACHABLE();
         default:
             LOG_CRITICAL(HW_GPU, "Unimplemented format={}, component_type={}",
                          static_cast<u32>(format), static_cast<u32>(component_type));
@@ -267,6 +326,7 @@ struct SurfaceParams {
         // TODO(Subv): Properly implement this
         switch (format) {
         case PixelFormat::ABGR8:
+        case PixelFormat::SRGBA8:
             return Tegra::Texture::TextureFormat::A8R8G8B8;
         case PixelFormat::B5G6R5:
             return Tegra::Texture::TextureFormat::B5G6R5;
@@ -309,6 +369,16 @@ struct SurfaceParams {
         case PixelFormat::R16F:
         case PixelFormat::R16UNORM:
             return Tegra::Texture::TextureFormat::R16;
+        case PixelFormat::Z32F:
+            return Tegra::Texture::TextureFormat::ZF32;
+        case PixelFormat::Z24S8:
+            return Tegra::Texture::TextureFormat::Z24S8;
+        case PixelFormat::RG16F:
+        case PixelFormat::RG16:
+        case PixelFormat::RG16UI:
+        case PixelFormat::RG16I:
+        case PixelFormat::RG16S:
+            return Tegra::Texture::TextureFormat::R16_G16;
         default:
             LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
             UNREACHABLE();
@@ -325,6 +395,8 @@ struct SurfaceParams {
             return Tegra::DepthFormat::Z32_FLOAT;
         case PixelFormat::Z16:
             return Tegra::DepthFormat::Z16_UNORM;
+        case PixelFormat::Z32FS8:
+            return Tegra::DepthFormat::Z32_S8_X24_FLOAT;
         default:
             LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
             UNREACHABLE();
@@ -338,6 +410,12 @@ struct SurfaceParams {
             return ComponentType::UNorm;
         case Tegra::Texture::ComponentType::FLOAT:
             return ComponentType::Float;
+        case Tegra::Texture::ComponentType::SNORM:
+            return ComponentType::SNorm;
+        case Tegra::Texture::ComponentType::UINT:
+            return ComponentType::UInt;
+        case Tegra::Texture::ComponentType::SINT:
+            return ComponentType::SInt;
         default:
             LOG_CRITICAL(HW_GPU, "Unimplemented component type={}", static_cast<u32>(type));
             UNREACHABLE();
@@ -351,14 +429,23 @@ struct SurfaceParams {
         case Tegra::RenderTargetFormat::RGBA8_SRGB:
         case Tegra::RenderTargetFormat::BGRA8_UNORM:
         case Tegra::RenderTargetFormat::RGB10_A2_UNORM:
+        case Tegra::RenderTargetFormat::R8_UNORM:
+        case Tegra::RenderTargetFormat::RG16_UNORM:
             return ComponentType::UNorm;
+        case Tegra::RenderTargetFormat::RG16_SNORM:
+            return ComponentType::SNorm;
         case Tegra::RenderTargetFormat::RGBA16_FLOAT:
         case Tegra::RenderTargetFormat::R11G11B10_FLOAT:
         case Tegra::RenderTargetFormat::RGBA32_FLOAT:
         case Tegra::RenderTargetFormat::RG32_FLOAT:
+        case Tegra::RenderTargetFormat::RG16_FLOAT:
+        case Tegra::RenderTargetFormat::R16_FLOAT:
             return ComponentType::Float;
         case Tegra::RenderTargetFormat::RGBA32_UINT:
+        case Tegra::RenderTargetFormat::RG16_UINT:
             return ComponentType::UInt;
+        case Tegra::RenderTargetFormat::RG16_SINT:
+            return ComponentType::SInt;
         default:
             LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
             UNREACHABLE();
@@ -382,6 +469,7 @@ struct SurfaceParams {
         case Tegra::DepthFormat::Z24_S8_UNORM:
             return ComponentType::UNorm;
         case Tegra::DepthFormat::Z32_FLOAT:
+        case Tegra::DepthFormat::Z32_S8_X24_FLOAT:
             return ComponentType::Float;
         default:
             LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));

src/video_core/textures/decoders.cpp

@@ -62,6 +62,7 @@ u32 BytesPerPixel(TextureFormat format) {
     case TextureFormat::A2B10G10R10:
     case TextureFormat::BF10GF11RF11:
     case TextureFormat::R32:
+    case TextureFormat::R16_G16:
         return 4;
     case TextureFormat::A1B5G5R5:
     case TextureFormat::B5G6R5:
@@ -90,6 +91,8 @@ static u32 DepthBytesPerPixel(DepthFormat format) {
     case DepthFormat::Z24_S8_UNORM:
     case DepthFormat::Z32_FLOAT:
         return 4;
+    case DepthFormat::Z32_S8_X24_FLOAT:
+        return 8;
     default:
         UNIMPLEMENTED_MSG("Format not implemented");
         break;
@@ -125,6 +128,7 @@ std::vector<u8> UnswizzleTexture(VAddr address, TextureFormat format, u32 width,
     case TextureFormat::R32_G32:
     case TextureFormat::R32:
     case TextureFormat::R16:
+    case TextureFormat::R16_G16:
     case TextureFormat::BF10GF11RF11:
     case TextureFormat::ASTC_2D_4X4:
         CopySwizzledData(width, height, bytes_per_pixel, bytes_per_pixel, data,
@@ -150,6 +154,7 @@ std::vector<u8> UnswizzleDepthTexture(VAddr address, DepthFormat format, u32 wid
     case DepthFormat::S8_Z24_UNORM:
     case DepthFormat::Z24_S8_UNORM:
     case DepthFormat::Z32_FLOAT:
+    case DepthFormat::Z32_S8_X24_FLOAT:
         CopySwizzledData(width, height, bytes_per_pixel, bytes_per_pixel, data,
                          unswizzled_data.data(), true, block_height);
         break;
@@ -184,6 +189,7 @@ std::vector<u8> DecodeTexture(const std::vector<u8>& texture_data, TextureFormat
     case TextureFormat::R32_G32:
     case TextureFormat::R32:
     case TextureFormat::R16:
+    case TextureFormat::R16_G16:
         // TODO(Subv): For the time being just forward the same data without any decoding.
         rgba_data = texture_data;
         break;

src/yuzu/debugger/wait_tree.cpp

@@ -5,6 +5,7 @@
 #include "yuzu/debugger/wait_tree.h"
 #include "yuzu/util/util.h"
 
+#include "common/assert.h"
 #include "core/core.h"
 #include "core/hle/kernel/event.h"
 #include "core/hle/kernel/handle_table.h"
@@ -169,6 +170,8 @@ QString WaitTreeWaitObject::GetResetTypeQString(Kernel::ResetType reset_type) {
     case Kernel::ResetType::Pulse:
         return tr("pulse");
     }
+    UNREACHABLE();
+    return {};
 }
 
 WaitTreeObjectList::WaitTreeObjectList(
@@ -206,6 +209,9 @@ QString WaitTreeThread::GetText() const {
     case ThreadStatus::WaitSleep:
         status = tr("sleeping");
         break;
+    case ThreadStatus::WaitIPC:
+        status = tr("waiting for IPC reply");
+        break;
     case ThreadStatus::WaitSynchAll:
     case ThreadStatus::WaitSynchAny:
         status = tr("waiting for objects");
@@ -237,6 +243,7 @@ QColor WaitTreeThread::GetColor() const {
     case ThreadStatus::Ready:
         return QColor(Qt::GlobalColor::darkBlue);
     case ThreadStatus::WaitHLEEvent:
+    case ThreadStatus::WaitIPC:
         return QColor(Qt::GlobalColor::darkRed);
     case ThreadStatus::WaitSleep:
         return QColor(Qt::GlobalColor::darkYellow);
@@ -321,11 +328,11 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeTimer::GetChildren() const {
     const auto& timer = static_cast<const Kernel::Timer&>(object);
 
     list.push_back(std::make_unique<WaitTreeText>(
-        tr("reset type = %1").arg(GetResetTypeQString(timer.reset_type))));
+        tr("reset type = %1").arg(GetResetTypeQString(timer.GetResetType()))));
     list.push_back(
-        std::make_unique<WaitTreeText>(tr("initial delay = %1").arg(timer.initial_delay)));
+        std::make_unique<WaitTreeText>(tr("initial delay = %1").arg(timer.GetInitialDelay())));
     list.push_back(
-        std::make_unique<WaitTreeText>(tr("interval delay = %1").arg(timer.interval_delay)));
+        std::make_unique<WaitTreeText>(tr("interval delay = %1").arg(timer.GetIntervalDelay())));
     return list;
 }
 

src/yuzu/main.cpp

@@ -101,6 +101,8 @@ GMainWindow::GMainWindow() : config(new Config()), emu_thread(nullptr) {
 
     ConnectMenuEvents();
     ConnectWidgetEvents();
+    LOG_INFO(Frontend, "yuzu Version: {} | {}-{}", Common::g_build_name, Common::g_scm_branch,
+             Common::g_scm_desc);
 
     setWindowTitle(QString("yuzu %1| %2-%3")
                        .arg(Common::g_build_name, Common::g_scm_branch, Common::g_scm_desc));

src/yuzu_cmd/default_ini.h

@@ -118,7 +118,7 @@ bg_green =
 layout_option =
 
 # Toggle custom layout (using the settings below) on or off.
-# 0 (default): Off , 1: On
+# 0 (default): Off, 1: On
 custom_layout =
 
 # Screen placement when using Custom layout option

src/yuzu_cmd/emu_window/emu_window_sdl2.cpp

@@ -164,6 +164,8 @@ EmuWindow_SDL2::EmuWindow_SDL2(bool fullscreen) {
     OnResize();
     OnMinimalClientAreaChangeRequest(GetActiveConfig().min_client_area_size);
     SDL_PumpEvents();
+    LOG_INFO(Frontend, "yuzu Version: {} | {}-{}", Common::g_build_name, Common::g_scm_branch,
+             Common::g_scm_desc);
 
     DoneCurrent();
 }