From 644de99e86856bad3fe24a0324c06f96cee6a401 Mon Sep 17 00:00:00 2001 From: Thog Date: Sun, 19 Apr 2020 03:25:57 +0200 Subject: 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 --- Ryujinx.Graphics.Gpu/Engine/MethodFifo.cs | 77 ++++++++++++++++++++++ .../Engine/MethodIncrementSyncpoint.cs | 19 ++++++ Ryujinx.Graphics.Gpu/Engine/MethodReport.cs | 8 +-- Ryujinx.Graphics.Gpu/Engine/Methods.cs | 15 +++++ 4 files changed, 115 insertions(+), 4 deletions(-) create mode 100644 Ryujinx.Graphics.Gpu/Engine/MethodFifo.cs create mode 100644 Ryujinx.Graphics.Gpu/Engine/MethodIncrementSyncpoint.cs (limited to 'Ryujinx.Graphics.Gpu/Engine') 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 + { + /// + /// Waits for the GPU to be idle. + /// + /// Current GPU state + /// Method call argument + public void WaitForIdle(GpuState state, int argument) + { + PerformDeferredDraws(); + + _context.Renderer.Pipeline.Barrier(); + } + + /// + /// Send macro code/data to the MME. + /// + /// Current GPU state + /// Method call argument + public void SendMacroCodeData(GpuState state, int argument) + { + int macroUploadAddress = state.Get(MethodOffset.MacroUploadAddress); + + _context.Fifo.SendMacroCodeData(macroUploadAddress++, argument); + + state.Write((int)MethodOffset.MacroUploadAddress, macroUploadAddress); + } + + /// + /// Bind a macro index to a position for the MME. + /// + /// Current GPU state + /// Method call argument + public void BindMacro(GpuState state, int argument) + { + int macroBindingIndex = state.Get(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); + } + + /// + /// Apply a fence operation on a syncpoint. + /// + /// Current GPU state + /// Method call argument + public void FenceAction(GpuState state, int argument) + { + uint threshold = state.Get(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 + { + /// + /// Performs an incrementation on a syncpoint. + /// + /// Current GPU state + /// Method call argument + 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; } } /// - /// Writes a GPU semaphore value to guest memory. + /// Writes (or Releases) a GPU semaphore value to guest memory. /// /// Current GPU state - private void ReportSemaphore(GpuState state) + private void ReleaseSemaphore(GpuState state) { var rs = state.Get(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); @@ -94,6 +96,19 @@ namespace Ryujinx.Graphics.Gpu.Engine state.RegisterCallback(MethodOffset.UniformBufferBindFragment, UniformBufferBindFragment); } + /// + /// Register callback for Fifo method calls that triggers an action on the GPFIFO. + /// + /// GPU state where the triggers will be registered + 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); + } + /// /// Updates host state based on the current guest GPU state. /// -- cgit v1.2.3