GPU: Implemented the R8 texture format (0x1D)

Service/BCAT: add module and services

src/common/logging/backend.cpp

@@ -35,6 +35,7 @@ namespace Log {
     SUB(Service, AM)                                                                               \
     SUB(Service, AOC)                                                                              \
     SUB(Service, APM)                                                                              \
+    SUB(Service, BCAT)                                                                             \
     SUB(Service, Fatal)                                                                            \
     SUB(Service, Friend)                                                                           \
     SUB(Service, FS)                                                                               \

src/common/logging/log.h

@@ -55,6 +55,7 @@ enum class Class : ClassType {
     Service_AOC,       ///< The AOC (AddOn Content) service
     Service_APM,       ///< The APM (Performance) service
     Service_Audio,     ///< The Audio (Audio control) service
+    Service_BCAT,      ///< The BCAT service
     Service_Fatal,     ///< The Fatal service
     Service_Friend,    ///< The friend service
     Service_FS,        ///< The FS (Filesystem) service

src/core/CMakeLists.txt

@@ -124,6 +124,10 @@ add_library(core STATIC
     hle/service/audio/audren_u.h
     hle/service/audio/codecctl.cpp
     hle/service/audio/codecctl.h
+    hle/service/bcat/module.cpp
+    hle/service/bcat/module.h
+    hle/service/bcat/bcat.cpp
+    hle/service/bcat/bcat.h
     hle/service/fatal/fatal.cpp
     hle/service/fatal/fatal.h
     hle/service/fatal/fatal_p.cpp

src/core/hle/ipc.h

@@ -32,6 +32,8 @@ enum class CommandType : u32 {
     Close = 2,
     Request = 4,
     Control = 5,
+    RequestWithContext = 6,
+    ControlWithContext = 7,
     Unspecified,
 };
 

src/core/hle/kernel/hle_ipc.cpp

@@ -110,7 +110,9 @@ void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
     // Padding to align to 16 bytes
     rp.AlignWithPadding();
 
-    if (Session()->IsDomain() && (command_header->type == IPC::CommandType::Request || !incoming)) {
+    if (Session()->IsDomain() && ((command_header->type == IPC::CommandType::Request ||
+                                   command_header->type == IPC::CommandType::RequestWithContext) ||
+                                  !incoming)) {
         // If this is an incoming message, only CommandType "Request" has a domain header
         // All outgoing domain messages have the domain header, if only incoming has it
         if (incoming || domain_message_header) {

src/core/hle/kernel/mutex.cpp

@@ -104,7 +104,6 @@ ResultCode Mutex::Release(VAddr address) {
 
     // There are no more threads waiting for the mutex, release it completely.
     if (thread == nullptr) {
-        ASSERT(GetCurrentThread()->wait_mutex_threads.empty());
         Memory::Write32(address, 0);
         return RESULT_SUCCESS;
     }

src/core/hle/kernel/svc.cpp

@@ -145,36 +145,6 @@ static bool DefaultThreadWakeupCallback(ThreadWakeupReason reason, SharedPtr<Thr
     return true;
 };
 
-/// Wait for a kernel object to synchronize, timeout after the specified nanoseconds
-static ResultCode WaitSynchronization1(
-    SharedPtr<WaitObject> object, Thread* thread, s64 nano_seconds = -1,
-    std::function<Thread::WakeupCallback> wakeup_callback = DefaultThreadWakeupCallback) {
-
-    if (!object) {
-        return ERR_INVALID_HANDLE;
-    }
-
-    if (object->ShouldWait(thread)) {
-        if (nano_seconds == 0) {
-            return RESULT_TIMEOUT;
-        }
-
-        thread->wait_objects = {object};
-        object->AddWaitingThread(thread);
-        thread->status = THREADSTATUS_WAIT_SYNCH_ANY;
-
-        // Create an event to wake the thread up after the specified nanosecond delay has passed
-        thread->WakeAfterDelay(nano_seconds);
-        thread->wakeup_callback = wakeup_callback;
-
-        Core::System::GetInstance().PrepareReschedule();
-    } else {
-        object->Acquire(thread);
-    }
-
-    return RESULT_SUCCESS;
-}
-
 /// Wait for the given handles to synchronize, timeout after the specified nanoseconds
 static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64 handle_count,
                                       s64 nano_seconds) {
@@ -232,7 +202,7 @@ static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64
     thread->WakeAfterDelay(nano_seconds);
     thread->wakeup_callback = DefaultThreadWakeupCallback;
 
-    Core::System::GetInstance().PrepareReschedule();
+    Core::System::GetInstance().CpuCore(thread->processor_id).PrepareReschedule();
 
     return RESULT_TIMEOUT;
 }
@@ -395,7 +365,7 @@ static ResultCode SetThreadPriority(Handle handle, u32 priority) {
 
     thread->SetPriority(priority);
 
-    Core::System::GetInstance().PrepareReschedule();
+    Core::System::GetInstance().CpuCore(thread->processor_id).PrepareReschedule();
     return RESULT_SUCCESS;
 }
 
@@ -552,6 +522,7 @@ static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, V
     *out_handle = thread->guest_handle;
 
     Core::System::GetInstance().PrepareReschedule();
+    Core::System::GetInstance().CpuCore(thread->processor_id).PrepareReschedule();
 
     NGLOG_TRACE(Kernel_SVC,
                 "called entrypoint=0x{:08X} ({}), arg=0x{:08X}, stacktop=0x{:08X}, "
@@ -570,7 +541,10 @@ static ResultCode StartThread(Handle thread_handle) {
         return ERR_INVALID_HANDLE;
     }
 
+    ASSERT(thread->status == THREADSTATUS_DORMANT);
+
     thread->ResumeFromWait();
+    Core::System::GetInstance().CpuCore(thread->processor_id).PrepareReschedule();
 
     return RESULT_SUCCESS;
 }
@@ -634,61 +608,78 @@ static ResultCode SignalProcessWideKey(VAddr condition_variable_addr, s32 target
     NGLOG_TRACE(Kernel_SVC, "called, condition_variable_addr=0x{:X}, target=0x{:08X}",
                 condition_variable_addr, target);
 
-    u32 processed = 0;
+    auto RetrieveWaitingThreads =
+        [](size_t core_index, std::vector<SharedPtr<Thread>>& waiting_threads, VAddr condvar_addr) {
+            const auto& scheduler = Core::System::GetInstance().Scheduler(core_index);
+            auto& thread_list = scheduler->GetThreadList();
 
-    auto signal_process_wide_key = [&](size_t core_index) {
-        const auto& scheduler = Core::System::GetInstance().Scheduler(core_index);
-        for (auto& thread : scheduler->GetThreadList()) {
-            if (thread->condvar_wait_address != condition_variable_addr)
-                continue;
-
-            // Only process up to 'target' threads, unless 'target' is -1, in which case process
-            // them all.
-            if (target != -1 && processed >= target)
-                break;
-
-            // If the mutex is not yet acquired, acquire it.
-            u32 mutex_val = Memory::Read32(thread->mutex_wait_address);
-
-            if (mutex_val == 0) {
-                // We were able to acquire the mutex, resume this thread.
-                Memory::Write32(thread->mutex_wait_address, thread->wait_handle);
-                ASSERT(thread->status == THREADSTATUS_WAIT_MUTEX);
-                thread->ResumeFromWait();
-
-                auto lock_owner = thread->lock_owner;
-                if (lock_owner)
-                    lock_owner->RemoveMutexWaiter(thread);
-
-                thread->lock_owner = nullptr;
-                thread->mutex_wait_address = 0;
-                thread->condvar_wait_address = 0;
-                thread->wait_handle = 0;
-            } else {
-                // Couldn't acquire the mutex, block the thread.
-                Handle owner_handle = static_cast<Handle>(mutex_val & Mutex::MutexOwnerMask);
-                auto owner = g_handle_table.Get<Thread>(owner_handle);
-                ASSERT(owner);
-                ASSERT(thread->status != THREADSTATUS_RUNNING);
-                thread->status = THREADSTATUS_WAIT_MUTEX;
-                thread->wakeup_callback = nullptr;
-
-                // Signal that the mutex now has a waiting thread.
-                Memory::Write32(thread->mutex_wait_address, mutex_val | Mutex::MutexHasWaitersFlag);
-
-                owner->AddMutexWaiter(thread);
-
-                Core::System::GetInstance().CpuCore(thread->processor_id).PrepareReschedule();
+            for (auto& thread : thread_list) {
+                if (thread->condvar_wait_address == condvar_addr)
+                    waiting_threads.push_back(thread);
             }
+        };
 
-            ++processed;
+    // Retrieve a list of all threads that are waiting for this condition variable.
+    std::vector<SharedPtr<Thread>> waiting_threads;
+    RetrieveWaitingThreads(0, waiting_threads, condition_variable_addr);
+    RetrieveWaitingThreads(1, waiting_threads, condition_variable_addr);
+    RetrieveWaitingThreads(2, waiting_threads, condition_variable_addr);
+    RetrieveWaitingThreads(3, waiting_threads, condition_variable_addr);
+    // Sort them by priority, such that the highest priority ones come first.
+    std::sort(waiting_threads.begin(), waiting_threads.end(),
+              [](const SharedPtr<Thread>& lhs, const SharedPtr<Thread>& rhs) {
+                  return lhs->current_priority < rhs->current_priority;
+              });
+
+    // Only process up to 'target' threads, unless 'target' is -1, in which case process
+    // them all.
+    size_t last = waiting_threads.size();
+    if (target != -1)
+        last = target;
+
+    // If there are no threads waiting on this condition variable, just exit
+    if (last > waiting_threads.size())
+        return RESULT_SUCCESS;
+
+    for (size_t index = 0; index < last; ++index) {
+        auto& thread = waiting_threads[index];
+
+        ASSERT(thread->condvar_wait_address == condition_variable_addr);
+
+        // If the mutex is not yet acquired, acquire it.
+        u32 mutex_val = Memory::Read32(thread->mutex_wait_address);
+
+        if (mutex_val == 0) {
+            // We were able to acquire the mutex, resume this thread.
+            Memory::Write32(thread->mutex_wait_address, thread->wait_handle);
+            ASSERT(thread->status == THREADSTATUS_WAIT_MUTEX);
+            thread->ResumeFromWait();
+
+            auto lock_owner = thread->lock_owner;
+            if (lock_owner)
+                lock_owner->RemoveMutexWaiter(thread);
+
+            thread->lock_owner = nullptr;
+            thread->mutex_wait_address = 0;
+            thread->condvar_wait_address = 0;
+            thread->wait_handle = 0;
+        } else {
+            // Couldn't acquire the mutex, block the thread.
+            Handle owner_handle = static_cast<Handle>(mutex_val & Mutex::MutexOwnerMask);
+            auto owner = g_handle_table.Get<Thread>(owner_handle);
+            ASSERT(owner);
+            ASSERT(thread->status != THREADSTATUS_RUNNING);
+            thread->status = THREADSTATUS_WAIT_MUTEX;
+            thread->wakeup_callback = nullptr;
+
+            // Signal that the mutex now has a waiting thread.
+            Memory::Write32(thread->mutex_wait_address, mutex_val | Mutex::MutexHasWaitersFlag);
+
+            owner->AddMutexWaiter(thread);
+
+            Core::System::GetInstance().CpuCore(thread->processor_id).PrepareReschedule();
         }
-    };
-
-    signal_process_wide_key(0);
-    signal_process_wide_key(1);
-    signal_process_wide_key(2);
-    signal_process_wide_key(3);
+    }
 
     return RESULT_SUCCESS;
 }

src/core/hle/kernel/svc.h

@@ -47,9 +47,12 @@ enum class GetInfoType : u64 {
     NewMapRegionSize = 15,
     // 3.0.0+
     IsVirtualAddressMemoryEnabled = 16,
+    PersonalMmHeapUsage = 17,
     TitleId = 18,
     // 4.0.0+
     PrivilegedProcessId = 19,
+    // 5.0.0+
+    UserExceptionContextAddr = 20,
 };
 
 void CallSVC(u32 immediate);

src/core/hle/result.h

@@ -32,7 +32,8 @@ enum class ErrorModule : u32 {
     Common = 0,
     Kernel = 1,
     FS = 2,
-    NvidiaTransferMemory = 3,
+    OS = 3, // used for Memory, Thread, Mutex, Nvidia
+    HTCS = 4,
     NCM = 5,
     DD = 6,
     LR = 8,
@@ -42,41 +43,80 @@ enum class ErrorModule : u32 {
     PM = 15,
     NS = 16,
     HTC = 18,
+    NCMContent = 20,
     SM = 21,
     RO = 22,
     SDMMC = 24,
+    OVLN = 25,
     SPL = 26,
     ETHC = 100,
     I2C = 101,
+    GPIO = 102,
+    UART = 103,
     Settings = 105,
+    WLAN = 107,
+    XCD = 108,
     NIFM = 110,
-    Display = 114,
-    NTC = 116,
+    Hwopus = 111,
+    Bluetooth = 113,
+    VI = 114,
+    NFP = 115,
+    Time = 116,
     FGM = 117,
-    PCIE = 120,
+    OE = 118,
+    PCIe = 120,
     Friends = 121,
+    BCAT = 122,
     SSL = 123,
     Account = 124,
+    News = 125,
     Mii = 126,
+    NFC = 127,
     AM = 128,
     PlayReport = 129,
+    AHID = 130,
+    Qlaunch = 132,
     PCV = 133,
     OMM = 134,
+    BPC = 135,
+    PSM = 136,
     NIM = 137,
     PSC = 138,
+    TC = 139,
     USB = 140,
+    NSD = 141,
+    PCTL = 142,
     BTM = 143,
+    ETicket = 145,
+    NGC = 146,
     ERPT = 147,
     APM = 148,
+    Profiler = 150,
+    ErrorUpload = 151,
+    Audio = 153,
     NPNS = 154,
+    NPNSHTTPSTREAM = 155,
     ARP = 157,
-    BOOT = 158,
-    NFC = 161,
+    SWKBD = 158,
+    BOOT = 159,
+    NFCMifare = 161,
     UserlandAssert = 162,
+    Fatal = 163,
+    NIMShop = 164,
+    SPSM = 165,
+    BGTC = 167,
     UserlandCrash = 168,
-    HID = 203,
+    SREPO = 180,
+    Dauth = 181,
+    HID = 202,
+    LDN = 203,
+    Irsensor = 205,
     Capture = 206,
-    TC = 651,
+    Manu = 208,
+    ATK = 209,
+    GRC = 212,
+    Migration = 216,
+    MigrationLdcServ = 217,
     GeneralWebApplet = 800,
     WifiWebAuthApplet = 809,
     WhitelistedApplet = 810,

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

@@ -74,7 +74,40 @@ void IAudioController::GetLibraryAppletExpectedMasterVolume(Kernel::HLERequestCo
     rb.Push(volume);
 }
 
-IDisplayController::IDisplayController() : ServiceFramework("IDisplayController") {}
+IDisplayController::IDisplayController() : ServiceFramework("IDisplayController") {
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "GetLastForegroundCaptureImage"},
+        {1, nullptr, "UpdateLastForegroundCaptureImage"},
+        {2, nullptr, "GetLastApplicationCaptureImage"},
+        {3, nullptr, "GetCallerAppletCaptureImage"},
+        {4, nullptr, "UpdateCallerAppletCaptureImage"},
+        {5, nullptr, "GetLastForegroundCaptureImageEx"},
+        {6, nullptr, "GetLastApplicationCaptureImageEx"},
+        {7, nullptr, "GetCallerAppletCaptureImageEx"},
+        {8, nullptr, "TakeScreenShotOfOwnLayer"},  // 2.0.0+
+        {9, nullptr, "CopyBetweenCaptureBuffers"}, // 5.0.0+
+        {10, nullptr, "AcquireLastApplicationCaptureBuffer"},
+        {11, nullptr, "ReleaseLastApplicationCaptureBuffer"},
+        {12, nullptr, "AcquireLastForegroundCaptureBuffer"},
+        {13, nullptr, "ReleaseLastForegroundCaptureBuffer"},
+        {14, nullptr, "AcquireCallerAppletCaptureBuffer"},
+        {15, nullptr, "ReleaseCallerAppletCaptureBuffer"},
+        {16, nullptr, "AcquireLastApplicationCaptureBufferEx"},
+        {17, nullptr, "AcquireLastForegroundCaptureBufferEx"},
+        {18, nullptr, "AcquireCallerAppletCaptureBufferEx"},
+        // 2.0.0+
+        {20, nullptr, "ClearCaptureBuffer"},
+        {21, nullptr, "ClearAppletTransitionBuffer"},
+        // 4.0.0+
+        {22, nullptr, "AcquireLastApplicationCaptureSharedBuffer"},
+        {23, nullptr, "ReleaseLastApplicationCaptureSharedBuffer"},
+        {24, nullptr, "AcquireLastForegroundCaptureSharedBuffer"},
+        {25, nullptr, "ReleaseLastForegroundCaptureSharedBuffer"},
+        {26, nullptr, "AcquireCallerAppletCaptureSharedBuffer"},
+        {27, nullptr, "ReleaseCallerAppletCaptureSharedBuffer"},
+    };
+    RegisterHandlers(functions);
+}
 
 IDebugFunctions::IDebugFunctions() : ServiceFramework("IDebugFunctions") {}
 
@@ -457,7 +490,7 @@ IApplicationFunctions::IApplicationFunctions() : ServiceFramework("IApplicationF
         {20, &IApplicationFunctions::EnsureSaveData, "EnsureSaveData"},
         {21, &IApplicationFunctions::GetDesiredLanguage, "GetDesiredLanguage"},
         {22, &IApplicationFunctions::SetTerminateResult, "SetTerminateResult"},
-        {23, nullptr, "GetDisplayVersion"},
+        {23, &IApplicationFunctions::GetDisplayVersion, "GetDisplayVersion"},
         {24, nullptr, "GetLaunchStorageInfoForDebug"},
         {25, nullptr, "ExtendSaveData"},
         {26, nullptr, "GetSaveDataSize"},
@@ -552,6 +585,14 @@ void IApplicationFunctions::SetTerminateResult(Kernel::HLERequestContext& ctx) {
     NGLOG_WARNING(Service_AM, "(STUBBED) called, result=0x{:08X}", result);
 }
 
+void IApplicationFunctions::GetDisplayVersion(Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 6};
+    rb.Push(RESULT_SUCCESS);
+    rb.Push<u64>(1);
+    rb.Push<u64>(0);
+    NGLOG_WARNING(Service_AM, "(STUBBED) called");
+}
+
 void IApplicationFunctions::GetDesiredLanguage(Kernel::HLERequestContext& ctx) {
     // TODO(bunnei): This should be configurable
     IPC::ResponseBuilder rb{ctx, 4};

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

@@ -18,10 +18,25 @@ class NVFlinger;
 
 namespace AM {
 
-// TODO: Add more languages
 enum SystemLanguage {
     Japanese = 0,
-    English = 1,
+    English = 1, // en-US
+    French = 2,
+    German = 3,
+    Italian = 4,
+    Spanish = 5,
+    Chinese = 6,
+    Korean = 7,
+    Dutch = 8,
+    Portuguese = 9,
+    Russian = 10,
+    Taiwanese = 11,
+    BritishEnglish = 12, // en-GB
+    CanadianFrench = 13,
+    LatinAmericanSpanish = 14, // es-419
+    // 4.0.0+
+    SimplifiedChinese = 15,
+    TraditionalChinese = 16,
 };
 
 class IWindowController final : public ServiceFramework<IWindowController> {
@@ -117,6 +132,7 @@ private:
     void CreateApplicationAndRequestToStartForQuest(Kernel::HLERequestContext& ctx);
     void EnsureSaveData(Kernel::HLERequestContext& ctx);
     void SetTerminateResult(Kernel::HLERequestContext& ctx);
+    void GetDisplayVersion(Kernel::HLERequestContext& ctx);
     void GetDesiredLanguage(Kernel::HLERequestContext& ctx);
     void InitializeGamePlayRecording(Kernel::HLERequestContext& ctx);
     void SetGamePlayRecordingState(Kernel::HLERequestContext& ctx);

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

@@ -98,7 +98,7 @@ void AppletOE::OpenApplicationProxy(Kernel::HLERequestContext& ctx) {
 AppletOE::AppletOE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
     : ServiceFramework("appletOE"), nvflinger(std::move(nvflinger)) {
     static const FunctionInfo functions[] = {
-        {0x00000000, &AppletOE::OpenApplicationProxy, "OpenApplicationProxy"},
+        {0, &AppletOE::OpenApplicationProxy, "OpenApplicationProxy"},
     };
     RegisterHandlers(functions);
 }

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

@@ -35,10 +35,8 @@ public:
 
 AudInU::AudInU() : ServiceFramework("audin:u") {
     static const FunctionInfo functions[] = {
-        {0, nullptr, "ListAudioIns"},
-        {1, nullptr, "OpenAudioIn"},
-        {3, nullptr, "OpenAudioInAuto"},
-        {4, nullptr, "ListAudioInsAuto"},
+        {0, nullptr, "ListAudioIns"},    {1, nullptr, "OpenAudioIn"},      {2, nullptr, "Unknown"},
+        {3, nullptr, "OpenAudioInAuto"}, {4, nullptr, "ListAudioInsAuto"},
     };
     RegisterHandlers(functions);
 }

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

@@ -196,10 +196,10 @@ void AudOutU::OpenAudioOut(Kernel::HLERequestContext& ctx) {
 }
 
 AudOutU::AudOutU() : ServiceFramework("audout:u") {
-    static const FunctionInfo functions[] = {{0x00000000, &AudOutU::ListAudioOuts, "ListAudioOuts"},
-                                             {0x00000001, &AudOutU::OpenAudioOut, "OpenAudioOut"},
-                                             {0x00000002, nullptr, "ListAudioOutsAuto"},
-                                             {0x00000003, nullptr, "OpenAudioOutAuto"}};
+    static const FunctionInfo functions[] = {{0, &AudOutU::ListAudioOuts, "ListAudioOuts"},
+                                             {1, &AudOutU::OpenAudioOut, "OpenAudioOut"},
+                                             {2, nullptr, "ListAudioOutsAuto"},
+                                             {3, nullptr, "OpenAudioOutAuto"}};
     RegisterHandlers(functions);
 }
 

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

@@ -20,6 +20,7 @@ public:
             {4, nullptr, "RegisterBufferEvent"},
             {5, nullptr, "GetReleasedFinalOutputRecorderBuffer"},
             {6, nullptr, "ContainsFinalOutputRecorderBuffer"},
+            {7, nullptr, "Unknown"},
             {8, nullptr, "AppendFinalOutputRecorderBufferAuto"},
             {9, nullptr, "GetReleasedFinalOutputRecorderBufferAuto"},
         };
@@ -30,7 +31,7 @@ public:
 
 AudRecU::AudRecU() : ServiceFramework("audrec:u") {
     static const FunctionInfo functions[] = {
-        {0x00000000, nullptr, "OpenFinalOutputRecorder"},
+        {0, nullptr, "OpenFinalOutputRecorder"},
     };
     RegisterHandlers(functions);
 }

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

@@ -2,6 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include "common/alignment.h"
 #include "common/logging/log.h"
 #include "core/core_timing.h"
 #include "core/hle/ipc_helpers.h"
@@ -156,19 +157,20 @@ class IAudioDevice final : public ServiceFramework<IAudioDevice> {
 public:
     IAudioDevice() : ServiceFramework("IAudioDevice") {
         static const FunctionInfo functions[] = {
-            {0x0, &IAudioDevice::ListAudioDeviceName, "ListAudioDeviceName"},
-            {0x1, &IAudioDevice::SetAudioDeviceOutputVolume, "SetAudioDeviceOutputVolume"},
-            {0x2, nullptr, "GetAudioDeviceOutputVolume"},
-            {0x3, &IAudioDevice::GetActiveAudioDeviceName, "GetActiveAudioDeviceName"},
-            {0x4, &IAudioDevice::QueryAudioDeviceSystemEvent, "QueryAudioDeviceSystemEvent"},
-            {0x5, &IAudioDevice::GetActiveChannelCount, "GetActiveChannelCount"},
-            {0x6, &IAudioDevice::ListAudioDeviceName,
+            {0, &IAudioDevice::ListAudioDeviceName, "ListAudioDeviceName"},
+            {1, &IAudioDevice::SetAudioDeviceOutputVolume, "SetAudioDeviceOutputVolume"},
+            {2, nullptr, "GetAudioDeviceOutputVolume"},
+            {3, &IAudioDevice::GetActiveAudioDeviceName, "GetActiveAudioDeviceName"},
+            {4, &IAudioDevice::QueryAudioDeviceSystemEvent, "QueryAudioDeviceSystemEvent"},
+            {5, &IAudioDevice::GetActiveChannelCount, "GetActiveChannelCount"},
+            {6, &IAudioDevice::ListAudioDeviceName,
              "ListAudioDeviceNameAuto"}, // TODO(ogniK): Confirm if autos are identical to non auto
-            {0x7, &IAudioDevice::SetAudioDeviceOutputVolume, "SetAudioDeviceOutputVolumeAuto"},
-            {0x8, nullptr, "GetAudioDeviceOutputVolumeAuto"},
-            {0xa, &IAudioDevice::GetActiveAudioDeviceName, "GetActiveAudioDeviceNameAuto"},
-            {0xb, nullptr, "QueryAudioDeviceInputEvent"},
-            {0xc, nullptr, "QueryAudioDeviceOutputEvent"}};
+            {7, &IAudioDevice::SetAudioDeviceOutputVolume, "SetAudioDeviceOutputVolumeAuto"},
+            {8, nullptr, "GetAudioDeviceOutputVolumeAuto"},
+            {10, &IAudioDevice::GetActiveAudioDeviceName, "GetActiveAudioDeviceNameAuto"},
+            {11, nullptr, "QueryAudioDeviceInputEvent"},
+            {12, nullptr, "QueryAudioDeviceOutputEvent"},
+        };
         RegisterHandlers(functions);
 
         buffer_event =
@@ -255,12 +257,62 @@ void AudRenU::OpenAudioRenderer(Kernel::HLERequestContext& ctx) {
 }
 
 void AudRenU::GetAudioRendererWorkBufferSize(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    auto params = rp.PopRaw<WorkerBufferParameters>();
+
+    u64 buffer_sz = Common::AlignUp(4 * params.unknown8, 0x40);
+    buffer_sz += params.unknownC * 1024;
+    buffer_sz += 0x940 * (params.unknownC + 1);
+    buffer_sz += 0x3F0 * params.voice_count;
+    buffer_sz += Common::AlignUp(8 * (params.unknownC + 1), 0x10);
+    buffer_sz += Common::AlignUp(8 * params.voice_count, 0x10);
+    buffer_sz +=
+        Common::AlignUp((0x3C0 * (params.sink_count + params.unknownC) + 4 * params.sample_count) *
+                            (params.unknown8 + 6),
+                        0x40);
+
+    if (IsFeatureSupported(AudioFeatures::Splitter, params.magic)) {
+        u32 count = params.unknownC + 1;
+        u64 node_count = Common::AlignUp(count, 0x40);
+        u64 node_state_buffer_sz =
+            4 * (node_count * node_count) + 0xC * node_count + 2 * (node_count / 8);
+        u64 edge_matrix_buffer_sz = 0;
+        node_count = Common::AlignUp(count * count, 0x40);
+        if (node_count >> 31 != 0) {
+            edge_matrix_buffer_sz = (node_count | 7) / 8;
+        } else {
+            edge_matrix_buffer_sz = node_count / 8;
+        }
+        buffer_sz += Common::AlignUp(node_state_buffer_sz + edge_matrix_buffer_sz, 0x10);
+    }
+
+    buffer_sz += 0x20 * (params.effect_count + 4 * params.voice_count) + 0x50;
+    if (IsFeatureSupported(AudioFeatures::Splitter, params.magic)) {
+        buffer_sz += 0xE0 * params.unknown2c;
+        buffer_sz += 0x20 * params.splitter_count;
+        buffer_sz += Common::AlignUp(4 * params.unknown2c, 0x10);
+    }
+    buffer_sz = Common::AlignUp(buffer_sz, 0x40) + 0x170 * params.sink_count;
+    u64 output_sz = buffer_sz + 0x280 * params.sink_count + 0x4B0 * params.effect_count +
+                    ((params.voice_count * 256) | 0x40);
+
+    if (params.unknown1c >= 1) {
+        output_sz = Common::AlignUp(((16 * params.sink_count + 16 * params.effect_count +
+                                      16 * params.voice_count + 16) +
+                                     0x658) *
+                                            (params.unknown1c + 1) +
+                                        0xc0,
+                                    0x40) +
+                    output_sz;
+    }
+    output_sz = Common::AlignUp(output_sz + 0x1807e, 0x1000);
+
     IPC::ResponseBuilder rb{ctx, 4};
 
     rb.Push(RESULT_SUCCESS);
-    rb.Push<u64>(0x4000);
+    rb.Push<u64>(output_sz);
 
-    NGLOG_WARNING(Service_Audio, "(STUBBED) called");
+    NGLOG_DEBUG(Service_Audio, "called, buffer_size=0x{:X}", output_sz);
 }
 
 void AudRenU::GetAudioDevice(Kernel::HLERequestContext& ctx) {
@@ -272,4 +324,14 @@ void AudRenU::GetAudioDevice(Kernel::HLERequestContext& ctx) {
     NGLOG_DEBUG(Service_Audio, "called");
 }
 
+bool AudRenU::IsFeatureSupported(AudioFeatures feature, u32_le revision) const {
+    u32_be version_num = (revision - Common::MakeMagic('R', 'E', 'V', '0')); // Byte swap
+    switch (feature) {
+    case AudioFeatures::Splitter:
+        return version_num >= 2;
+    default:
+        return false;
+    }
+}
+
 } // namespace Service::Audio

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

@@ -21,6 +21,31 @@ private:
     void OpenAudioRenderer(Kernel::HLERequestContext& ctx);
     void GetAudioRendererWorkBufferSize(Kernel::HLERequestContext& ctx);
     void GetAudioDevice(Kernel::HLERequestContext& ctx);
+
+    struct WorkerBufferParameters {
+        u32_le sample_rate;
+        u32_le sample_count;
+        u32_le unknown8;
+        u32_le unknownC;
+        u32_le voice_count;
+        u32_le sink_count;
+        u32_le effect_count;
+        u32_le unknown1c;
+        u8 unknown20;
+        u8 padding1[3];
+        u32_le splitter_count;
+        u32_le unknown2c;
+        u8 padding2[4];
+        u32_le magic;
+    };
+    static_assert(sizeof(WorkerBufferParameters) == 52,
+                  "WorkerBufferParameters is an invalid size");
+
+    enum class AudioFeatures : u32 {
+        Splitter,
+    };
+
+    bool IsFeatureSupported(AudioFeatures feature, u32_le revision) const;
 };
 
 } // namespace Service::Audio

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

@@ -11,19 +11,19 @@ namespace Service::Audio {
 
 CodecCtl::CodecCtl() : ServiceFramework("codecctl") {
     static const FunctionInfo functions[] = {
-        {0x00000000, nullptr, "InitializeCodecController"},
-        {0x00000001, nullptr, "FinalizeCodecController"},
-        {0x00000002, nullptr, "SleepCodecController"},
-        {0x00000003, nullptr, "WakeCodecController"},
-        {0x00000004, nullptr, "SetCodecVolume"},
-        {0x00000005, nullptr, "GetCodecVolumeMax"},
-        {0x00000006, nullptr, "GetCodecVolumeMin"},
-        {0x00000007, nullptr, "SetCodecActiveTarget"},
-        {0x00000008, nullptr, "Unknown"},
-        {0x00000009, nullptr, "BindCodecHeadphoneMicJackInterrupt"},
-        {0x00000010, nullptr, "IsCodecHeadphoneMicJackInserted"},
-        {0x00000011, nullptr, "ClearCodecHeadphoneMicJackInterrupt"},
-        {0x00000012, nullptr, "IsCodecDeviceRequested"},
+        {0, nullptr, "InitializeCodecController"},
+        {1, nullptr, "FinalizeCodecController"},
+        {2, nullptr, "SleepCodecController"},
+        {3, nullptr, "WakeCodecController"},
+        {4, nullptr, "SetCodecVolume"},
+        {5, nullptr, "GetCodecVolumeMax"},
+        {6, nullptr, "GetCodecVolumeMin"},
+        {7, nullptr, "SetCodecActiveTarget"},
+        {8, nullptr, "GetCodecActiveTarget"},
+        {9, nullptr, "BindCodecHeadphoneMicJackInterrupt"},
+        {10, nullptr, "IsCodecHeadphoneMicJackInserted"},
+        {11, nullptr, "ClearCodecHeadphoneMicJackInterrupt"},
+        {12, nullptr, "IsCodecDeviceRequested"},
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/bcat/bcat.cpp

@@ -0,0 +1,16 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/service/bcat/bcat.h"
+
+namespace Service::BCAT {
+
+BCAT::BCAT(std::shared_ptr<Module> module, const char* name)
+    : Module::Interface(std::move(module), name) {
+    static const FunctionInfo functions[] = {
+        {0, &BCAT::CreateBcatService, "CreateBcatService"},
+    };
+    RegisterHandlers(functions);
+}
+} // namespace Service::BCAT

src/core/hle/service/bcat/bcat.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/bcat/module.h"
+
+namespace Service::BCAT {
+
+class BCAT final : public Module::Interface {
+public:
+    explicit BCAT(std::shared_ptr<Module> module, const char* name);
+};
+
+} // namespace Service::BCAT

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

@@ -0,0 +1,53 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/logging/log.h"
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/service/bcat/bcat.h"
+#include "core/hle/service/bcat/module.h"
+
+namespace Service::BCAT {
+
+class IBcatService final : public ServiceFramework<IBcatService> {
+public:
+    IBcatService() : ServiceFramework("IBcatService") {
+        static const FunctionInfo functions[] = {
+            {10100, nullptr, "RequestSyncDeliveryCache"},
+            {10101, nullptr, "RequestSyncDeliveryCacheWithDirectoryName"},
+            {10200, nullptr, "CancelSyncDeliveryCacheRequest"},
+            {20100, nullptr, "RequestSyncDeliveryCacheWithApplicationId"},
+            {20101, nullptr, "RequestSyncDeliveryCacheWithApplicationIdAndDirectoryName"},
+            {30100, nullptr, "SetPassphrase"},
+            {30200, nullptr, "RegisterBackgroundDeliveryTask"},
+            {30201, nullptr, "UnregisterBackgroundDeliveryTask"},
+            {30202, nullptr, "BlockDeliveryTask"},
+            {30203, nullptr, "UnblockDeliveryTask"},
+            {90100, nullptr, "EnumerateBackgroundDeliveryTask"},
+            {90200, nullptr, "GetDeliveryList"},
+            {90201, nullptr, "ClearDeliveryCacheStorage"},
+            {90300, nullptr, "GetPushNotificationLog"},
+        };
+        RegisterHandlers(functions);
+    }
+};
+
+void Module::Interface::CreateBcatService(Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushIpcInterface<IBcatService>();
+    NGLOG_DEBUG(Service_BCAT, "called");
+}
+
+Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
+    : ServiceFramework(name), module(std::move(module)) {}
+
+void InstallInterfaces(SM::ServiceManager& service_manager) {
+    auto module = std::make_shared<Module>();
+    std::make_shared<BCAT>(module, "bcat:a")->InstallAsService(service_manager);
+    std::make_shared<BCAT>(module, "bcat:m")->InstallAsService(service_manager);
+    std::make_shared<BCAT>(module, "bcat:u")->InstallAsService(service_manager);
+    std::make_shared<BCAT>(module, "bcat:s")->InstallAsService(service_manager);
+}
+
+} // namespace Service::BCAT

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

@@ -0,0 +1,27 @@
+// 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::BCAT {
+
+class Module final {
+public:
+    class Interface : public ServiceFramework<Interface> {
+    public:
+        Interface(std::shared_ptr<Module> module, const char* name);
+
+        void CreateBcatService(Kernel::HLERequestContext& ctx);
+
+    protected:
+        std::shared_ptr<Module> module;
+    };
+};
+
+/// Registers all BCAT services with the specified service manager.
+void InstallInterfaces(SM::ServiceManager& service_manager);
+
+} // namespace Service::BCAT

src/core/hle/service/fatal/fatal.cpp

@@ -13,7 +13,7 @@ namespace Service::Fatal {
 Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
     : ServiceFramework(name), module(std::move(module)) {}
 
-void Module::Interface::FatalSimple(Kernel::HLERequestContext& ctx) {
+void Module::Interface::ThrowFatalWithPolicy(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp(ctx);
     u32 error_code = rp.Pop<u32>();
     NGLOG_WARNING(Service_Fatal, "(STUBBED) called, error_code=0x{:X}", error_code);
@@ -21,7 +21,7 @@ void Module::Interface::FatalSimple(Kernel::HLERequestContext& ctx) {
     rb.Push(RESULT_SUCCESS);
 }
 
-void Module::Interface::TransitionToFatalError(Kernel::HLERequestContext& ctx) {
+void Module::Interface::ThrowFatalWithCpuContext(Kernel::HLERequestContext& ctx) {
     NGLOG_WARNING(Service_Fatal, "(STUBBED) called");
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);

src/core/hle/service/fatal/fatal.h

@@ -14,8 +14,8 @@ public:
     public:
         Interface(std::shared_ptr<Module> module, const char* name);
 
-        void FatalSimple(Kernel::HLERequestContext& ctx);
-        void TransitionToFatalError(Kernel::HLERequestContext& ctx);
+        void ThrowFatalWithPolicy(Kernel::HLERequestContext& ctx);
+        void ThrowFatalWithCpuContext(Kernel::HLERequestContext& ctx);
 
     protected:
         std::shared_ptr<Module> module;

src/core/hle/service/fatal/fatal_u.cpp

@@ -8,8 +8,9 @@ namespace Service::Fatal {
 
 Fatal_U::Fatal_U(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "fatal:u") {
     static const FunctionInfo functions[] = {
-        {1, &Fatal_U::FatalSimple, "FatalSimple"},
-        {2, &Fatal_U::TransitionToFatalError, "TransitionToFatalError"},
+        {0, nullptr, "ThrowFatal"},
+        {1, &Fatal_U::ThrowFatalWithPolicy, "ThrowFatalWithPolicy"},
+        {2, &Fatal_U::ThrowFatalWithCpuContext, "ThrowFatalWithCpuContext"},
     };
     RegisterHandlers(functions);
 }

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

@@ -12,7 +12,7 @@ namespace Service::HID {
 // Begin enums and output structs
 
 constexpr u32 HID_NUM_ENTRIES = 17;
-constexpr u32 HID_NUM_LAYOUTS = 7;
+constexpr u32 HID_NUM_LAYOUTS = 2;
 constexpr s32 HID_JOYSTICK_MAX = 0x8000;
 constexpr s32 HID_JOYSTICK_MIN = -0x8000;
 

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

@@ -17,30 +17,30 @@ public:
     IUser() : ServiceFramework("IUser") {
         static const FunctionInfo functions[] = {
             {0, &IUser::Initialize, "Initialize"},
-            {1, nullptr, "Unknown1"},
-            {2, nullptr, "Unknown2"},
-            {3, nullptr, "Unknown3"},
-            {4, nullptr, "Unknown4"},
-            {5, nullptr, "Unknown5"},
-            {6, nullptr, "Unknown6"},
-            {7, nullptr, "Unknown7"},
-            {8, nullptr, "Unknown8"},
-            {9, nullptr, "Unknown9"},
-            {10, nullptr, "Unknown10"},
-            {11, nullptr, "Unknown11"},
-            {12, nullptr, "Unknown12"},
-            {13, nullptr, "Unknown13"},
-            {14, nullptr, "Unknown14"},
-            {15, nullptr, "Unknown15"},
-            {16, nullptr, "Unknown16"},
-            {17, nullptr, "Unknown17"},
-            {18, nullptr, "Unknown18"},
-            {19, nullptr, "Unknown19"},
-            {20, nullptr, "Unknown20"},
-            {21, nullptr, "Unknown21"},
-            {22, nullptr, "Unknown22"},
-            {23, nullptr, "Unknown23"},
-            {24, nullptr, "Unknown24"},
+            {1, nullptr, "Finalize"},
+            {2, nullptr, "ListDevices"},
+            {3, nullptr, "StartDetection"},
+            {4, nullptr, "StopDetection"},
+            {5, nullptr, "Mount"},
+            {6, nullptr, "Unmount"},
+            {7, nullptr, "OpenApplicationArea"},
+            {8, nullptr, "GetApplicationArea"},
+            {9, nullptr, "SetApplicationArea"},
+            {10, nullptr, "Flush"},
+            {11, nullptr, "Restore"},
+            {12, nullptr, "CreateApplicationArea"},
+            {13, nullptr, "GetTagInfo"},
+            {14, nullptr, "GetRegisterInfo"},
+            {15, nullptr, "GetCommonInfo"},
+            {16, nullptr, "GetModelInfo"},
+            {17, nullptr, "AttachActivateEvent"},
+            {18, nullptr, "AttachDeactivateEvent"},
+            {19, nullptr, "GetState"},
+            {20, nullptr, "GetDeviceState"},
+            {21, nullptr, "GetNpadId"},
+            {22, nullptr, "GetApplicationArea2"},
+            {23, nullptr, "AttachAvailabilityChangeEvent"},
+            {24, nullptr, "RecreateApplicationArea"},
         };
         RegisterHandlers(functions);
     }

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

@@ -26,6 +26,8 @@ u32 nvhost_as_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vecto
         return BindChannel(input, output);
     case IoctlCommand::IocGetVaRegionsCommand:
         return GetVARegions(input, output);
+    case IoctlCommand::IocUnmapBufferCommand:
+        return UnmapBuffer(input, output);
     }
 
     if (static_cast<IoctlCommand>(command.cmd.Value()) == IoctlCommand::IocRemapCommand)
@@ -125,6 +127,37 @@ u32 nvhost_as_gpu::MapBufferEx(const std::vector<u8>& input, std::vector<u8>& ou
         params.offset = gpu.memory_manager->MapBufferEx(object->addr, object->size);
     }
 
+    // Create a new mapping entry for this operation.
+    ASSERT_MSG(buffer_mappings.find(params.offset) == buffer_mappings.end(),
+               "Offset is already mapped");
+
+    BufferMapping mapping{};
+    mapping.nvmap_handle = params.nvmap_handle;
+    mapping.offset = params.offset;
+    mapping.size = object->size;
+
+    buffer_mappings[params.offset] = mapping;
+
+    std::memcpy(output.data(), &params, output.size());
+    return 0;
+}
+
+u32 nvhost_as_gpu::UnmapBuffer(const std::vector<u8>& input, std::vector<u8>& output) {
+    IoctlUnmapBuffer params{};
+    std::memcpy(&params, input.data(), input.size());
+
+    NGLOG_DEBUG(Service_NVDRV, "called, offset=0x{:X}", params.offset);
+
+    auto& gpu = Core::System::GetInstance().GPU();
+
+    auto itr = buffer_mappings.find(params.offset);
+
+    ASSERT_MSG(itr != buffer_mappings.end(), "Tried to unmap invalid mapping");
+
+    params.offset = gpu.memory_manager->UnmapBuffer(params.offset, itr->second.size);
+
+    buffer_mappings.erase(itr->second.offset);
+
     std::memcpy(output.data(), &params, output.size());
     return 0;
 }

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

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <memory>
+#include <unordered_map>
 #include <utility>
 #include <vector>
 #include "common/common_types.h"
@@ -30,6 +31,7 @@ private:
         IocMapBufferExCommand = 0xC0284106,
         IocBindChannelCommand = 0x40044101,
         IocGetVaRegionsCommand = 0xC0404108,
+        IocUnmapBufferCommand = 0xC0084105,
     };
 
     struct IoctlInitalizeEx {
@@ -76,6 +78,11 @@ private:
     };
     static_assert(sizeof(IoctlMapBufferEx) == 40, "IoctlMapBufferEx is incorrect size");
 
+    struct IoctlUnmapBuffer {
+        u64_le offset;
+    };
+    static_assert(sizeof(IoctlUnmapBuffer) == 8, "IoctlUnmapBuffer is incorrect size");
+
     struct IoctlBindChannel {
         u32_le fd;
     };
@@ -98,12 +105,22 @@ private:
     static_assert(sizeof(IoctlGetVaRegions) == 16 + sizeof(IoctlVaRegion) * 2,
                   "IoctlGetVaRegions is incorrect size");
 
+    struct BufferMapping {
+        u64 offset;
+        u64 size;
+        u32 nvmap_handle;
+    };
+
+    /// Map containing the nvmap object mappings in GPU memory.
+    std::unordered_map<u64, BufferMapping> buffer_mappings;
+
     u32 channel{};
 
     u32 InitalizeEx(const std::vector<u8>& input, std::vector<u8>& output);
     u32 AllocateSpace(const std::vector<u8>& input, std::vector<u8>& output);
     u32 Remap(const std::vector<u8>& input, std::vector<u8>& output);
     u32 MapBufferEx(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 UnmapBuffer(const std::vector<u8>& input, std::vector<u8>& output);
     u32 BindChannel(const std::vector<u8>& input, std::vector<u8>& output);
     u32 GetVARegions(const std::vector<u8>& input, std::vector<u8>& output);
 

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

@@ -36,7 +36,7 @@ u32 nvhost_ctrl::NvOsGetConfigU32(const std::vector<u8>& input, std::vector<u8>&
         } else if (!strcmp(params.param_str.data(), "NVRM_GPU_PREVENT_USE")) {
             params.config_str[0] = '0';
         } else {
-            params.config_str[0] = '0';
+            params.config_str[0] = '\0';
         }
     } else {
         UNIMPLEMENTED(); // unknown domain? Only nv has been seen so far on hardware

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

@@ -26,12 +26,64 @@ private:
         IocSyncptIncrCommand = 0x40040015,
         IocSyncptWaitCommand = 0xC00C0016,
         IocModuleMutexCommand = 0x40080017,
-        IocModuleRegRDWRCommand = 0xC008010E,
+        IocModuleRegRDWRCommand = 0xC0180018,
         IocSyncptWaitexCommand = 0xC0100019,
         IocSyncptReadMaxCommand = 0xC008001A,
-        IocCtrlEventWaitCommand = 0xC010001D,
         IocGetConfigCommand = 0xC183001B,
+        IocCtrlEventSignalCommand = 0xC004001C,
+        IocCtrlEventWaitCommand = 0xC010001D,
+        IocCtrlEventWaitAsyncCommand = 0xC010001E,
+        IocCtrlEventRegisterCommand = 0xC004001F,
+        IocCtrlEventUnregisterCommand = 0xC0040020,
+        IocCtrlEventKillCommand = 0x40080021,
     };
+    struct IocSyncptReadParams {
+        u32_le id;
+        u32_le value;
+    };
+    static_assert(sizeof(IocSyncptReadParams) == 8, "IocSyncptReadParams is incorrect size");
+
+    struct IocSyncptIncrParams {
+        u32_le id;
+    };
+    static_assert(sizeof(IocSyncptIncrParams) == 4, "IocSyncptIncrParams is incorrect size");
+
+    struct IocSyncptWaitParams {
+        u32_le id;
+        u32_le thresh;
+        s32_le timeout;
+    };
+    static_assert(sizeof(IocSyncptWaitParams) == 12, "IocSyncptWaitParams is incorrect size");
+
+    struct IocModuleMutexParams {
+        u32_le id;
+        u32_le lock; // (0 = unlock and 1 = lock)
+    };
+    static_assert(sizeof(IocModuleMutexParams) == 8, "IocModuleMutexParams is incorrect size");
+
+    struct IocModuleRegRDWRParams {
+        u32_le id;
+        u32_le num_offsets;
+        u32_le block_size;
+        u32_le offsets;
+        u32_le values;
+        u32_le write;
+    };
+    static_assert(sizeof(IocModuleRegRDWRParams) == 24, "IocModuleRegRDWRParams is incorrect size");
+
+    struct IocSyncptWaitexParams {
+        u32_le id;
+        u32_le thresh;
+        s32_le timeout;
+        u32_le value;
+    };
+    static_assert(sizeof(IocSyncptWaitexParams) == 16, "IocSyncptWaitexParams is incorrect size");
+
+    struct IocSyncptReadMaxParams {
+        u32_le id;
+        u32_le value;
+    };
+    static_assert(sizeof(IocSyncptReadMaxParams) == 8, "IocSyncptReadMaxParams is incorrect size");
 
     struct IocGetConfigParams {
         std::array<char, 0x41> domain_str;
@@ -40,6 +92,12 @@ private:
     };
     static_assert(sizeof(IocGetConfigParams) == 387, "IocGetConfigParams is incorrect size");
 
+    struct IocCtrlEventSignalParams {
+        u32_le user_event_id;
+    };
+    static_assert(sizeof(IocCtrlEventSignalParams) == 4,
+                  "IocCtrlEventSignalParams is incorrect size");
+
     struct IocCtrlEventWaitParams {
         u32_le syncpt_id;
         u32_le threshold;
@@ -48,6 +106,32 @@ private:
     };
     static_assert(sizeof(IocCtrlEventWaitParams) == 16, "IocCtrlEventWaitParams is incorrect size");
 
+    struct IocCtrlEventWaitAsyncParams {
+        u32_le syncpt_id;
+        u32_le threshold;
+        u32_le timeout;
+        u32_le value;
+    };
+    static_assert(sizeof(IocCtrlEventWaitAsyncParams) == 16,
+                  "IocCtrlEventWaitAsyncParams is incorrect size");
+
+    struct IocCtrlEventRegisterParams {
+        u32_le user_event_id;
+    };
+    static_assert(sizeof(IocCtrlEventRegisterParams) == 4,
+                  "IocCtrlEventRegisterParams is incorrect size");
+
+    struct IocCtrlEventUnregisterParams {
+        u32_le user_event_id;
+    };
+    static_assert(sizeof(IocCtrlEventUnregisterParams) == 4,
+                  "IocCtrlEventUnregisterParams is incorrect size");
+
+    struct IocCtrlEventKill {
+        u64_le user_events;
+    };
+    static_assert(sizeof(IocCtrlEventKill) == 8, "IocCtrlEventKill is incorrect size");
+
     u32 NvOsGetConfigU32(const std::vector<u8>& input, std::vector<u8>& output);
 
     u32 IocCtrlEventWait(const std::vector<u8>& input, std::vector<u8>& output);

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

@@ -24,6 +24,8 @@ u32 nvhost_ctrl_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vec
         return ZCullGetCtxSize(input, output);
     case IoctlCommand::IocZcullGetInfo:
         return ZCullGetInfo(input, output);
+    case IoctlCommand::IocZbcSetTable:
+        return ZBCSetTable(input, output);
     }
     UNIMPLEMENTED_MSG("Unimplemented ioctl");
     return 0;
@@ -125,4 +127,13 @@ u32 nvhost_ctrl_gpu::ZCullGetInfo(const std::vector<u8>& input, std::vector<u8>&
     return 0;
 }
 
+u32 nvhost_ctrl_gpu::ZBCSetTable(const std::vector<u8>& input, std::vector<u8>& output) {
+    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called");
+    IoctlZbcSetTable params{};
+    std::memcpy(&params, input.data(), input.size());
+    // TODO(ogniK): What does this even actually do?
+    std::memcpy(output.data(), &params, output.size());
+    return 0;
+}
+
 } // namespace Service::Nvidia::Devices

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

@@ -25,6 +25,7 @@ private:
         IocGetActiveSlotMaskCommand = 0x80084714,
         IocZcullGetCtxSizeCommand = 0x80044701,
         IocZcullGetInfo = 0x80284702,
+        IocZbcSetTable = 0x402C4703,
     };
 
     struct IoctlGpuCharacteristics {
@@ -117,11 +118,21 @@ private:
     static_assert(sizeof(IoctlNvgpuGpuZcullGetInfoArgs) == 40,
                   "IoctlNvgpuGpuZcullGetInfoArgs is incorrect size");
 
+    struct IoctlZbcSetTable {
+        u32_le color_ds[4];
+        u32_le color_l2[4];
+        u32_le depth;
+        u32_le format;
+        u32_le type;
+    };
+    static_assert(sizeof(IoctlZbcSetTable) == 44, "IoctlZbcSetTable is incorrect size");
+
     u32 GetCharacteristics(const std::vector<u8>& input, std::vector<u8>& output);
     u32 GetTPCMasks(const std::vector<u8>& input, std::vector<u8>& output);
     u32 GetActiveSlotMask(const std::vector<u8>& input, std::vector<u8>& output);
     u32 ZCullGetCtxSize(const std::vector<u8>& input, std::vector<u8>& output);
     u32 ZCullGetInfo(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 ZBCSetTable(const std::vector<u8>& input, std::vector<u8>& output);
 };
 
 } // namespace Service::Nvidia::Devices

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

@@ -32,6 +32,10 @@ u32 nvhost_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u
         return AllocGPFIFOEx2(input, output);
     case IoctlCommand::IocAllocObjCtxCommand:
         return AllocateObjectContext(input, output);
+    case IoctlCommand::IocChannelGetWaitbaseCommand:
+        return GetWaitbase(input, output);
+    case IoctlCommand::IocChannelSetTimeoutCommand:
+        return ChannelSetTimeout(input, output);
     }
 
     if (command.group == NVGPU_IOCTL_MAGIC) {
@@ -138,4 +142,20 @@ u32 nvhost_gpu::SubmitGPFIFO(const std::vector<u8>& input, std::vector<u8>& outp
     return 0;
 }
 
+u32 nvhost_gpu::GetWaitbase(const std::vector<u8>& input, std::vector<u8>& output) {
+    IoctlGetWaitbase params{};
+    std::memcpy(&params, input.data(), sizeof(IoctlGetWaitbase));
+    NGLOG_INFO(Service_NVDRV, "called, unknown=0x{:X}", params.unknown);
+    params.value = 0; // Seems to be hard coded at 0
+    std::memcpy(output.data(), &params, output.size());
+    return 0;
+}
+
+u32 nvhost_gpu::ChannelSetTimeout(const std::vector<u8>& input, std::vector<u8>& output) {
+    IoctlChannelSetTimeout params{};
+    std::memcpy(&params, input.data(), sizeof(IoctlChannelSetTimeout));
+    NGLOG_INFO(Service_NVDRV, "called, timeout=0x{:X}", params.timeout);
+    return 0;
+}
+
 } // namespace Service::Nvidia::Devices

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

@@ -33,6 +33,8 @@ private:
         IocChannelSetPriorityCommand = 0x4004480D,
         IocAllocGPFIFOEx2Command = 0xC020481A,
         IocAllocObjCtxCommand = 0xC0104809,
+        IocChannelGetWaitbaseCommand = 0xC0080003,
+        IocChannelSetTimeoutCommand = 0x40044803,
     };
 
     enum class CtxObjects : u32_le {
@@ -49,6 +51,11 @@ private:
     };
     static_assert(sizeof(IoctlSetNvmapFD) == 4, "IoctlSetNvmapFD is incorrect size");
 
+    struct IoctlChannelSetTimeout {
+        u32_le timeout;
+    };
+    static_assert(sizeof(IoctlChannelSetTimeout) == 4, "IoctlChannelSetTimeout is incorrect size");
+
     struct IoctlClientData {
         u64_le data;
     };
@@ -117,7 +124,13 @@ private:
         IoctlFence fence_out; // returned new fence object for others to wait on
     };
     static_assert(sizeof(IoctlSubmitGpfifo) == 16 + sizeof(IoctlFence),
-                  "submit_gpfifo is incorrect size");
+                  "IoctlSubmitGpfifo is incorrect size");
+
+    struct IoctlGetWaitbase {
+        u32 unknown; // seems to be ignored? Nintendo added this
+        u32 value;
+    };
+    static_assert(sizeof(IoctlGetWaitbase) == 8, "IoctlGetWaitbase is incorrect size");
 
     u32_le nvmap_fd{};
     u64_le user_data{};
@@ -133,6 +146,8 @@ private:
     u32 AllocGPFIFOEx2(const std::vector<u8>& input, std::vector<u8>& output);
     u32 AllocateObjectContext(const std::vector<u8>& input, std::vector<u8>& output);
     u32 SubmitGPFIFO(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 GetWaitbase(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 ChannelSetTimeout(const std::vector<u8>& input, std::vector<u8>& output);
 
     std::shared_ptr<nvmap> nvmap_dev;
 };

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

@@ -30,6 +30,8 @@ u32 nvmap::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& o
         return IocFromId(input, output);
     case IoctlCommand::Param:
         return IocParam(input, output);
+    case IoctlCommand::Free:
+        return IocFree(input, output);
     }
 
     UNIMPLEMENTED_MSG("Unimplemented ioctl");
@@ -45,6 +47,7 @@ u32 nvmap::IocCreate(const std::vector<u8>& input, std::vector<u8>& output) {
     object->id = next_id++;
     object->size = params.size;
     object->status = Object::Status::Created;
+    object->refcount = 1;
 
     u32 handle = next_handle++;
     handles[handle] = std::move(object);
@@ -101,6 +104,8 @@ u32 nvmap::IocFromId(const std::vector<u8>& input, std::vector<u8>& output) {
                             [&](const auto& entry) { return entry.second->id == params.id; });
     ASSERT(itr != handles.end());
 
+    itr->second->refcount++;
+
     // Return the existing handle instead of creating a new one.
     params.handle = itr->first;
 
@@ -114,25 +119,25 @@ u32 nvmap::IocParam(const std::vector<u8>& input, std::vector<u8>& output) {
     IocParamParams params;
     std::memcpy(&params, input.data(), sizeof(params));
 
-    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called type={}", params.type);
+    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called type={}", params.param);
 
     auto object = GetObject(params.handle);
     ASSERT(object);
     ASSERT(object->status == Object::Status::Allocated);
 
-    switch (static_cast<ParamTypes>(params.type)) {
+    switch (static_cast<ParamTypes>(params.param)) {
     case ParamTypes::Size:
-        params.value = object->size;
+        params.result = object->size;
         break;
     case ParamTypes::Alignment:
-        params.value = object->align;
+        params.result = object->align;
         break;
     case ParamTypes::Heap:
         // TODO(Subv): Seems to be a hardcoded value?
-        params.value = 0x40000000;
+        params.result = 0x40000000;
         break;
     case ParamTypes::Kind:
-        params.value = object->kind;
+        params.result = object->kind;
         break;
     default:
         UNIMPLEMENTED();
@@ -142,4 +147,34 @@ u32 nvmap::IocParam(const std::vector<u8>& input, std::vector<u8>& output) {
     return 0;
 }
 
+u32 nvmap::IocFree(const std::vector<u8>& input, std::vector<u8>& output) {
+    enum FreeFlags {
+        Freed = 0,
+        NotFreedYet = 1,
+    };
+
+    IocFreeParams params;
+    std::memcpy(&params, input.data(), sizeof(params));
+
+    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called");
+
+    auto itr = handles.find(params.handle);
+    ASSERT(itr != handles.end());
+
+    itr->second->refcount--;
+
+    params.refcount = itr->second->refcount;
+    params.size = itr->second->size;
+
+    if (itr->second->refcount == 0)
+        params.flags = Freed;
+    else
+        params.flags = NotFreedYet;
+
+    handles.erase(params.handle);
+
+    std::memcpy(output.data(), &params, sizeof(params));
+    return 0;
+}
+
 } // namespace Service::Nvidia::Devices

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

@@ -34,6 +34,7 @@ public:
         u8 kind;
         VAddr addr;
         Status status;
+        u32 refcount;
     };
 
     std::shared_ptr<Object> GetObject(u32 handle) const {
@@ -58,16 +59,25 @@ private:
         Create = 0xC0080101,
         FromId = 0xC0080103,
         Alloc = 0xC0200104,
+        Free = 0xC0180105,
         Param = 0xC00C0109,
-        GetId = 0xC008010E
+        GetId = 0xC008010E,
     };
-
     struct IocCreateParams {
         // Input
         u32_le size;
         // Output
         u32_le handle;
     };
+    static_assert(sizeof(IocCreateParams) == 8, "IocCreateParams has wrong size");
+
+    struct IocFromIdParams {
+        // Input
+        u32_le id;
+        // Output
+        u32_le handle;
+    };
+    static_assert(sizeof(IocFromIdParams) == 8, "IocFromIdParams has wrong size");
 
     struct IocAllocParams {
         // Input
@@ -79,6 +89,25 @@ private:
         INSERT_PADDING_BYTES(7);
         u64_le addr;
     };
+    static_assert(sizeof(IocAllocParams) == 32, "IocAllocParams has wrong size");
+
+    struct IocFreeParams {
+        u32_le handle;
+        INSERT_PADDING_BYTES(4);
+        u64_le refcount;
+        u32_le size;
+        u32_le flags;
+    };
+    static_assert(sizeof(IocFreeParams) == 24, "IocFreeParams has wrong size");
+
+    struct IocParamParams {
+        // Input
+        u32_le handle;
+        u32_le param;
+        // Output
+        u32_le result;
+    };
+    static_assert(sizeof(IocParamParams) == 12, "IocParamParams has wrong size");
 
     struct IocGetIdParams {
         // Output
@@ -86,27 +115,14 @@ private:
         // Input
         u32_le handle;
     };
-
-    struct IocFromIdParams {
-        // Input
-        u32_le id;
-        // Output
-        u32_le handle;
-    };
-
-    struct IocParamParams {
-        // Input
-        u32_le handle;
-        u32_le type;
-        // Output
-        u32_le value;
-    };
+    static_assert(sizeof(IocGetIdParams) == 8, "IocGetIdParams has wrong size");
 
     u32 IocCreate(const std::vector<u8>& input, std::vector<u8>& output);
     u32 IocAlloc(const std::vector<u8>& input, std::vector<u8>& output);
     u32 IocGetId(const std::vector<u8>& input, std::vector<u8>& output);
     u32 IocFromId(const std::vector<u8>& input, std::vector<u8>& output);
     u32 IocParam(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 IocFree(const std::vector<u8>& input, std::vector<u8>& output);
 };
 
 } // namespace Service::Nvidia::Devices

src/core/hle/service/service.cpp

@@ -20,6 +20,7 @@
 #include "core/hle/service/aoc/aoc_u.h"
 #include "core/hle/service/apm/apm.h"
 #include "core/hle/service/audio/audio.h"
+#include "core/hle/service/bcat/bcat.h"
 #include "core/hle/service/fatal/fatal.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/friend/friend.h"
@@ -144,10 +145,12 @@ ResultCode ServiceFrameworkBase::HandleSyncRequest(Kernel::HLERequestContext& co
         rb.Push(RESULT_SUCCESS);
         return ResultCode(ErrorModule::HIPC, ErrorDescription::RemoteProcessDead);
     }
+    case IPC::CommandType::ControlWithContext:
     case IPC::CommandType::Control: {
         Core::System::GetInstance().ServiceManager().InvokeControlRequest(context);
         break;
     }
+    case IPC::CommandType::RequestWithContext:
     case IPC::CommandType::Request: {
         InvokeRequest(context);
         break;
@@ -181,6 +184,7 @@ void Init(std::shared_ptr<SM::ServiceManager>& sm) {
     AM::InstallInterfaces(*sm, nv_flinger);
     AOC::InstallInterfaces(*sm);
     APM::InstallInterfaces(*sm);
+    BCAT::InstallInterfaces(*sm);
     Audio::InstallInterfaces(*sm);
     Fatal::InstallInterfaces(*sm);
     FileSystem::InstallInterfaces(*sm);

src/video_core/command_processor.cpp

@@ -36,7 +36,6 @@ void GPU::WriteReg(u32 method, u32 subchannel, u32 value, u32 remaining_params)
     if (method == static_cast<u32>(BufferMethods::BindObject)) {
         // Bind the current subchannel to the desired engine id.
         NGLOG_DEBUG(HW_GPU, "Binding subchannel {} to engine {}", subchannel, value);
-        ASSERT(bound_engines.find(subchannel) == bound_engines.end());
         bound_engines[subchannel] = static_cast<EngineID>(value);
         return;
     }

src/video_core/engines/shader_bytecode.h

@@ -1,4 +1,4 @@
-// Copyright 2018 yuzu Emulator Project
+// Copyright 2018 yuzu Emulator Project
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
@@ -193,6 +193,11 @@ union Instruction {
         BitField<50, 1, u64> abs_d;
         BitField<56, 1, u64> negate_imm;
 
+        union {
+            BitField<39, 3, u64> pred;
+            BitField<42, 1, u64> negate_pred;
+        } fmnmx;
+
         float GetImm20_19() const {
             float result{};
             u32 imm{static_cast<u32>(imm20_19)};
@@ -310,7 +315,9 @@ public:
         SHR_C,
         SHR_R,
         SHR_IMM,
-        FMNMX,
+        FMNMX_C,
+        FMNMX_R,
+        FMNMX_IMM,
         FSETP_C, // Set Predicate
         FSETP_R,
         FSETP_IMM,
@@ -320,6 +327,7 @@ public:
         ISETP_C,
         ISETP_IMM,
         ISETP_R,
+        PSETP,
     };
 
     enum class Type {
@@ -331,6 +339,7 @@ public:
         FloatSet,
         FloatSetPredicate,
         IntegerSetPredicate,
+        PredicateSetPredicate,
         Conversion,
         Unknown,
     };
@@ -461,7 +470,9 @@ private:
             INST("0100110000101---", Id::SHR_C, Type::Arithmetic, "SHR_C"),
             INST("0101110000101---", Id::SHR_R, Type::Arithmetic, "SHR_R"),
             INST("0011100-00101---", Id::SHR_IMM, Type::Arithmetic, "SHR_IMM"),
-            INST("0101110001100---", Id::FMNMX, Type::Arithmetic, "FMNMX"),
+            INST("0100110001100---", Id::FMNMX_C, Type::Arithmetic, "FMNMX_C"),
+            INST("0101110001100---", Id::FMNMX_R, Type::Arithmetic, "FMNMX_R"),
+            INST("0011100-01100---", Id::FMNMX_IMM, Type::Arithmetic, "FMNMX_IMM"),
             INST("0100110011100---", Id::I2I_C, Type::Conversion, "I2I_C"),
             INST("0101110011100---", Id::I2I_R, Type::Conversion, "I2I_R"),
             INST("01110001-1000---", Id::I2I_IMM, Type::Conversion, "I2I_IMM"),
@@ -477,6 +488,7 @@ private:
             INST("010010110110----", Id::ISETP_C, Type::IntegerSetPredicate, "ISETP_C"),
             INST("010110110110----", Id::ISETP_R, Type::IntegerSetPredicate, "ISETP_R"),
             INST("0011011-0110----", Id::ISETP_IMM, Type::IntegerSetPredicate, "ISETP_IMM"),
+            INST("0101000010010---", Id::PSETP, Type::PredicateSetPredicate, "PSETP"),
         };
 #undef INST
         std::stable_sort(table.begin(), table.end(), [](const auto& a, const auto& b) {

src/video_core/memory_manager.cpp

@@ -58,6 +58,25 @@ GPUVAddr MemoryManager::MapBufferEx(VAddr cpu_addr, GPUVAddr gpu_addr, u64 size)
     return gpu_addr;
 }
 
+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);
+    }
+
+    // Delete the region mappings that are contained within the unmapped region
+    mapped_regions.erase(std::remove_if(mapped_regions.begin(), mapped_regions.end(),
+                                        [&](const MappedRegion& region) {
+                                            return region.gpu_addr <= gpu_addr &&
+                                                   region.gpu_addr + region.size < gpu_addr + size;
+                                        }),
+                         mapped_regions.end());
+    return gpu_addr;
+}
+
 boost::optional<GPUVAddr> MemoryManager::FindFreeBlock(u64 size, u64 align) {
     GPUVAddr gpu_addr = 0;
     u64 free_space = 0;

src/video_core/memory_manager.h

@@ -25,6 +25,7 @@ public:
     GPUVAddr AllocateSpace(GPUVAddr gpu_addr, u64 size, u64 align);
     GPUVAddr MapBufferEx(VAddr cpu_addr, u64 size);
     GPUVAddr MapBufferEx(VAddr cpu_addr, GPUVAddr gpu_addr, u64 size);
+    GPUVAddr UnmapBuffer(GPUVAddr gpu_addr, u64 size);
     boost::optional<VAddr> GpuToCpuAddress(GPUVAddr gpu_addr);
     std::vector<GPUVAddr> CpuToGpuAddress(VAddr cpu_addr) const;
 

src/video_core/renderer_opengl/gl_rasterizer_cache.cpp

@@ -47,6 +47,8 @@ static constexpr std::array<FormatTuple, SurfaceParams::MaxPixelFormat> tex_form
     {GL_RGBA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, false},                    // ABGR8
     {GL_RGB, GL_RGB, GL_UNSIGNED_SHORT_5_6_5_REV, false},                       // B5G6R5
     {GL_RGB10_A2, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, false},              // A2B10G10R10
+    {GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_SHORT_1_5_5_5_REV, false},                // A1B5G5R5
+    {GL_R8, GL_RED, GL_UNSIGNED_BYTE, false},                                   // R8
     {GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GL_RGB, GL_UNSIGNED_INT_8_8_8_8, true},   // DXT1
     {GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, true}, // DXT23
     {GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, true}, // DXT45
@@ -107,7 +109,8 @@ static constexpr std::array<void (*)(u32, u32, u32, u8*, Tegra::GPUVAddr, Tegra:
                             SurfaceParams::MaxPixelFormat>
     morton_to_gl_fns = {
         MortonCopy<true, PixelFormat::ABGR8>,       MortonCopy<true, PixelFormat::B5G6R5>,
-        MortonCopy<true, PixelFormat::A2B10G10R10>, MortonCopy<true, PixelFormat::DXT1>,
+        MortonCopy<true, PixelFormat::A2B10G10R10>, MortonCopy<true, PixelFormat::A1B5G5R5>,
+        MortonCopy<true, PixelFormat::R8>,          MortonCopy<true, PixelFormat::DXT1>,
         MortonCopy<true, PixelFormat::DXT23>,       MortonCopy<true, PixelFormat::DXT45>,
 };
 
@@ -118,6 +121,8 @@ static constexpr std::array<void (*)(u32, u32, u32, u8*, Tegra::GPUVAddr, Tegra:
         MortonCopy<false, PixelFormat::ABGR8>,
         MortonCopy<false, PixelFormat::B5G6R5>,
         MortonCopy<false, PixelFormat::A2B10G10R10>,
+        MortonCopy<false, PixelFormat::A1B5G5R5>,
+        MortonCopy<false, PixelFormat::R8>,
         // TODO(Subv): Swizzling the DXT1/DXT23/DXT45 formats is not yet supported
         nullptr,
         nullptr,

src/video_core/renderer_opengl/gl_rasterizer_cache.h

@@ -57,9 +57,11 @@ struct SurfaceParams {
         ABGR8 = 0,
         B5G6R5 = 1,
         A2B10G10R10 = 2,
-        DXT1 = 3,
-        DXT23 = 4,
-        DXT45 = 5,
+        A1B5G5R5 = 3,
+        R8 = 4,
+        DXT1 = 5,
+        DXT23 = 6,
+        DXT45 = 7,
 
         Max,
         Invalid = 255,
@@ -98,6 +100,8 @@ struct SurfaceParams {
             1, // ABGR8
             1, // B5G6R5
             1, // A2B10G10R10
+            1, // A1B5G5R5
+            1, // R8
             4, // DXT1
             4, // DXT23
             4, // DXT45
@@ -118,6 +122,8 @@ struct SurfaceParams {
             32,  // ABGR8
             16,  // B5G6R5
             32,  // A2B10G10R10
+            16,  // A1B5G5R5
+            8,   // R8
             64,  // DXT1
             128, // DXT23
             128, // DXT45
@@ -133,6 +139,7 @@ struct SurfaceParams {
     static PixelFormat PixelFormatFromRenderTargetFormat(Tegra::RenderTargetFormat format) {
         switch (format) {
         case Tegra::RenderTargetFormat::RGBA8_UNORM:
+        case Tegra::RenderTargetFormat::RGBA8_SRGB:
             return PixelFormat::ABGR8;
         case Tegra::RenderTargetFormat::RGB10_A2_UNORM:
             return PixelFormat::A2B10G10R10;
@@ -161,6 +168,10 @@ struct SurfaceParams {
             return PixelFormat::B5G6R5;
         case Tegra::Texture::TextureFormat::A2B10G10R10:
             return PixelFormat::A2B10G10R10;
+        case Tegra::Texture::TextureFormat::A1B5G5R5:
+            return PixelFormat::A1B5G5R5;
+        case Tegra::Texture::TextureFormat::R8:
+            return PixelFormat::R8;
         case Tegra::Texture::TextureFormat::DXT1:
             return PixelFormat::DXT1;
         case Tegra::Texture::TextureFormat::DXT23:
@@ -182,6 +193,10 @@ struct SurfaceParams {
             return Tegra::Texture::TextureFormat::B5G6R5;
         case PixelFormat::A2B10G10R10:
             return Tegra::Texture::TextureFormat::A2B10G10R10;
+        case PixelFormat::A1B5G5R5:
+            return Tegra::Texture::TextureFormat::A1B5G5R5;
+        case PixelFormat::R8:
+            return Tegra::Texture::TextureFormat::R8;
         case PixelFormat::DXT1:
             return Tegra::Texture::TextureFormat::DXT1;
         case PixelFormat::DXT23:
@@ -208,6 +223,7 @@ struct SurfaceParams {
         // TODO(Subv): Implement more render targets
         switch (format) {
         case Tegra::RenderTargetFormat::RGBA8_UNORM:
+        case Tegra::RenderTargetFormat::RGBA8_SRGB:
         case Tegra::RenderTargetFormat::RGB10_A2_UNORM:
             return ComponentType::UNorm;
         default:

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -580,20 +580,62 @@ private:
      * @param instr Instruction to generate the if condition for.
      * @returns string containing the predicate condition.
      */
-    std::string GetPredicateCondition(Instruction instr) const {
+    std::string GetPredicateCondition(u64 index, bool negate) const {
         using Tegra::Shader::Pred;
-        ASSERT(instr.pred.pred_index != static_cast<u64>(Pred::UnusedIndex));
+        std::string variable;
 
-        std::string variable =
-            'p' + std::to_string(static_cast<u64>(instr.pred.pred_index.Value()));
+        // Index 7 is used as an 'Always True' condition.
+        if (index == static_cast<u64>(Pred::UnusedIndex))
+            variable = "true";
+        else
+            variable = 'p' + std::to_string(index);
 
-        if (instr.negate_pred) {
+        if (negate) {
             return "!(" + variable + ')';
         }
 
         return variable;
     }
 
+    /**
+     * Returns the comparison string to use to compare two values in the 'set' family of
+     * instructions.
+     * @params condition The condition used in the 'set'-family instruction.
+     * @returns String corresponding to the GLSL operator that matches the desired comparison.
+     */
+    std::string GetPredicateComparison(Tegra::Shader::PredCondition condition) const {
+        using Tegra::Shader::PredCondition;
+        static const std::unordered_map<PredCondition, const char*> PredicateComparisonStrings = {
+            {PredCondition::LessThan, "<"},      {PredCondition::Equal, "=="},
+            {PredCondition::LessEqual, "<="},    {PredCondition::GreaterThan, ">"},
+            {PredCondition::GreaterEqual, ">="},
+        };
+
+        auto comparison = PredicateComparisonStrings.find(condition);
+        ASSERT_MSG(comparison != PredicateComparisonStrings.end(),
+                   "Unknown predicate comparison operation");
+        return comparison->second;
+    }
+
+    /**
+     * Returns the operator string to use to combine two predicates in the 'setp' family of
+     * instructions.
+     * @params operation The operator used in the 'setp'-family instruction.
+     * @returns String corresponding to the GLSL operator that matches the desired operator.
+     */
+    std::string GetPredicateCombiner(Tegra::Shader::PredOperation operation) const {
+        using Tegra::Shader::PredOperation;
+        static const std::unordered_map<PredOperation, const char*> PredicateOperationStrings = {
+            {PredOperation::And, "&&"},
+            {PredOperation::Or, "||"},
+            {PredOperation::Xor, "^^"},
+        };
+
+        auto op = PredicateOperationStrings.find(operation);
+        ASSERT_MSG(op != PredicateOperationStrings.end(), "Unknown predicate operation");
+        return op->second;
+    }
+
     /*
      * Returns whether the instruction at the specified offset is a 'sched' instruction.
      * Sched instructions always appear before a sequence of 3 instructions.
@@ -634,7 +676,9 @@ private:
                    "NeverExecute predicate not implemented");
 
         if (instr.pred.pred_index != static_cast<u64>(Pred::UnusedIndex)) {
-            shader.AddLine("if (" + GetPredicateCondition(instr) + ')');
+            shader.AddLine("if (" +
+                           GetPredicateCondition(instr.pred.pred_index, instr.negate_pred != 0) +
+                           ')');
             shader.AddLine('{');
             ++shader.scope;
         }
@@ -730,6 +774,18 @@ private:
                 }
                 break;
             }
+            case OpCode::Id::FMNMX_C:
+            case OpCode::Id::FMNMX_R:
+            case OpCode::Id::FMNMX_IMM: {
+                std::string condition =
+                    GetPredicateCondition(instr.alu.fmnmx.pred, instr.alu.fmnmx.negate_pred != 0);
+                std::string parameters = op_a + ',' + op_b;
+                regs.SetRegisterToFloat(instr.gpr0, 0,
+                                        '(' + condition + ") ? min(" + parameters + ") : max(" +
+                                            parameters + ')',
+                                        1, 1);
+                break;
+            }
             case OpCode::Id::RRO: {
                 NGLOG_DEBUG(HW_GPU, "Skipping RRO instruction");
                 break;
@@ -873,28 +929,25 @@ private:
             }
 
             using Tegra::Shader::Pred;
-            ASSERT_MSG(instr.fsetp.pred0 == static_cast<u64>(Pred::UnusedIndex) &&
-                           instr.fsetp.pred39 == static_cast<u64>(Pred::UnusedIndex),
-                       "Compound predicates are not implemented");
-
             // We can't use the constant predicate as destination.
             ASSERT(instr.fsetp.pred3 != static_cast<u64>(Pred::UnusedIndex));
 
-            using Tegra::Shader::PredCondition;
-            switch (instr.fsetp.cond) {
-            case PredCondition::LessThan:
-                SetPredicate(instr.fsetp.pred3, '(' + op_a + ") < (" + op_b + ')');
-                break;
-            case PredCondition::Equal:
-                SetPredicate(instr.fsetp.pred3, '(' + op_a + ") == (" + op_b + ')');
-                break;
-            case PredCondition::LessEqual:
-                SetPredicate(instr.fsetp.pred3, '(' + op_a + ") <= (" + op_b + ')');
-                break;
-            default:
-                NGLOG_CRITICAL(HW_GPU, "Unhandled predicate condition: {} (a: {}, b: {})",
-                               static_cast<unsigned>(instr.fsetp.cond.Value()), op_a, op_b);
-                UNREACHABLE();
+            std::string second_pred =
+                GetPredicateCondition(instr.fsetp.pred39, instr.fsetp.neg_pred != 0);
+
+            std::string comparator = GetPredicateComparison(instr.fsetp.cond);
+            std::string combiner = GetPredicateCombiner(instr.fsetp.op);
+
+            std::string predicate = '(' + op_a + ") " + comparator + " (" + op_b + ')';
+            // Set the primary predicate to the result of Predicate OP SecondPredicate
+            SetPredicate(instr.fsetp.pred3,
+                         '(' + predicate + ") " + combiner + " (" + second_pred + ')');
+
+            if (instr.fsetp.pred0 != static_cast<u64>(Pred::UnusedIndex)) {
+                // Set the secondary predicate to the result of !Predicate OP SecondPredicate, if
+                // enabled
+                SetPredicate(instr.fsetp.pred0,
+                             "!(" + predicate + ") " + combiner + " (" + second_pred + ')');
             }
             break;
         }
@@ -926,35 +979,18 @@ private:
                 op_b = "abs(" + op_b + ')';
             }
 
-            using Tegra::Shader::Pred;
-            ASSERT_MSG(instr.fset.pred39 == static_cast<u64>(Pred::UnusedIndex),
-                       "Compound predicates are not implemented");
-
             // The fset instruction sets a register to 1.0 if the condition is true, and to 0
             // otherwise.
-            using Tegra::Shader::PredCondition;
-            switch (instr.fset.cond) {
-            case PredCondition::LessThan:
-                regs.SetRegisterToFloat(instr.gpr0, 0,
-                                        "((" + op_a + ") < (" + op_b + ")) ? 1.0 : 0", 1, 1);
-                break;
-            case PredCondition::Equal:
-                regs.SetRegisterToFloat(instr.gpr0, 0,
-                                        "((" + op_a + ") == (" + op_b + ")) ? 1.0 : 0", 1, 1);
-                break;
-            case PredCondition::LessEqual:
-                regs.SetRegisterToFloat(instr.gpr0, 0,
-                                        "((" + op_a + ") <= (" + op_b + ")) ? 1.0 : 0", 1, 1);
-                break;
-            case PredCondition::GreaterThan:
-                regs.SetRegisterToFloat(instr.gpr0, 0,
-                                        "((" + op_a + ") > (" + op_b + ")) ? 1.0 : 0", 1, 1);
-                break;
-            default:
-                NGLOG_CRITICAL(HW_GPU, "Unhandled predicate condition: {} (a: {}, b: {})",
-                               static_cast<unsigned>(instr.fset.cond.Value()), op_a, op_b);
-                UNREACHABLE();
-            }
+            std::string second_pred =
+                GetPredicateCondition(instr.fset.pred39, instr.fset.neg_pred != 0);
+
+            std::string comparator = GetPredicateComparison(instr.fset.cond);
+            std::string combiner = GetPredicateCombiner(instr.fset.op);
+
+            std::string predicate = "(((" + op_a + ") " + comparator + " (" + op_b + ")) " +
+                                    combiner + " (" + second_pred + "))";
+
+            regs.SetRegisterToFloat(instr.gpr0, 0, predicate + " ? 1.0 : 0.0", 1, 1);
             break;
         }
         default: {

src/video_core/renderer_opengl/gl_shader_util.h

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <string>
 #include <vector>
 #include <glad/glad.h>
 #include "common/assert.h"
@@ -11,6 +12,27 @@
 
 namespace GLShader {
 
+/**
+ * Utility function to log the source code of a list of shaders.
+ * @param shaders The OpenGL shaders whose source we will print.
+ */
+template <typename... T>
+void LogShaderSource(T... shaders) {
+    auto shader_list = {shaders...};
+
+    for (const auto& shader : shader_list) {
+        if (shader == 0)
+            continue;
+
+        GLint source_length;
+        glGetShaderiv(shader, GL_SHADER_SOURCE_LENGTH, &source_length);
+
+        std::string source(source_length, ' ');
+        glGetShaderSource(shader, source_length, nullptr, &source[0]);
+        NGLOG_INFO(Render_OpenGL, "Shader source {}", source);
+    }
+}
+
 /**
  * Utility function to create and compile an OpenGL GLSL shader
  * @param source String of the GLSL shader program
@@ -55,6 +77,11 @@ GLuint LoadProgram(bool separable_program, T... shaders) {
         }
     }
 
+    if (result == GL_FALSE) {
+        // There was a problem linking the shader, print the source for debugging purposes.
+        LogShaderSource(shaders...);
+    }
+
     ASSERT_MSG(result == GL_TRUE, "Shader not linked");
 
     ((shaders == 0 ? (void)0 : glDetachShader(program_id, shaders)), ...);

src/video_core/textures/decoders.cpp

@@ -55,8 +55,11 @@ u32 BytesPerPixel(TextureFormat format) {
     case TextureFormat::A8R8G8B8:
     case TextureFormat::A2B10G10R10:
         return 4;
+    case TextureFormat::A1B5G5R5:
     case TextureFormat::B5G6R5:
         return 2;
+    case TextureFormat::R8:
+        return 1;
     default:
         UNIMPLEMENTED_MSG("Format not implemented");
         break;
@@ -80,7 +83,9 @@ std::vector<u8> UnswizzleTexture(VAddr address, TextureFormat format, u32 width,
         break;
     case TextureFormat::A8R8G8B8:
     case TextureFormat::A2B10G10R10:
+    case TextureFormat::A1B5G5R5:
     case TextureFormat::B5G6R5:
+    case TextureFormat::R8:
         CopySwizzledData(width, height, bytes_per_pixel, bytes_per_pixel, data,
                          unswizzled_data.data(), true, block_height);
         break;
@@ -103,7 +108,9 @@ std::vector<u8> DecodeTexture(const std::vector<u8>& texture_data, TextureFormat
     case TextureFormat::DXT45:
     case TextureFormat::A8R8G8B8:
     case TextureFormat::A2B10G10R10:
+    case TextureFormat::A1B5G5R5:
     case TextureFormat::B5G6R5:
+    case TextureFormat::R8:
         // TODO(Subv): For the time being just forward the same data without any decoding.
         rgba_data = texture_data;
         break;

src/video_core/textures/texture.h

@@ -14,12 +14,82 @@ namespace Tegra {
 namespace Texture {
 
 enum class TextureFormat : u32 {
-    A8R8G8B8 = 0x8,
-    A2B10G10R10 = 0x9,
+    R32_G32_B32_A32 = 0x01,
+    R32_G32_B32 = 0x02,
+    R16_G16_B16_A16 = 0x03,
+    R32_G32 = 0x04,
+    R32_B24G8 = 0x05,
+    ETC2_RGB = 0x06,
+    X8B8G8R8 = 0x07,
+    A8R8G8B8 = 0x08,
+    A2B10G10R10 = 0x09,
+    ETC2_RGB_PTA = 0x0a,
+    ETC2_RGBA = 0x0b,
+    R16_G16 = 0x0c,
+    G8R24 = 0x0d,
+    G24R8 = 0x0e,
+    R32 = 0x0f,
+    BC6H_SF16 = 0x10,
+    BC6H_UF16 = 0x11,
+    A4B4G4R4 = 0x12,
+    A5B5G5R1 = 0x13,
+    A1B5G5R5 = 0x14,
     B5G6R5 = 0x15,
+    B6G5R5 = 0x16,
+    BC7U = 0x17,
+    G8R8 = 0x18,
+    EAC = 0x19,
+    EACX2 = 0x1a,
+    R16 = 0x1b,
+    Y8_VIDEO = 0x1c,
+    R8 = 0x1d,
+    G4R4 = 0x1e,
+    R1 = 0x1f,
+    E5B9G9R9_SHAREDEXP = 0x20,
+    BF10GF11RF11 = 0x21,
+    G8B8G8R8 = 0x22,
+    B8G8R8G8 = 0x23,
     DXT1 = 0x24,
     DXT23 = 0x25,
     DXT45 = 0x26,
+    DXN1 = 0x27,
+    DXN2 = 0x28,
+    Z24S8 = 0x29,
+    X8Z24 = 0x2a,
+    S8Z24 = 0x2b,
+    X4V4Z24__COV4R4V = 0x2c,
+    X4V4Z24__COV8R8V = 0x2d,
+    V8Z24__COV4R12V = 0x2e,
+    ZF32 = 0x2f,
+    ZF32_X24S8 = 0x30,
+    X8Z24_X20V4S8__COV4R4V = 0x31,
+    X8Z24_X20V4S8__COV8R8V = 0x32,
+    ZF32_X20V4X8__COV4R4V = 0x33,
+    ZF32_X20V4X8__COV8R8V = 0x34,
+    ZF32_X20V4S8__COV4R4V = 0x35,
+    ZF32_X20V4S8__COV8R8V = 0x36,
+    X8Z24_X16V8S8__COV4R12V = 0x37,
+    ZF32_X16V8X8__COV4R12V = 0x38,
+    ZF32_X16V8S8__COV4R12V = 0x39,
+    Z16 = 0x3a,
+    V8Z24__COV8R24V = 0x3b,
+    X8Z24_X16V8S8__COV8R24V = 0x3c,
+    ZF32_X16V8X8__COV8R24V = 0x3d,
+    ZF32_X16V8S8__COV8R24V = 0x3e,
+    ASTC_2D_4X4 = 0x40,
+    ASTC_2D_5X5 = 0x41,
+    ASTC_2D_6X6 = 0x42,
+    ASTC_2D_8X8 = 0x44,
+    ASTC_2D_10X10 = 0x45,
+    ASTC_2D_12X12 = 0x46,
+    ASTC_2D_5X4 = 0x50,
+    ASTC_2D_6X5 = 0x51,
+    ASTC_2D_8X6 = 0x52,
+    ASTC_2D_10X8 = 0x53,
+    ASTC_2D_12X10 = 0x54,
+    ASTC_2D_8X5 = 0x55,
+    ASTC_2D_10X5 = 0x56,
+    ASTC_2D_10X6 = 0x57,
 };
 
 enum class TextureType : u32 {

src/yuzu/debugger/wait_tree.cpp

@@ -98,6 +98,30 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeMutexInfo::GetChildren() cons
     return list;
 }
 
+WaitTreeCallstack::WaitTreeCallstack(const Kernel::Thread& thread) : thread(thread) {}
+
+QString WaitTreeCallstack::GetText() const {
+    return tr("Call stack");
+}
+
+std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeCallstack::GetChildren() const {
+    std::vector<std::unique_ptr<WaitTreeItem>> list;
+
+    constexpr size_t BaseRegister = 29;
+    u64 base_pointer = thread.context.cpu_registers[BaseRegister];
+
+    while (base_pointer != 0) {
+        u64 lr = Memory::Read64(base_pointer + sizeof(u64));
+        if (lr == 0)
+            break;
+        list.push_back(
+            std::make_unique<WaitTreeText>(tr("0x%1").arg(lr - sizeof(u32), 16, 16, QChar('0'))));
+        base_pointer = Memory::Read64(base_pointer);
+    }
+
+    return list;
+}
+
 WaitTreeWaitObject::WaitTreeWaitObject(const Kernel::WaitObject& o) : object(o) {}
 
 bool WaitTreeExpandableItem::IsExpandable() const {
@@ -269,6 +293,8 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeThread::GetChildren() const {
                                                             thread.IsSleepingOnWaitAll()));
     }
 
+    list.push_back(std::make_unique<WaitTreeCallstack>(thread));
+
     return list;
 }
 

src/yuzu/debugger/wait_tree.h

@@ -73,6 +73,17 @@ private:
     Kernel::SharedPtr<Kernel::Thread> owner;
 };
 
+class WaitTreeCallstack : public WaitTreeExpandableItem {
+    Q_OBJECT
+public:
+    explicit WaitTreeCallstack(const Kernel::Thread& thread);
+    QString GetText() const override;
+    std::vector<std::unique_ptr<WaitTreeItem>> GetChildren() const override;
+
+private:
+    const Kernel::Thread& thread;
+};
+
 class WaitTreeWaitObject : public WaitTreeExpandableItem {
     Q_OBJECT
 public:

src/yuzu_cmd/yuzu.cpp

@@ -7,8 +7,19 @@
 #include <string>
 #include <thread>
 
-// This needs to be included before getopt.h because the latter #defines symbols used by it
+#include "common/logging/backend.h"
+#include "common/logging/filter.h"
+#include "common/logging/log.h"
 #include "common/microprofile.h"
+#include "common/scm_rev.h"
+#include "common/scope_exit.h"
+#include "common/string_util.h"
+#include "core/core.h"
+#include "core/gdbstub/gdbstub.h"
+#include "core/loader/loader.h"
+#include "core/settings.h"
+#include "yuzu_cmd/config.h"
+#include "yuzu_cmd/emu_window/emu_window_sdl2.h"
 
 #ifdef _MSC_VER
 #include <getopt.h>
@@ -24,19 +35,6 @@
 #include <shellapi.h>
 #endif
 
-#include "common/logging/backend.h"
-#include "common/logging/filter.h"
-#include "common/logging/log.h"
-#include "common/scm_rev.h"
-#include "common/scope_exit.h"
-#include "common/string_util.h"
-#include "core/core.h"
-#include "core/gdbstub/gdbstub.h"
-#include "core/loader/loader.h"
-#include "core/settings.h"
-#include "yuzu_cmd/config.h"
-#include "yuzu_cmd/emu_window/emu_window_sdl2.h"
-
 #ifdef _WIN32
 extern "C" {
 // tells Nvidia and AMD drivers to use the dedicated GPU by default on laptops with switchable