1 files changed, 162 insertions, 9 deletions

diff --git a/Ryujinx.HLE/HOS/Services/Nv/NvDrvServices/NvHostChannel/NvHostChannelDeviceFile.cs b/Ryujinx.HLE/HOS/Services/Nv/NvDrvServices/NvHostChannel/NvHostChannelDeviceFile.cs
index 212d69e0..573df48c 100644
--- a/Ryujinx.HLE/HOS/Services/Nv/NvDrvServices/NvHostChannel/NvHostChannelDeviceFile.cs
+++ b/Ryujinx.HLE/HOS/Services/Nv/NvDrvServices/NvHostChannel/NvHostChannelDeviceFile.cs
@@ -1,8 +1,9 @@
 using Ryujinx.Common.Logging;
-using Ryujinx.Graphics.Gpu;
 using Ryujinx.Graphics.Gpu.Memory;
+using Ryujinx.HLE.HOS.Services.Nv.Types;
 using Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostAsGpu;
 using Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostChannel.Types;
+using Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostCtrl;
 using Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvMap;
 using System;
 using System.Runtime.CompilerServices;
@@ -12,21 +13,42 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostChannel
 {
     class NvHostChannelDeviceFile : NvDeviceFile
     {
+        private const uint MaxModuleSyncpoint = 16;
+
         private uint _timeout;
         private uint _submitTimeout;
         private uint _timeslice;
 
-        private GpuContext _gpu;
+        private Switch _device;
 
         private ARMeilleure.Memory.MemoryManager _memory;
 
+        public enum ResourcePolicy
+        {
+            Device,
+            Channel
+        }
+
+        protected static uint[] DeviceSyncpoints = new uint[MaxModuleSyncpoint];
+
+        protected uint[] ChannelSyncpoints;
+
+        protected static ResourcePolicy ChannelResourcePolicy = ResourcePolicy.Device;
+
+        private NvFence _channelSyncpoint;
+
         public NvHostChannelDeviceFile(ServiceCtx context) : base(context)
         {
-            _gpu           = context.Device.Gpu;
+            _device        = context.Device;
             _memory        = context.Memory;
             _timeout       = 3000;
             _submitTimeout = 0;
             _timeslice     = 0;
+
+            ChannelSyncpoints = new uint[MaxModuleSyncpoint];
+
+            _channelSyncpoint.Id = _device.System.HostSyncpoint.AllocateSyncpoint(false);
+            _channelSyncpoint.UpdateValue(_device.System.HostSyncpoint);
         }
 
         public override NvInternalResult Ioctl(NvIoctl command, Span<byte> arguments)
@@ -132,9 +154,24 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostChannel
 
         private NvInternalResult GetSyncpoint(ref GetParameterArguments arguments)
         {
-            arguments.Value = 0;
+            if (arguments.Parameter >= MaxModuleSyncpoint)
+            {
+                return NvInternalResult.InvalidInput;
+            }
 
-            Logger.PrintStub(LogClass.ServiceNv);
+            if (ChannelResourcePolicy == ResourcePolicy.Device)
+            {
+                arguments.Value = GetSyncpointDevice(_device.System.HostSyncpoint, arguments.Parameter, false);
+            }
+            else
+            {
+                arguments.Value = GetSyncpointChannel(arguments.Parameter, false);
+            }
+
+            if (arguments.Value == 0)
+            {
+                return NvInternalResult.TryAgain;
+            }
 
             return NvInternalResult.Success;
         }
@@ -293,6 +330,10 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostChannel
 
         private NvInternalResult AllocGpfifoEx(ref AllocGpfifoExArguments arguments)
         {
+            _channelSyncpoint.UpdateValue(_device.System.HostSyncpoint);
+
+            arguments.Fence = _channelSyncpoint;
+
             Logger.PrintStub(LogClass.ServiceNv);
 
             return NvInternalResult.Success;
@@ -300,6 +341,10 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostChannel
 
         private NvInternalResult AllocGpfifoEx2(ref AllocGpfifoExArguments arguments)
         {
+            _channelSyncpoint.UpdateValue(_device.System.HostSyncpoint);
+
+            arguments.Fence = _channelSyncpoint;
+
             Logger.PrintStub(LogClass.ServiceNv);
 
             return NvInternalResult.Success;
@@ -330,17 +375,125 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostChannel
 
         protected NvInternalResult SubmitGpfifo(ref SubmitGpfifoArguments header, Span<ulong> entries)
         {
-            foreach (ulong entry in entries)
+            if (header.Flags.HasFlag(SubmitGpfifoFlags.FenceWait) && header.Flags.HasFlag(SubmitGpfifoFlags.IncrementWithValue))
             {
-                _gpu.DmaPusher.Push(entry);
+                return NvInternalResult.InvalidInput;
             }
 
-            header.Fence.Id    = 0;
-            header.Fence.Value = 0;
+            if (header.Flags.HasFlag(SubmitGpfifoFlags.FenceWait) && !_device.System.HostSyncpoint.IsSyncpointExpired(header.Fence.Id, header.Fence.Value))
+            {
+                _device.Gpu.DmaPusher.PushHostCommandBuffer(CreateWaitCommandBuffer(header.Fence));
+            }
+
+            _device.Gpu.DmaPusher.PushEntries(entries);
+
+            header.Fence.Id = _channelSyncpoint.Id;
+
+            if (header.Flags.HasFlag(SubmitGpfifoFlags.FenceIncrement) || header.Flags.HasFlag(SubmitGpfifoFlags.IncrementWithValue))
+            {
+                uint incrementCount = header.Flags.HasFlag(SubmitGpfifoFlags.FenceIncrement) ? 2u : 0u;
+
+                if (header.Flags.HasFlag(SubmitGpfifoFlags.IncrementWithValue))
+                {
+                    incrementCount += header.Fence.Value;
+                }
+
+                header.Fence.Value = _device.System.HostSyncpoint.IncrementSyncpointMaxExt(header.Fence.Id, (int)incrementCount);
+            }
+            else
+            {
+                header.Fence.Value = _device.System.HostSyncpoint.ReadSyncpointMaxValue(header.Fence.Id);
+            }
+
+            if (header.Flags.HasFlag(SubmitGpfifoFlags.FenceIncrement))
+            {
+                _device.Gpu.DmaPusher.PushHostCommandBuffer(CreateIncrementCommandBuffer(ref header.Fence, header.Flags));
+            }
+
+            header.Flags = SubmitGpfifoFlags.None;
+
+            _device.Gpu.DmaPusher.SignalNewEntries();
 
             return NvInternalResult.Success;
         }
 
+        public uint GetSyncpointChannel(uint index, bool isClientManaged)
+        {
+            if (ChannelSyncpoints[index] != 0)
+            {
+                return ChannelSyncpoints[index];
+            }
+
+            ChannelSyncpoints[index] = _device.System.HostSyncpoint.AllocateSyncpoint(isClientManaged);
+
+            return ChannelSyncpoints[index];
+        }
+
+        public static uint GetSyncpointDevice(NvHostSyncpt syncpointManager, uint index, bool isClientManaged)
+        {
+            if (DeviceSyncpoints[index] != 0)
+            {
+                return DeviceSyncpoints[index];
+            }
+
+            DeviceSyncpoints[index] = syncpointManager.AllocateSyncpoint(isClientManaged);
+
+            return DeviceSyncpoints[index];
+        }
+
+        private static int[] CreateWaitCommandBuffer(NvFence fence)
+        {
+            int[] commandBuffer = new int[4];
+
+            // SyncpointValue = fence.Value;
+            commandBuffer[0] = 0x2001001C;
+            commandBuffer[1] = (int)fence.Value;
+
+            // SyncpointAction(fence.id, increment: false, switch_en: true);
+            commandBuffer[2] = 0x2001001D;
+            commandBuffer[3] = (((int)fence.Id << 8) | (0 << 0) | (1 << 4));
+
+            return commandBuffer;
+        }
+
+        private int[] CreateIncrementCommandBuffer(ref NvFence fence, SubmitGpfifoFlags flags)
+        {
+            bool hasWfi = !flags.HasFlag(SubmitGpfifoFlags.SuppressWfi);
+
+            int[] commandBuffer;
+
+            int offset = 0;
+
+            if (hasWfi)
+            {
+                commandBuffer = new int[8];
+
+                // WaitForInterrupt(handle)
+                commandBuffer[offset++] = 0x2001001E;
+                commandBuffer[offset++] = 0x0;
+            }
+            else
+            {
+                commandBuffer = new int[6];
+            }
+
+            // SyncpointValue = 0x0;
+            commandBuffer[offset++] = 0x2001001C;
+            commandBuffer[offset++] = 0x0;
+
+            // Increment the syncpoint 2 times. (mitigate a hardware bug)
+
+            // SyncpointAction(fence.id, increment: true, switch_en: false);
+            commandBuffer[offset++] = 0x2001001D;
+            commandBuffer[offset++] = (((int)fence.Id << 8) | (1 << 0) | (0 << 4));
+
+            // SyncpointAction(fence.id, increment: true, switch_en: false);
+            commandBuffer[offset++] = 0x2001001D;
+            commandBuffer[offset++] = (((int)fence.Id << 8) | (1 << 0) | (0 << 4));
+
+            return commandBuffer;
+        }
+
         public override void Close() { }
     }
 }