nvhost_ctrl: Refactor usage of gpu.LockSync()

This seems to only be used to protect a later gpu function call. So we can move the lock into that call instead.

3 files changed, 16 insertions, 35 deletions

diff --git a/src/core/hle/service/nvdrv/devices/nvhost_ctrl.cpp b/src/core/hle/service/nvdrv/devices/nvhost_ctrl.cpp
index 775e76330..8b4867ca7 100644
--- a/src/core/hle/service/nvdrv/devices/nvhost_ctrl.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvhost_ctrl.cpp
@@ -111,7 +111,6 @@ NvResult nvhost_ctrl::IocCtrlEventWait(const std::vector<u8>& input, std::vector
         event.event->GetWritableEvent().Signal();
         return NvResult::Success;
     }
-    auto lock = gpu.LockSync();
     const u32 current_syncpoint_value = event.fence.value;
     const s32 diff = current_syncpoint_value - params.threshold;
     if (diff >= 0) {
@@ -132,23 +131,24 @@ NvResult nvhost_ctrl::IocCtrlEventWait(const std::vector<u8>& input, std::vector
     }
 
     EventState status = events_interface.status[event_id];
-    if (event_id < MaxNvEvents || status == EventState::Free || status == EventState::Registered) {
-        events_interface.SetEventStatus(event_id, EventState::Waiting);
-        events_interface.assigned_syncpt[event_id] = params.syncpt_id;
-        events_interface.assigned_value[event_id] = target_value;
-        if (is_async) {
-            params.value = params.syncpt_id << 4;
-        } else {
-            params.value = ((params.syncpt_id & 0xfff) << 16) | 0x10000000;
-        }
-        params.value |= event_id;
-        event.event->GetWritableEvent().Clear();
-        gpu.RegisterSyncptInterrupt(params.syncpt_id, target_value);
+    const bool bad_parameter = status != EventState::Free && status != EventState::Registered;
+    if (bad_parameter) {
         std::memcpy(output.data(), &params, sizeof(params));
-        return NvResult::Timeout;
+        return NvResult::BadParameter;
     }
+    events_interface.SetEventStatus(event_id, EventState::Waiting);
+    events_interface.assigned_syncpt[event_id] = params.syncpt_id;
+    events_interface.assigned_value[event_id] = target_value;
+    if (is_async) {
+        params.value = params.syncpt_id << 4;
+    } else {
+        params.value = ((params.syncpt_id & 0xfff) << 16) | 0x10000000;
+    }
+    params.value |= event_id;
+    event.event->GetWritableEvent().Clear();
+    gpu.RegisterSyncptInterrupt(params.syncpt_id, target_value);
     std::memcpy(output.data(), &params, sizeof(params));
-    return NvResult::BadParameter;
+    return NvResult::Timeout;
 }
 
 NvResult nvhost_ctrl::IocCtrlEventRegister(const std::vector<u8>& input, std::vector<u8>& output) {
diff --git a/src/video_core/gpu.cpp b/src/video_core/gpu.cpp
index 520675873..ab7c21a49 100644
--- a/src/video_core/gpu.cpp
+++ b/src/video_core/gpu.cpp
@@ -262,6 +262,7 @@ struct GPU::Impl {
     }
 
     void RegisterSyncptInterrupt(u32 syncpoint_id, u32 value) {
+        std::lock_guard lock{sync_mutex};
         auto& interrupt = syncpt_interrupts.at(syncpoint_id);
         bool contains = std::any_of(interrupt.begin(), interrupt.end(),
                                     [value](u32 in_value) { return in_value == value; });
@@ -300,10 +301,6 @@ struct GPU::Impl {
         return nanoseconds_num * gpu_ticks_num + (nanoseconds_rem * gpu_ticks_num) / gpu_ticks_den;
     }
 
-    [[nodiscard]] std::unique_lock<std::mutex> LockSync() {
-        return std::unique_lock{sync_mutex};
-    }
-
     [[nodiscard]] bool IsAsync() const {
         return is_async;
     }
@@ -862,10 +859,6 @@ u64 GPU::GetTicks() const {
     return impl->GetTicks();
 }
 
-std::unique_lock<std::mutex> GPU::LockSync() {
-    return impl->LockSync();
-}
-
 bool GPU::IsAsync() const {
     return impl->IsAsync();
 }
diff --git a/src/video_core/gpu.h b/src/video_core/gpu.h
index 39b304823..05e5c94f3 100644
--- a/src/video_core/gpu.h
+++ b/src/video_core/gpu.h
@@ -5,22 +5,12 @@
 #pragma once
 
 #include <memory>
-#include <mutex>
 
 #include "common/bit_field.h"
 #include "common/common_types.h"
 #include "video_core/cdma_pusher.h"
 #include "video_core/framebuffer_config.h"
 
-using CacheAddr = std::uintptr_t;
-[[nodiscard]] inline CacheAddr ToCacheAddr(const void* host_ptr) {
-    return reinterpret_cast<CacheAddr>(host_ptr);
-}
-
-[[nodiscard]] inline u8* FromCacheAddr(CacheAddr cache_addr) {
-    return reinterpret_cast<u8*>(cache_addr);
-}
-
 namespace Core {
 namespace Frontend {
 class EmuWindow;
@@ -230,8 +220,6 @@ public:
 
     [[nodiscard]] u64 GetTicks() const;
 
-    [[nodiscard]] std::unique_lock<std::mutex> LockSync();
-
     [[nodiscard]] bool IsAsync() const;
 
     [[nodiscard]] bool UseNvdec() const;