30 files changed, 969 insertions, 74 deletions

diff --git a/src/common/logging/backend.cpp b/src/common/logging/backend.cpp
index 59b999935..ad9edbcdf 100644
--- a/src/common/logging/backend.cpp
+++ b/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)                                                                              \
diff --git a/src/common/logging/log.h b/src/common/logging/log.h
index e7115933f..ad3cbf5d1 100644
--- a/src/common/logging/log.h
+++ b/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
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index 2e2de59b1..b74e495ef 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -156,8 +156,16 @@ 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
@@ -170,6 +178,8 @@ add_library(core STATIC
     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
@@ -225,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
diff --git a/src/core/hle/service/grc/grc.cpp b/src/core/hle/service/grc/grc.cpp
new file mode 100644
index 000000000..24910ac6c
--- /dev/null
+++ b/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
diff --git a/src/core/hle/service/grc/grc.h b/src/core/hle/service/grc/grc.h
new file mode 100644
index 000000000..e0d29e70d
--- /dev/null
+++ b/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
diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp
index 9a02ba686..e4619a547 100644
--- a/src/core/hle/service/hid/hid.cpp
+++ b/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 {
@@ -555,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
diff --git a/src/core/hle/service/hid/irs.cpp b/src/core/hle/service/hid/irs.cpp
new file mode 100644
index 000000000..aaf311912
--- /dev/null
+++ b/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
diff --git a/src/core/hle/service/hid/irs.h b/src/core/hle/service/hid/irs.h
new file mode 100644
index 000000000..a8be701c7
--- /dev/null
+++ b/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
diff --git a/src/core/hle/service/hid/xcd.cpp b/src/core/hle/service/hid/xcd.cpp
new file mode 100644
index 000000000..49f733f60
--- /dev/null
+++ b/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
diff --git a/src/core/hle/service/hid/xcd.h b/src/core/hle/service/hid/xcd.h
new file mode 100644
index 000000000..232a044df
--- /dev/null
+++ b/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
diff --git a/src/core/hle/service/ldn/ldn.cpp b/src/core/hle/service/ldn/ldn.cpp
new file mode 100644
index 000000000..167f2c66a
--- /dev/null
+++ b/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
diff --git a/src/core/hle/service/ldn/ldn.h b/src/core/hle/service/ldn/ldn.h
new file mode 100644
index 000000000..6b2a3c2b2
--- /dev/null
+++ b/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
diff --git a/src/core/hle/service/lm/lm.cpp b/src/core/hle/service/lm/lm.cpp
index e85a8bdb9..b497376d7 100644
--- a/src/core/hle/service/lm/lm.cpp
+++ b/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;
 };
 
-void InstallInterfaces(SM::ServiceManager& service_manager) {
-    std::make_shared<LM>()->InstallAsService(service_manager);
-}
+class LM final : public ServiceFramework<LM> {
+public:
+    explicit LM() : ServiceFramework{"lm"} {
+        static const FunctionInfo functions[] = {
+            {0x00000000, &LM::OpenLogger, "OpenLogger"},
+        };
+        RegisterHandlers(functions);
+    }
 
-/**
- * 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::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>();
 
-LM::LM() : ServiceFramework("lm") {
-    static const FunctionInfo functions[] = {
-        {0x00000000, &LM::Initialize, "Initialize"},
-    };
-    RegisterHandlers(functions);
+        LOG_DEBUG(Service_LM, "called");
+    }
+};
+
+void InstallInterfaces(SM::ServiceManager& service_manager) {
+    std::make_shared<LM>()->InstallAsService(service_manager);
 }
 
 } // namespace Service::LM
diff --git a/src/core/hle/service/lm/lm.h b/src/core/hle/service/lm/lm.h
index 63d6506fe..7806ae27b 100644
--- a/src/core/hle/service/lm/lm.h
+++ b/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);
 
diff --git a/src/core/hle/service/nim/nim.cpp b/src/core/hle/service/nim/nim.cpp
new file mode 100644
index 000000000..bd05b0a70
--- /dev/null
+++ b/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
diff --git a/src/core/hle/service/nim/nim.h b/src/core/hle/service/nim/nim.h
new file mode 100644
index 000000000..2a2a92df0
--- /dev/null
+++ b/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
diff --git a/src/core/hle/service/service.cpp b/src/core/hle/service/service.cpp
index 482989ea7..8b84fd349 100644
--- a/src/core/hle/service/service.cpp
+++ b/src/core/hle/service/service.cpp
@@ -27,12 +27,15 @@
 #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"
@@ -198,12 +201,15 @@ 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);
diff --git a/src/core/hle/service/sockets/bsd.cpp b/src/core/hle/service/sockets/bsd.cpp
index 6aa1e2511..3211a8346 100644
--- a/src/core/hle/service/sockets/bsd.cpp
+++ b/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
diff --git a/src/core/hle/service/sockets/bsd.h b/src/core/hle/service/sockets/bsd.h
index a6b1ca7d0..c1da59b24 100644
--- a/src/core/hle/service/sockets/bsd.h
+++ b/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
diff --git a/src/core/hle/service/sockets/ethc.cpp b/src/core/hle/service/sockets/ethc.cpp
new file mode 100644
index 000000000..d53c25eec
--- /dev/null
+++ b/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
diff --git a/src/core/hle/service/sockets/ethc.h b/src/core/hle/service/sockets/ethc.h
new file mode 100644
index 000000000..9a3c88100
--- /dev/null
+++ b/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
diff --git a/src/core/hle/service/sockets/sockets.cpp b/src/core/hle/service/sockets/sockets.cpp
index 05bd10d35..08d2d306a 100644
--- a/src/core/hle/service/sockets/sockets.cpp
+++ b/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);
 }
 
diff --git a/src/video_core/gpu.h b/src/video_core/gpu.h
index e9d87efb4..c464fc6d1 100644
--- a/src/video_core/gpu.h
+++ b/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,
 };
 
diff --git a/src/video_core/memory_manager.cpp b/src/video_core/memory_manager.cpp
index 2f814a184..ca923d17d 100644
--- a/src/video_core/memory_manager.cpp
+++ b/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];
 }
diff --git a/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp b/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
index f52ac23f1..a4d9707cb 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
+++ b/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>,
diff --git a/src/video_core/renderer_opengl/gl_rasterizer_cache.h b/src/video_core/renderer_opengl/gl_rasterizer_cache.h
index ffa2019f7..bf0458b94 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer_cache.h
+++ b/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();
diff --git a/src/video_core/textures/decoders.cpp b/src/video_core/textures/decoders.cpp
index 50c5a56f6..d794f8402 100644
--- a/src/video_core/textures/decoders.cpp
+++ b/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;
diff --git a/src/yuzu/main.cpp b/src/yuzu/main.cpp
index 3c2726498..97273f967 100644
--- a/src/yuzu/main.cpp
+++ b/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));
diff --git a/src/yuzu_cmd/default_ini.h b/src/yuzu_cmd/default_ini.h
index 5eca38b48..567f23417 100644
--- a/src/yuzu_cmd/default_ini.h
+++ b/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
diff --git a/src/yuzu_cmd/emu_window/emu_window_sdl2.cpp b/src/yuzu_cmd/emu_window/emu_window_sdl2.cpp
index 72ba7d49c..e2945b6cf 100644
--- a/src/yuzu_cmd/emu_window/emu_window_sdl2.cpp
+++ b/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();
 }