Addressed comments

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

@@ -156,8 +156,18 @@ add_library(core STATIC
     hle/service/friend/friend.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
@@ -168,12 +178,8 @@ add_library(core STATIC
     hle/service/nfp/nfp_user.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/nim/nim.cpp
+    hle/service/nim/nim.h
     hle/service/ns/ns.cpp
     hle/service/ns/ns.h
     hle/service/ns/pl_u.cpp
@@ -207,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
@@ -227,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

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/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

@@ -14,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 {
@@ -324,7 +326,7 @@ public:
             {79, &Hid::SetGyroscopeZeroDriftMode, "SetGyroscopeZeroDriftMode"},
             {80, nullptr, "GetGyroscopeZeroDriftMode"},
             {81, nullptr, "ResetGyroscopeZeroDriftMode"},
-            {82, nullptr, "IsSixAxisSensorAtRest"},
+            {82, &Hid::IsSixAxisSensorAtRest, "IsSixAxisSensorAtRest"},
             {91, nullptr, "ActivateGesture"},
             {100, &Hid::SetSupportedNpadStyleSet, "SetSupportedNpadStyleSet"},
             {101, &Hid::GetSupportedNpadStyleSet, "GetSupportedNpadStyleSet"},
@@ -341,7 +343,7 @@ public:
              "SetNpadJoyAssignmentModeSingleByDefault"},
             {123, nullptr, "SetNpadJoyAssignmentModeSingleByDefault"},
             {124, &Hid::SetNpadJoyAssignmentModeDual, "SetNpadJoyAssignmentModeDual"},
-            {125, nullptr, "MergeSingleJoyAsDualJoy"},
+            {125, &Hid::MergeSingleJoyAsDualJoy, "MergeSingleJoyAsDualJoy"},
             {126, nullptr, "StartLrAssignmentMode"},
             {127, nullptr, "StopLrAssignmentMode"},
             {128, &Hid::SetNpadHandheldActivationMode, "SetNpadHandheldActivationMode"},
@@ -453,6 +455,14 @@ private:
         LOG_WARNING(Service_HID, "(STUBBED) called");
     }
 
+    void IsSixAxisSensorAtRest(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+        // TODO (Hexagon12): Properly implement reading gyroscope values from controllers.
+        rb.Push(true);
+        LOG_WARNING(Service_HID, "(STUBBED) called");
+    }
+
     void SetSupportedNpadStyleSet(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
@@ -528,6 +538,12 @@ private:
         LOG_WARNING(Service_HID, "(STUBBED) called");
     }
 
+    void MergeSingleJoyAsDualJoy(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+        LOG_WARNING(Service_HID, "(STUBBED) called");
+    }
+
     void SetNpadHandheldActivationMode(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
@@ -555,10 +571,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/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

@@ -27,14 +27,19 @@
 #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"
@@ -196,15 +201,20 @@ void Init(std::shared_ptr<SM::ServiceManager>& 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/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/video_core/gpu.h

@@ -23,7 +23,13 @@ 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,
 };
 

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_cache.cpp

@@ -104,15 +104,20 @@ 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
@@ -210,10 +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::SRGBA8>,
-        MortonCopy<true, PixelFormat::Z24S8>,        MortonCopy<true, PixelFormat::S8Z24>,
-        MortonCopy<true, PixelFormat::Z32F>,         MortonCopy<true, PixelFormat::Z16>,
-        MortonCopy<true, PixelFormat::Z32FS8>,
+        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::Z32FS8>,
 };
 
 static constexpr std::array<void (*)(u32, u32, u32, u8*, Tegra::GPUVAddr),
@@ -241,6 +248,11 @@ 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>,

src/video_core/renderer_opengl/gl_rasterizer_cache.h

@@ -43,16 +43,21 @@ struct SurfaceParams {
         R32F = 18,
         R16F = 19,
         R16UNORM = 20,
-        SRGBA8 = 21,
+        RG16 = 21,
+        RG16F = 22,
+        RG16UI = 23,
+        RG16I = 24,
+        RG16S = 25,
+        SRGBA8 = 26,
 
         MaxColorFormat,
 
         // DepthStencil formats
-        Z24S8 = 22,
-        S8Z24 = 23,
-        Z32F = 24,
-        Z16 = 25,
-        Z32FS8 = 26,
+        Z24S8 = 27,
+        S8Z24 = 28,
+        Z32F = 29,
+        Z16 = 30,
+        Z32FS8 = 31,
 
         MaxDepthStencilFormat,
 
@@ -111,6 +116,11 @@ struct SurfaceParams {
             1, // R32F
             1, // R16F
             1, // R16UNORM
+            1, // RG16
+            1, // RG16F
+            1, // RG16UI
+            1, // RG16I
+            1, // RG16S
             1, // SRGBA8
             1, // Z24S8
             1, // S8Z24
@@ -149,6 +159,11 @@ struct SurfaceParams {
             32,  // R32F
             16,  // R16F
             16,  // R16UNORM
+            32,  // RG16
+            32,  // RG16F
+            32,  // RG16UI
+            32,  // RG16I
+            32,  // RG16S
             32,  // SRGBA8
             32,  // Z24S8
             32,  // S8Z24
@@ -205,6 +220,18 @@ struct SurfaceParams {
             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();
@@ -271,6 +298,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));
@@ -329,6 +372,12 @@ struct SurfaceParams {
             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();
@@ -360,6 +409,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();
@@ -374,14 +429,22 @@ struct SurfaceParams {
         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();

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:
@@ -127,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,
@@ -187,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

@@ -328,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();
 }