Implement GPU syncpoints (#980)

* Implement GPU syncpoints

This adds support for GPU syncpoints on the GPU backend & nvservices.

Everything that was implemented here is based on my researches,
hardware testing of the GM20B and reversing of nvservices (8.1.0).

Thanks to @fincs for the informations about some behaviours of the pusher
and for the initial informations about syncpoints.

* syncpoint: address gdkchan's comments

* Add some missing logic to handle SubmitGpfifo correctly

* Handle the NV event API correctly

* evnt => hostEvent

* Finish addressing gdkchan's comments

* nvservices: write the output buffer even when an error is returned

* dma pusher: Implemnet prefetch barrier

lso fix when the commands should be prefetch.

* Partially fix prefetch barrier

* Add a missing syncpoint check in QueryEvent of NvHostSyncPt

* Address Ac_K's comments and fix GetSyncpoint for ChannelResourcePolicy == Channel

* fix SyncptWait & SyncptWaitEx cmds logic

* Address ripinperi's comments

* Address gdkchan's comments

* Move user event management to the control channel

* Fix mm implementation, nvdec works again

* Address ripinperi's comments

* Address gdkchan's comments

* Implement nvhost-ctrl close accurately + make nvservices dispose channels when stopping the emulator

* Fix typo in MultiMediaOperationType

4 files changed, 115 insertions, 4 deletions

diff --git a/Ryujinx.Graphics.Gpu/Engine/MethodFifo.cs b/Ryujinx.Graphics.Gpu/Engine/MethodFifo.cs
new file mode 100644
index 00000000..1c0e72e5
--- /dev/null
+++ b/Ryujinx.Graphics.Gpu/Engine/MethodFifo.cs
@@ -0,0 +1,77 @@
+using Ryujinx.Graphics.Gpu.State;
+using System;
+using System.Threading;
+
+namespace Ryujinx.Graphics.Gpu.Engine
+{
+    partial class Methods
+    {
+        /// <summary>
+        /// Waits for the GPU to be idle.
+        /// </summary>
+        /// <param name="state">Current GPU state</param>
+        /// <param name="argument">Method call argument</param>
+        public void WaitForIdle(GpuState state, int argument)
+        {
+            PerformDeferredDraws();
+
+            _context.Renderer.Pipeline.Barrier();
+        }
+
+        /// <summary>
+        /// Send macro code/data to the MME.
+        /// </summary>
+        /// <param name="state">Current GPU state</param>
+        /// <param name="argument">Method call argument</param>
+        public void SendMacroCodeData(GpuState state, int argument)
+        {
+            int macroUploadAddress = state.Get<int>(MethodOffset.MacroUploadAddress);
+
+            _context.Fifo.SendMacroCodeData(macroUploadAddress++, argument);
+
+            state.Write((int)MethodOffset.MacroUploadAddress, macroUploadAddress);
+        }
+
+        /// <summary>
+        /// Bind a macro index to a position for the MME.
+        /// </summary>
+        /// <param name="state">Current GPU state</param>
+        /// <param name="argument">Method call argument</param>
+        public void BindMacro(GpuState state, int argument)
+        {
+            int macroBindingIndex = state.Get<int>(MethodOffset.MacroBindingIndex);
+
+            _context.Fifo.BindMacro(macroBindingIndex++, argument);
+
+            state.Write((int)MethodOffset.MacroBindingIndex, macroBindingIndex);
+        }
+
+        public void SetMmeShadowRamControl(GpuState state, int argument)
+        {
+            _context.Fifo.SetMmeShadowRamControl((ShadowRamControl)argument);
+        }
+
+        /// <summary>
+        /// Apply a fence operation on a syncpoint.
+        /// </summary>
+        /// <param name="state">Current GPU state</param>
+        /// <param name="argument">Method call argument</param>
+        public void FenceAction(GpuState state, int argument)
+        {
+            uint threshold = state.Get<uint>(MethodOffset.FenceValue);
+
+            FenceActionOperation operation = (FenceActionOperation)(argument & 1);
+
+            uint syncpointId = (uint)(argument >> 8) & 0xFF;
+
+            if (operation == FenceActionOperation.Acquire)
+            {
+                _context.Synchronization.WaitOnSyncpoint(syncpointId, threshold, Timeout.InfiniteTimeSpan);
+            }
+            else if (operation == FenceActionOperation.Increment)
+            {
+                _context.Synchronization.IncrementSyncpoint(syncpointId);
+            }
+        }
+    }
+}
diff --git a/Ryujinx.Graphics.Gpu/Engine/MethodIncrementSyncpoint.cs b/Ryujinx.Graphics.Gpu/Engine/MethodIncrementSyncpoint.cs
new file mode 100644
index 00000000..65742ba7
--- /dev/null
+++ b/Ryujinx.Graphics.Gpu/Engine/MethodIncrementSyncpoint.cs
@@ -0,0 +1,19 @@
+using Ryujinx.Graphics.Gpu.State;
+
+namespace Ryujinx.Graphics.Gpu.Engine
+{
+    partial class Methods
+    {
+        /// <summary>
+        /// Performs an incrementation on a syncpoint.
+        /// </summary>
+        /// <param name="state">Current GPU state</param>
+        /// <param name="argument">Method call argument</param>
+        public void IncrementSyncpoint(GpuState state, int argument)
+        {
+            uint syncpointId = (uint)(argument) & 0xFFFF;
+
+            _context.Synchronization.IncrementSyncpoint(syncpointId);
+        }
+    }
+}
diff --git a/Ryujinx.Graphics.Gpu/Engine/MethodReport.cs b/Ryujinx.Graphics.Gpu/Engine/MethodReport.cs
index 173989c3..0565acdc 100644
--- a/Ryujinx.Graphics.Gpu/Engine/MethodReport.cs
+++ b/Ryujinx.Graphics.Gpu/Engine/MethodReport.cs
@@ -26,16 +26,16 @@ namespace Ryujinx.Graphics.Gpu.Engine
 
             switch (mode)
             {
-                case ReportMode.Semaphore: ReportSemaphore(state);     break;
-                case ReportMode.Counter:   ReportCounter(state, type); break;
+                case ReportMode.Release: ReleaseSemaphore(state);    break;
+                case ReportMode.Counter: ReportCounter(state, type); break;
             }
         }
 
         /// <summary>
-        /// Writes a GPU semaphore value to guest memory.
+        /// Writes (or Releases) a GPU semaphore value to guest memory.
         /// </summary>
         /// <param name="state">Current GPU state</param>
-        private void ReportSemaphore(GpuState state)
+        private void ReleaseSemaphore(GpuState state)
         {
             var rs = state.Get<ReportState>(MethodOffset.ReportState);
 
diff --git a/Ryujinx.Graphics.Gpu/Engine/Methods.cs b/Ryujinx.Graphics.Gpu/Engine/Methods.cs
index b7f4e1d9..bbfbf760 100644
--- a/Ryujinx.Graphics.Gpu/Engine/Methods.cs
+++ b/Ryujinx.Graphics.Gpu/Engine/Methods.cs
@@ -65,6 +65,8 @@ namespace Ryujinx.Graphics.Gpu.Engine
 
             state.RegisterCallback(MethodOffset.Dispatch, Dispatch);
 
+            state.RegisterCallback(MethodOffset.SyncpointAction, IncrementSyncpoint);
+
             state.RegisterCallback(MethodOffset.CopyBuffer,  CopyBuffer);
             state.RegisterCallback(MethodOffset.CopyTexture, CopyTexture);
 
@@ -95,6 +97,19 @@ namespace Ryujinx.Graphics.Gpu.Engine
         }
 
         /// <summary>
+        /// Register callback for Fifo method calls that triggers an action on the GPFIFO.
+        /// </summary>
+        /// <param name="state">GPU state where the triggers will be registered</param>
+        public void RegisterCallbacksForFifo(GpuState state)
+        {
+            state.RegisterCallback(MethodOffset.FenceAction,            FenceAction);
+            state.RegisterCallback(MethodOffset.WaitForIdle,            WaitForIdle);
+            state.RegisterCallback(MethodOffset.SendMacroCodeData,      SendMacroCodeData);
+            state.RegisterCallback(MethodOffset.BindMacro,              BindMacro);
+            state.RegisterCallback(MethodOffset.SetMmeShadowRamControl, SetMmeShadowRamControl);
+        }
+
+        /// <summary>
         /// Updates host state based on the current guest GPU state.
         /// </summary>
         /// <param name="state">Guest GPU state</param>