GPU: Correct Interrupts to interrupt on syncpt/value instead of event, mirroring hardware

src/core/hardware_interrupt_manager.cpp

@@ -8,14 +8,17 @@ namespace Core::Hardware {
 
 InterruptManager::InterruptManager(Core::System& system_in) : system(system_in) {
     gpu_interrupt_event =
-        system.CoreTiming().RegisterEvent("GPUInterrupt", [this](u64 event_index, s64) {
+        system.CoreTiming().RegisterEvent("GPUInterrupt", [this](u64 message, s64) {
             auto nvdrv = system.ServiceManager().GetService<Service::Nvidia::NVDRV>("nvdrv");
-            nvdrv->SignalGPUInterrupt(static_cast<u32>(event_index));
+            const u32 syncpt = static_cast<u32>(message >> 32);
+            const u32 value = static_cast<u32>(message & 0x00000000FFFFFFFFULL);
+            nvdrv->SignalGPUInterruptSyncpt(syncpt, value);
         });
 }
 
-void InterruptManager::InterruptGPU(const u32 event_index) {
+void InterruptManager::GPUInterruptSyncpt(const u32 syncpoint_id, const u32 value) {
-    system.CoreTiming().ScheduleEvent(10, gpu_interrupt_event, static_cast<u64>(event_index));
+    const u64 msg = (static_cast<u64>(syncpoint_id) << 32ULL) | value;
+    system.CoreTiming().ScheduleEvent(10, gpu_interrupt_event, msg);
 }
 
 } // namespace Core::Hardware

src/core/hardware_interrupt_manager.h

@@ -14,7 +14,7 @@ public:
     InterruptManager(Core::System& system);
     ~InterruptManager() = default;
 
-    void InterruptGPU(const u32 event_index);
+    void GPUInterruptSyncpt(const u32 syncpoint_id, const u32 value);
 
 private:
     Core::System& system;

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

@@ -109,7 +109,7 @@ u32 nvhost_ctrl::IocCtrlEventWait(const std::vector<u8>& input, std::vector<u8>&
         }
         params.value |= event_id;
         events_interface.events[event_id].writable->Clear();
-        gpu.RegisterEvent(event_id, params.syncpt_id, params.threshold);
+        gpu.RegisterSyncptInterrupt(params.syncpt_id, params.threshold);
         std::memcpy(output.data(), &params, sizeof(params));
         gpu.Guard(false);
         return NvResult::Timeout;
@@ -159,9 +159,6 @@ u32 nvhost_ctrl::IocCtrlEventSignal(const std::vector<u8>& input, std::vector<u8
         return NvResult::BadParameter;
     }
     if (events_interface.status[event_id] == EventState::Waiting) {
-        auto& gpu = system.GPU();
-        gpu.CancelEvent(event_id, events_interface.assigned_syncpt[event_id],
-                        events_interface.assigned_value[event_id]);
         events_interface.LiberateEvent(event_id);
     }
     return NvResult::Success;

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

@@ -15,8 +15,8 @@
 
 namespace Service::Nvidia {
 
-void NVDRV::SignalGPUInterrupt(const u32 event_id) {
+void NVDRV::SignalGPUInterruptSyncpt(const u32 syncpoint_id, const u32 value) {
-    nvdrv->SignalEvent(event_id);
+    nvdrv->SignalSyncpt(syncpoint_id, value);
 }
 
 void NVDRV::Open(Kernel::HLERequestContext& ctx) {

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

@@ -19,7 +19,7 @@ public:
     NVDRV(std::shared_ptr<Module> nvdrv, const char* name);
     ~NVDRV() override;
 
-    void SignalGPUInterrupt(const u32 event_id);
+    void SignalGPUInterruptSyncpt(const u32 syncpoint_id, const u32 value);
 
 private:
     void Open(Kernel::HLERequestContext& ctx);

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

@@ -89,13 +89,14 @@ ResultCode Module::Close(u32 fd) {
     return RESULT_SUCCESS;
 }
 
-void Module::SignalEvent(const u32 event_id) {
+void Module::SignalSyncpt(const u32 syncpoint_id, const u32 value) {
-    if (event_id >= 64) {
+    for (u32 i = 0; i < MaxNvEvents; i++) {
-        LOG_ERROR(Service_NVDRV, "Unexpected Event signalled!");
+        if (events_interface.assigned_syncpt[i] == syncpoint_id &&
-        return;
+            events_interface.assigned_value[i] == value) {
+            events_interface.LiberateEvent(i);
+            events_interface.events[i].writable->Signal();
+        }
     }
-    events_interface.LiberateEvent(event_id);
-    events_interface.events[event_id].writable->Signal();
 }
 
 Kernel::SharedPtr<Kernel::ReadableEvent> Module::GetEvent(const u32 event_id) {

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

@@ -73,6 +73,8 @@ struct EventsInterface {
     void LiberateEvent(const u32 event_id) {
         status[event_id] = registered[event_id] ? EventState::Registered : EventState::Free;
         events_mask &= ~(1 << event_id);
+        assigned_syncpt[event_id] = 0xFFFFFFFF;
+        assigned_value[event_id] = 0;
     }
 };
 
@@ -97,7 +99,7 @@ public:
     /// Closes a device file descriptor and returns operation success.
     ResultCode Close(u32 fd);
 
-    void SignalEvent(const u32 event_id);
+    void SignalSyncpt(const u32 syncpoint_id, const u32 value);
 
     Kernel::SharedPtr<Kernel::ReadableEvent> GetEvent(const u32 event_id);
 

src/video_core/gpu.cpp

@@ -70,13 +70,13 @@ const DmaPusher& GPU::DmaPusher() const {
 void GPU::IncrementSyncPoint(const u32 syncpoint_id) {
     syncpoints[syncpoint_id]++;
     sync_mutex.lock();
-    if (!events[syncpoint_id].empty()) {
+    if (!syncpt_interrupts[syncpoint_id].empty()) {
         u32 value = syncpoints[syncpoint_id].load();
-        auto it = events[syncpoint_id].begin();
+        auto it = syncpt_interrupts[syncpoint_id].begin();
-        while (it != events[syncpoint_id].end()) {
+        while (it != syncpt_interrupts[syncpoint_id].end()) {
-            if (value >= it->value) {
+            if (value >= *it) {
-                TriggerCpuInterrupt(it->event_id);
+                TriggerCpuInterrupt(syncpoint_id, *it);
-                it = events[syncpoint_id].erase(it);
+                it = syncpt_interrupts[syncpoint_id].erase(it);
                 continue;
             }
             it++;
@@ -89,19 +89,19 @@ u32 GPU::GetSyncpointValue(const u32 syncpoint_id) const {
     return syncpoints[syncpoint_id].load();
 }
 
-void GPU::RegisterEvent(const u32 event_id, const u32 syncpoint_id, const u32 value) {
+void GPU::RegisterSyncptInterrupt(const u32 syncpoint_id, const u32 value) {
-    for (auto& ev : events[syncpoint_id]) {
+    for (u32 in_value : syncpt_interrupts[syncpoint_id]) {
-        if (ev.event_id == event_id && ev.value == value)
+        if (in_value == value)
             return;
     }
-    events[syncpoint_id].emplace_back(event_id, value);
+    syncpt_interrupts[syncpoint_id].emplace_back(value);
 }
 
-void GPU::CancelEvent(const u32 event_id, const u32 syncpoint_id, const u32 value) {
+void GPU::CancelSyncptInterrupt(const u32 syncpoint_id, const u32 value) {
-    auto it = events[syncpoint_id].begin();
+    auto it = syncpt_interrupts[syncpoint_id].begin();
-    while (it != events[syncpoint_id].end()) {
+    while (it != syncpt_interrupts[syncpoint_id].end()) {
-        if (value == it->value) {
+        if (value == *it) {
-            it = events[syncpoint_id].erase(it);
+            it = syncpt_interrupts[syncpoint_id].erase(it);
             return;
         }
         it++;

src/video_core/gpu.h

@@ -172,9 +172,9 @@ public:
 
     u32 GetSyncpointValue(const u32 syncpoint_id) const;
 
-    void RegisterEvent(const u32 event_id, const u32 syncpoint_id, const u32 value);
+    void RegisterSyncptInterrupt(const u32 syncpoint_id, const u32 value);
 
-    void CancelEvent(const u32 event_id, const u32 syncpoint_id, const u32 value);
+    void CancelSyncptInterrupt(const u32 syncpoint_id, const u32 value);
 
     void Guard(bool guard_set) {
         if (guard_set) {
@@ -253,7 +253,7 @@ public:
     virtual void FlushAndInvalidateRegion(CacheAddr addr, u64 size) = 0;
 
 protected:
-    virtual void TriggerCpuInterrupt(const u32 event_id) const = 0;
+    virtual void TriggerCpuInterrupt(const u32 syncpoint_id, const u32 value) const = 0;
 
 private:
     void ProcessBindMethod(const MethodCall& method_call);
@@ -293,13 +293,7 @@ private:
 
     std::array<std::atomic<u32>, Service::Nvidia::MaxSyncPoints> syncpoints{};
 
-    struct Event {
+    std::array<std::list<u32>, Service::Nvidia::MaxSyncPoints> syncpt_interrupts;
-        Event(const u32 event_id, const u32 value) : event_id(event_id), value(value) {}
-        u32 event_id;
-        u32 value;
-    };
-
-    std::array<std::list<Event>, Service::Nvidia::MaxSyncPoints> events;
 
     std::mutex sync_mutex;
 

src/video_core/gpu_asynch.cpp

@@ -40,9 +40,9 @@ void GPUAsynch::FlushAndInvalidateRegion(CacheAddr addr, u64 size) {
     gpu_thread.FlushAndInvalidateRegion(addr, size);
 }
 
-void GPUAsynch::TriggerCpuInterrupt(const u32 event_id) const {
+void GPUAsynch::TriggerCpuInterrupt(const u32 syncpoint_id, const u32 value) const {
     auto& interrupt_manager = system.InterruptManager();
-    interrupt_manager.InterruptGPU(event_id);
+    interrupt_manager.GPUInterruptSyncpt(syncpoint_id, value);
 }
 
 } // namespace VideoCommon

src/video_core/gpu_asynch.h

@@ -28,7 +28,7 @@ public:
     void FlushAndInvalidateRegion(CacheAddr addr, u64 size) override;
 
 protected:
-    void TriggerCpuInterrupt(const u32 event_id) const override;
+    void TriggerCpuInterrupt(const u32 syncpoint_id, const u32 value) const override;
 
 private:
     GPUThread::ThreadManager gpu_thread;

src/video_core/gpu_synch.h

@@ -27,7 +27,7 @@ public:
     void FlushAndInvalidateRegion(CacheAddr addr, u64 size) override;
 
 protected:
-    void TriggerCpuInterrupt(const u32 event_id) const override {}
+    void TriggerCpuInterrupt(const u32 syncpoint_id, const u32 value) const override {}
 };
 
 } // namespace VideoCommon