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) {
-    system.CoreTiming().ScheduleEvent(10, gpu_interrupt_event, static_cast<u64>(event_index));
+void InterruptManager::GPUInterruptSyncpt(const u32 syncpoint_id, const u32 value) {
+    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) {
-    nvdrv->SignalEvent(event_id);
+void NVDRV::SignalGPUInterruptSyncpt(const u32 syncpoint_id, const u32 value) {
+    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) {
-    if (event_id >= 64) {
-        LOG_ERROR(Service_NVDRV, "Unexpected Event signalled!");
-        return;
+void Module::SignalSyncpt(const u32 syncpoint_id, const u32 value) {
+    for (u32 i = 0; i < MaxNvEvents; i++) {
+        if (events_interface.assigned_syncpt[i] == syncpoint_id &&
+            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);