Move solution and projects to src

src/Ryujinx.HLE/HOS/Services/Nv/NvDrvServices/NvHostCtrl/NvHostCtrlDeviceFile.cs

@@ -0,0 +1,540 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Graphics.Gpu.Synchronization;
+using Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostCtrl.Types;
+using Ryujinx.HLE.HOS.Services.Nv.Types;
+using Ryujinx.HLE.HOS.Services.Settings;
+using Ryujinx.Memory;
+using System;
+using System.Text;
+using System.Threading;
+
+namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostCtrl
+{
+    internal class NvHostCtrlDeviceFile : NvDeviceFile
+    {
+        public const int EventsCount = 64;
+
+        private bool          _isProductionMode;
+        private Switch        _device;
+        private NvHostEvent[] _events;
+
+        public NvHostCtrlDeviceFile(ServiceCtx context, IVirtualMemoryManager memory, ulong owner) : base(context, owner)
+        {
+            if (NxSettings.Settings.TryGetValue("nv!rmos_set_production_mode", out object productionModeSetting))
+            {
+                _isProductionMode = ((string)productionModeSetting) != "0"; // Default value is ""
+            }
+            else
+            {
+                _isProductionMode = true;
+            }
+
+            _device = context.Device;
+
+            _events = new NvHostEvent[EventsCount];
+        }
+
+        public override NvInternalResult Ioctl(NvIoctl command, Span<byte> arguments)
+        {
+            NvInternalResult result = NvInternalResult.NotImplemented;
+
+            if (command.Type == NvIoctl.NvHostCustomMagic)
+            {
+                switch (command.Number)
+                {
+                    case 0x14:
+                        result = CallIoctlMethod<NvFence>(SyncptRead, arguments);
+                        break;
+                    case 0x15:
+                        result = CallIoctlMethod<uint>(SyncptIncr, arguments);
+                        break;
+                    case 0x16:
+                        result = CallIoctlMethod<SyncptWaitArguments>(SyncptWait, arguments);
+                        break;
+                    case 0x19:
+                        result = CallIoctlMethod<SyncptWaitExArguments>(SyncptWaitEx, arguments);
+                        break;
+                    case 0x1a:
+                        result = CallIoctlMethod<NvFence>(SyncptReadMax, arguments);
+                        break;
+                    case 0x1b:
+                        // As Marshal cannot handle unaligned arrays, we do everything by hand here.
+                        GetConfigurationArguments configArgument = GetConfigurationArguments.FromSpan(arguments);
+                        result = GetConfig(configArgument);
+
+                        if (result == NvInternalResult.Success)
+                        {
+                            configArgument.CopyTo(arguments);
+                        }
+                        break;
+                    case 0x1c:
+                        result = CallIoctlMethod<uint>(EventSignal, arguments);
+                        break;
+                    case 0x1d:
+                        result = CallIoctlMethod<EventWaitArguments>(EventWait, arguments);
+                        break;
+                    case 0x1e:
+                        result = CallIoctlMethod<EventWaitArguments>(EventWaitAsync, arguments);
+                        break;
+                    case 0x1f:
+                        result = CallIoctlMethod<uint>(EventRegister, arguments);
+                        break;
+                    case 0x20:
+                        result = CallIoctlMethod<uint>(EventUnregister, arguments);
+                        break;
+                    case 0x21:
+                        result = CallIoctlMethod<ulong>(EventKill, arguments);
+                        break;
+                }
+            }
+
+            return result;
+        }
+
+        private int QueryEvent(uint eventId)
+        {
+            lock (_events)
+            {
+                uint eventSlot;
+                uint syncpointId;
+
+                if ((eventId >> 28) == 1)
+                {
+                    eventSlot = eventId & 0xFFFF;
+                    syncpointId = (eventId >> 16) & 0xFFF;
+                }
+                else
+                {
+                    eventSlot = eventId & 0xFF;
+                    syncpointId = eventId >> 4;
+                }
+
+                if (eventSlot >= EventsCount || _events[eventSlot] == null || _events[eventSlot].Fence.Id != syncpointId)
+                {
+                    return 0;
+                }
+
+                return _events[eventSlot].EventHandle;
+            }
+        }
+
+        public override NvInternalResult QueryEvent(out int eventHandle, uint eventId)
+        {
+            eventHandle = QueryEvent(eventId);
+
+            return eventHandle != 0 ? NvInternalResult.Success : NvInternalResult.InvalidInput;
+        }
+
+        private NvInternalResult SyncptRead(ref NvFence arguments)
+        {
+            return SyncptReadMinOrMax(ref arguments, max: false);
+        }
+
+        private NvInternalResult SyncptIncr(ref uint id)
+        {
+            if (id >= SynchronizationManager.MaxHardwareSyncpoints)
+            {
+                return NvInternalResult.InvalidInput;
+            }
+
+            _device.System.HostSyncpoint.Increment(id);
+
+            return NvInternalResult.Success;
+        }
+
+        private NvInternalResult SyncptWait(ref SyncptWaitArguments arguments)
+        {
+            uint dummyValue = 0;
+
+            return EventWait(ref arguments.Fence, ref dummyValue, arguments.Timeout, isWaitEventAsyncCmd: false, isWaitEventCmd: false);
+        }
+
+        private NvInternalResult SyncptWaitEx(ref SyncptWaitExArguments arguments)
+        {
+            return EventWait(ref arguments.Input.Fence, ref arguments.Value, arguments.Input.Timeout, isWaitEventAsyncCmd: false, isWaitEventCmd: false);
+        }
+
+        private NvInternalResult SyncptReadMax(ref NvFence arguments)
+        {
+            return SyncptReadMinOrMax(ref arguments, max: true);
+        }
+
+        private NvInternalResult GetConfig(GetConfigurationArguments arguments)
+        {
+            if (!_isProductionMode && NxSettings.Settings.TryGetValue($"{arguments.Domain}!{arguments.Parameter}".ToLower(), out object nvSetting))
+            {
+                byte[] settingBuffer = new byte[0x101];
+
+                if (nvSetting is string stringValue)
+                {
+                    if (stringValue.Length > 0x100)
+                    {
+                        Logger.Error?.Print(LogClass.ServiceNv, $"{arguments.Domain}!{arguments.Parameter} String value size is too big!");
+                    }
+                    else
+                    {
+                        settingBuffer = Encoding.ASCII.GetBytes(stringValue + "\0");
+                    }
+                }
+                else if (nvSetting is int intValue)
+                {
+                    settingBuffer = BitConverter.GetBytes(intValue);
+                }
+                else if (nvSetting is bool boolValue)
+                {
+                    settingBuffer[0] = boolValue ? (byte)1 : (byte)0;
+                }
+                else
+                {
+                    throw new NotImplementedException(nvSetting.GetType().Name);
+                }
+
+                Logger.Debug?.Print(LogClass.ServiceNv, $"Got setting {arguments.Domain}!{arguments.Parameter}");
+
+                arguments.Configuration = settingBuffer;
+
+                return NvInternalResult.Success;
+            }
+
+            // NOTE: This actually return NotAvailableInProduction but this is directly translated as a InvalidInput before returning the ioctl.
+            //return NvInternalResult.NotAvailableInProduction;
+            return NvInternalResult.InvalidInput;
+        }
+
+        private NvInternalResult EventWait(ref EventWaitArguments arguments)
+        {
+            return EventWait(ref arguments.Fence, ref arguments.Value, arguments.Timeout, isWaitEventAsyncCmd: false, isWaitEventCmd: true);
+        }
+
+        private NvInternalResult EventWaitAsync(ref EventWaitArguments arguments)
+        {
+            return EventWait(ref arguments.Fence, ref arguments.Value, arguments.Timeout, isWaitEventAsyncCmd: true, isWaitEventCmd: false);
+        }
+
+        private NvInternalResult EventRegister(ref uint userEventId)
+        {
+            lock (_events)
+            {
+                NvInternalResult result = EventUnregister(ref userEventId);
+
+                if (result == NvInternalResult.Success)
+                {
+                    _events[userEventId] = new NvHostEvent(_device.System.HostSyncpoint, userEventId, _device.System);
+                }
+
+                return result;
+            }
+
+        }
+
+        private NvInternalResult EventUnregister(ref uint userEventId)
+        {
+            lock (_events)
+            {
+                if (userEventId >= EventsCount)
+                {
+                    return NvInternalResult.InvalidInput;
+                }
+
+                NvHostEvent hostEvent = _events[userEventId];
+
+                if (hostEvent == null)
+                {
+                    return NvInternalResult.Success;
+                }
+
+                if (hostEvent.State == NvHostEventState.Available ||
+                    hostEvent.State == NvHostEventState.Cancelled ||
+                    hostEvent.State == NvHostEventState.Signaled)
+                {
+                    _events[userEventId].CloseEvent(Context);
+                    _events[userEventId] = null;
+
+                    return NvInternalResult.Success;
+                }
+
+                return NvInternalResult.Busy;
+            }
+        }
+
+        private NvInternalResult EventKill(ref ulong eventMask)
+        {
+            lock (_events)
+            {
+                NvInternalResult result = NvInternalResult.Success;
+
+                for (uint eventId = 0; eventId < EventsCount; eventId++)
+                {
+                    if ((eventMask & (1UL << (int)eventId)) != 0)
+                    {
+                        NvInternalResult tmp = EventUnregister(ref eventId);
+
+                        if (tmp != NvInternalResult.Success)
+                        {
+                            result = tmp;
+                        }
+                    }
+                }
+
+                return result;
+            }
+        }
+
+        private NvInternalResult EventSignal(ref uint userEventId)
+        {
+            uint eventId = userEventId & ushort.MaxValue;
+
+            if (eventId >= EventsCount)
+            {
+                return NvInternalResult.InvalidInput;
+            }
+
+            lock (_events)
+            {
+                NvHostEvent hostEvent = _events[eventId];
+
+                if (hostEvent == null)
+                {
+                    return NvInternalResult.InvalidInput;
+                }
+
+                hostEvent.Cancel(_device.Gpu);
+
+                _device.System.HostSyncpoint.UpdateMin(hostEvent.Fence.Id);
+
+                return NvInternalResult.Success;
+            }
+        }
+
+        private NvInternalResult SyncptReadMinOrMax(ref NvFence arguments, bool max)
+        {
+            if (arguments.Id >= SynchronizationManager.MaxHardwareSyncpoints)
+            {
+                return NvInternalResult.InvalidInput;
+            }
+
+            if (max)
+            {
+                arguments.Value = _device.System.HostSyncpoint.ReadSyncpointMaxValue(arguments.Id);
+            }
+            else
+            {
+                arguments.Value = _device.System.HostSyncpoint.ReadSyncpointValue(arguments.Id);
+            }
+
+            return NvInternalResult.Success;
+        }
+
+        private NvInternalResult EventWait(ref NvFence fence, ref uint value, int timeout, bool isWaitEventAsyncCmd, bool isWaitEventCmd)
+        {
+            if (fence.Id >= SynchronizationManager.MaxHardwareSyncpoints)
+            {
+                return NvInternalResult.InvalidInput;
+            }
+
+            // First try to check if the syncpoint is already expired on the CPU side
+            if (_device.System.HostSyncpoint.IsSyncpointExpired(fence.Id, fence.Value))
+            {
+                value = _device.System.HostSyncpoint.ReadSyncpointMinValue(fence.Id);
+
+                return NvInternalResult.Success;
+            }
+
+            // Try to invalidate the CPU cache and check for expiration again.
+            uint newCachedSyncpointValue = _device.System.HostSyncpoint.UpdateMin(fence.Id);
+
+            // Has the fence already expired?
+            if (_device.System.HostSyncpoint.IsSyncpointExpired(fence.Id, fence.Value))
+            {
+                value = newCachedSyncpointValue;
+
+                return NvInternalResult.Success;
+            }
+
+            // If the timeout is 0, directly return.
+            if (timeout == 0)
+            {
+                return NvInternalResult.TryAgain;
+            }
+
+            // The syncpoint value isn't at the fence yet, we need to wait.
+
+            if (!isWaitEventAsyncCmd)
+            {
+                value = 0;
+            }
+
+            NvHostEvent hostEvent;
+
+            NvInternalResult result;
+
+            uint eventIndex;
+
+            lock (_events)
+            {
+                if (isWaitEventAsyncCmd)
+                {
+                    eventIndex = value;
+
+                    if (eventIndex >= EventsCount)
+                    {
+                        return NvInternalResult.InvalidInput;
+                    }
+
+                    hostEvent = _events[eventIndex];
+                }
+                else
+                {
+                    hostEvent = GetFreeEventLocked(fence.Id, out eventIndex);
+                }
+
+                if (hostEvent != null)
+                {
+                    lock (hostEvent.Lock)
+                    {
+                        if (hostEvent.State == NvHostEventState.Available ||
+                            hostEvent.State == NvHostEventState.Signaled ||
+                            hostEvent.State == NvHostEventState.Cancelled)
+                        {
+                            bool timedOut = hostEvent.Wait(_device.Gpu, fence);
+
+                            if (timedOut)
+                            {
+                                if (isWaitEventCmd)
+                                {
+                                    value = ((fence.Id & 0xfff) << 16) | 0x10000000;
+                                }
+                                else
+                                {
+                                    value = fence.Id << 4;
+                                }
+
+                                value |= eventIndex;
+
+                                result = NvInternalResult.TryAgain;
+                            }
+                            else
+                            {
+                                value = fence.Value;
+
+                                return NvInternalResult.Success;
+                            }
+                        }
+                        else
+                        {
+                            Logger.Error?.Print(LogClass.ServiceNv, $"Invalid Event at index {eventIndex} (isWaitEventAsyncCmd: {isWaitEventAsyncCmd}, isWaitEventCmd: {isWaitEventCmd})");
+
+                            if (hostEvent != null)
+                            {
+                                Logger.Error?.Print(LogClass.ServiceNv, hostEvent.DumpState(_device.Gpu));
+                            }
+
+                            result = NvInternalResult.InvalidInput;
+                        }
+                    }
+                }
+                else
+                {
+                    Logger.Error?.Print(LogClass.ServiceNv, $"Invalid Event at index {eventIndex} (isWaitEventAsyncCmd: {isWaitEventAsyncCmd}, isWaitEventCmd: {isWaitEventCmd})");
+
+                    result = NvInternalResult.InvalidInput;
+                }
+            }
+
+            return result;
+        }
+
+        private NvHostEvent GetFreeEventLocked(uint id, out uint eventIndex)
+        {
+            eventIndex = EventsCount;
+
+            uint nullIndex = EventsCount;
+
+            for (uint index = 0; index < EventsCount; index++)
+            {
+                NvHostEvent Event = _events[index];
+
+                if (Event != null)
+                {
+                    if (Event.State == NvHostEventState.Available ||
+                        Event.State == NvHostEventState.Signaled ||
+                        Event.State == NvHostEventState.Cancelled)
+                    {
+                        eventIndex = index;
+
+                        if (Event.Fence.Id == id)
+                        {
+                            return Event;
+                        }
+                    }
+                }
+                else if (nullIndex == EventsCount)
+                {
+                    nullIndex = index;
+                }
+            }
+
+            if (nullIndex < EventsCount)
+            {
+                eventIndex = nullIndex;
+
+                EventRegister(ref eventIndex);
+
+                return _events[nullIndex];
+            }
+
+            if (eventIndex < EventsCount)
+            {
+                return _events[eventIndex];
+            }
+
+            return null;
+        }
+
+        public override void Close()
+        {
+            Logger.Warning?.Print(LogClass.ServiceNv, "Closing channel");
+
+            lock (_events)
+            {
+                // If the device file need to be closed, cancel all user events and dispose events.
+                for (int i = 0; i < _events.Length; i++)
+                {
+                    NvHostEvent evnt = _events[i];
+
+                    if (evnt != null)
+                    {
+                        lock (evnt.Lock)
+                        {
+                            if (evnt.State == NvHostEventState.Waiting)
+                            {
+                                evnt.State = NvHostEventState.Cancelling;
+
+                                evnt.Cancel(_device.Gpu);
+                            }
+                            else if (evnt.State == NvHostEventState.Signaling)
+                            {
+                                // Wait at max 9ms if the guest app is trying to signal the event while closing it..
+                                int retryCount = 0;
+                                do
+                                {
+                                    if (retryCount++ > 9)
+                                    {
+                                        break;
+                                    }
+
+                                    // TODO: This should be handled by the kernel (reschedule the current thread ect), waiting for Kernel decoupling work.
+                                    Thread.Sleep(1);
+                                } while (evnt.State != NvHostEventState.Signaled);
+                            }
+
+                            evnt.CloseEvent(Context);
+
+                            _events[i] = null;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Nv/NvDrvServices/NvHostCtrl/Types/EventWaitArguments.cs

@@ -0,0 +1,13 @@
+using Ryujinx.HLE.HOS.Services.Nv.Types;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostCtrl.Types
+{
+    [StructLayout(LayoutKind.Sequential)]
+    struct EventWaitArguments
+    {
+        public NvFence Fence;
+        public int     Timeout;
+        public uint    Value;
+    }
+}

src/Ryujinx.HLE/HOS/Services/Nv/NvDrvServices/NvHostCtrl/Types/GetConfigurationArguments.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Text;
+
+namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostCtrl.Types
+{
+    class GetConfigurationArguments
+    {
+        public string Domain;
+        public string Parameter;
+        public byte[] Configuration;
+
+        public static GetConfigurationArguments FromSpan(Span<byte> span)
+        {
+            string domain    = Encoding.ASCII.GetString(span.Slice(0, 0x41));
+            string parameter = Encoding.ASCII.GetString(span.Slice(0x41, 0x41));
+
+            GetConfigurationArguments result = new GetConfigurationArguments
+            {
+                Domain        = domain.Substring(0, domain.IndexOf('\0')),
+                Parameter     = parameter.Substring(0, parameter.IndexOf('\0')),
+                Configuration = span.Slice(0x82, 0x101).ToArray()
+            };
+
+            return result;
+        }
+
+        public void CopyTo(Span<byte> span)
+        {
+            Encoding.ASCII.GetBytes(Domain + '\0').CopyTo(span.Slice(0, 0x41));
+            Encoding.ASCII.GetBytes(Parameter + '\0').CopyTo(span.Slice(0x41, 0x41));
+            Configuration.CopyTo(span.Slice(0x82, 0x101));
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Nv/NvDrvServices/NvHostCtrl/Types/NvHostEvent.cs

@@ -0,0 +1,185 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Graphics.Gpu;
+using Ryujinx.Graphics.Gpu.Synchronization;
+using Ryujinx.HLE.HOS.Kernel;
+using Ryujinx.HLE.HOS.Kernel.Threading;
+using Ryujinx.HLE.HOS.Services.Nv.Types;
+using Ryujinx.Horizon.Common;
+using System;
+using System.Threading;
+
+namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostCtrl
+{
+    class NvHostEvent
+    {
+        public NvFence          Fence;
+        public NvHostEventState State;
+        public KEvent           Event;
+        public int              EventHandle;
+
+        private uint                  _eventId;
+        private NvHostSyncpt          _syncpointManager;
+        private SyncpointWaiterHandle _waiterInformation;
+
+        private NvFence _previousFailingFence;
+        private uint    _failingCount;
+
+        public readonly object Lock = new object();
+
+        /// <summary>
+        /// Max failing count until waiting on CPU.
+        /// FIXME: This seems enough for most of the cases, reduce if needed.
+        /// </summary>
+        private const uint FailingCountMax = 2;
+
+        public NvHostEvent(NvHostSyncpt syncpointManager, uint eventId, Horizon system)
+        {
+            Fence.Id = 0;
+
+            State = NvHostEventState.Available;
+
+            Event = new KEvent(system.KernelContext);
+
+            if (KernelStatic.GetCurrentProcess().HandleTable.GenerateHandle(Event.ReadableEvent, out EventHandle) != Result.Success)
+            {
+                throw new InvalidOperationException("Out of handles!");
+            }
+
+            _eventId = eventId;
+
+            _syncpointManager = syncpointManager;
+
+            ResetFailingState();
+        }
+
+        private void ResetFailingState()
+        {
+            _previousFailingFence.Id    = NvFence.InvalidSyncPointId;
+            _previousFailingFence.Value = 0;
+            _failingCount               = 0;
+        }
+
+        private void Signal()
+        {
+            lock (Lock)
+            {
+                NvHostEventState oldState = State;
+
+                State = NvHostEventState.Signaling;
+
+                if (oldState == NvHostEventState.Waiting)
+                {
+                    Event.WritableEvent.Signal();
+                }
+
+                State = NvHostEventState.Signaled;
+            }
+        }
+
+        private void GpuSignaled(SyncpointWaiterHandle waiterInformation)
+        {
+            lock (Lock)
+            {
+                // If the signal does not match our current waiter,
+                // then it is from a past fence and we should just ignore it.
+                if (waiterInformation != null && waiterInformation != _waiterInformation)
+                {
+                    return;
+                }
+
+                ResetFailingState();
+
+                Signal();
+            }
+        }
+
+        public void Cancel(GpuContext gpuContext)
+        {
+            lock (Lock)
+            {
+                NvHostEventState oldState = State;
+
+                State = NvHostEventState.Cancelling;
+
+                if (oldState == NvHostEventState.Waiting && _waiterInformation != null)
+                {
+                    gpuContext.Synchronization.UnregisterCallback(Fence.Id, _waiterInformation);
+                    _waiterInformation = null;
+
+                    if (_previousFailingFence.Id == Fence.Id && _previousFailingFence.Value == Fence.Value)
+                    {
+                        _failingCount++;
+                    }
+                    else
+                    {
+                        _failingCount = 1;
+
+                        _previousFailingFence = Fence;
+                    }
+                }
+
+                State = NvHostEventState.Cancelled;
+
+                Event.WritableEvent.Clear();
+            }
+        }
+
+        public bool Wait(GpuContext gpuContext, NvFence fence)
+        {
+            lock (Lock)
+            {
+                // NOTE: nvservices code should always wait on the GPU side.
+                //       If we do this, we may get an abort or undefined behaviour when the GPU processing thread is blocked for a long period (for example, during shader compilation).
+                //       The reason for this is that the NVN code will try to wait until giving up.
+                //       This is done by trying to wait and signal multiple times until aborting after you are past the timeout.
+                //       As such, if it fails too many time, we enforce a wait on the CPU side indefinitely.
+                //       This allows to keep GPU and CPU in sync when we are slow.
+                if (_failingCount == FailingCountMax)
+                {
+                    Logger.Warning?.Print(LogClass.ServiceNv, "GPU processing thread is too slow, waiting on CPU...");
+
+                    Fence.Wait(gpuContext, Timeout.InfiniteTimeSpan);
+
+                    ResetFailingState();
+
+                    return false;
+                }
+                else
+                {
+                    Fence = fence;
+                    State = NvHostEventState.Waiting;
+
+                    _waiterInformation = gpuContext.Synchronization.RegisterCallbackOnSyncpoint(Fence.Id, Fence.Value, GpuSignaled);
+
+                    return true;
+                }
+            }
+        }
+
+        public string DumpState(GpuContext gpuContext)
+        {
+            string res = $"\nNvHostEvent {_eventId}:\n";
+            res += $"\tState: {State}\n";
+
+            if (State == NvHostEventState.Waiting)
+            {
+                res += "\tFence:\n";
+                res += $"\t\tId            : {Fence.Id}\n";
+                res += $"\t\tThreshold     : {Fence.Value}\n";
+                res += $"\t\tCurrent Value : {gpuContext.Synchronization.GetSyncpointValue(Fence.Id)}\n";
+                res += $"\t\tWaiter Valid  : {_waiterInformation != null}\n";
+            }
+
+            return res;
+        }
+
+        public void CloseEvent(ServiceCtx context)
+        {
+            if (EventHandle != 0)
+            {
+                context.Process.HandleTable.CloseHandle(EventHandle);
+                EventHandle = 0;
+            }
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Nv/NvDrvServices/NvHostCtrl/Types/NvHostEventState.cs

@@ -0,0 +1,12 @@
+namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostCtrl
+{
+    enum NvHostEventState
+    {
+        Available  = 0,
+        Waiting    = 1,
+        Cancelling = 2,
+        Signaling  = 3,
+        Signaled   = 4,
+        Cancelled  = 5
+    }
+}

src/Ryujinx.HLE/HOS/Services/Nv/NvDrvServices/NvHostCtrl/Types/NvHostSyncPt.cs

@@ -0,0 +1,199 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Graphics.Gpu.Synchronization;
+using System;
+using System.Threading;
+
+namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostCtrl
+{
+    class NvHostSyncpt
+    {
+        public const int VBlank0SyncpointId = 26;
+        public const int VBlank1SyncpointId = 27;
+
+        private int[]  _counterMin;
+        private int[]  _counterMax;
+        private bool[] _clientManaged;
+        private bool[] _assigned;
+
+        private Switch _device;
+
+        private object _syncpointAllocatorLock = new object();
+
+        public NvHostSyncpt(Switch device)
+        {
+            _device        = device;
+            _counterMin    = new int[SynchronizationManager.MaxHardwareSyncpoints];
+            _counterMax    = new int[SynchronizationManager.MaxHardwareSyncpoints];
+            _clientManaged = new bool[SynchronizationManager.MaxHardwareSyncpoints];
+            _assigned      = new bool[SynchronizationManager.MaxHardwareSyncpoints];
+
+            // Reserve VBLANK syncpoints
+            ReserveSyncpointLocked(VBlank0SyncpointId, true);
+            ReserveSyncpointLocked(VBlank1SyncpointId, true);
+        }
+
+        private void ReserveSyncpointLocked(uint id, bool isClientManaged)
+        {
+            if (id >= SynchronizationManager.MaxHardwareSyncpoints || _assigned[id])
+            {
+                throw new ArgumentOutOfRangeException(nameof(id));
+            }
+
+            _assigned[id]      = true;
+            _clientManaged[id] = isClientManaged;
+        }
+
+        public uint AllocateSyncpoint(bool isClientManaged)
+        {
+            lock (_syncpointAllocatorLock)
+            {
+                for (uint i = 1; i < SynchronizationManager.MaxHardwareSyncpoints; i++)
+                {
+                    if (!_assigned[i])
+                    {
+                        ReserveSyncpointLocked(i, isClientManaged);
+                        return i;
+                    }
+                }
+            }
+
+            Logger.Error?.Print(LogClass.ServiceNv, "Cannot allocate a new syncpoint!");
+
+            return 0;
+        }
+
+        public void ReleaseSyncpoint(uint id)
+        {
+            if (id == 0)
+            {
+                return;
+            }
+
+            lock (_syncpointAllocatorLock)
+            {
+                if (id >= SynchronizationManager.MaxHardwareSyncpoints || !_assigned[id])
+                {
+                    throw new ArgumentOutOfRangeException(nameof(id));
+                }
+
+                _assigned[id]      = false;
+                _clientManaged[id] = false;
+
+                SetSyncpointMinEqualSyncpointMax(id);
+            }
+        }
+
+        public void SetSyncpointMinEqualSyncpointMax(uint id)
+        {
+            if (id >= SynchronizationManager.MaxHardwareSyncpoints)
+            {
+                throw new ArgumentOutOfRangeException(nameof(id));
+            }
+
+            int value = (int)ReadSyncpointValue(id);
+
+            Interlocked.Exchange(ref _counterMax[id], value);
+        }
+
+        public uint ReadSyncpointValue(uint id)
+        {
+            return UpdateMin(id);
+        }
+
+        public uint ReadSyncpointMinValue(uint id)
+        {
+            return (uint)_counterMin[id];
+        }
+
+        public uint ReadSyncpointMaxValue(uint id)
+        {
+            return (uint)_counterMax[id];
+        }
+
+        private bool IsClientManaged(uint id)
+        {
+            if (id >= SynchronizationManager.MaxHardwareSyncpoints)
+            {
+                return false;
+            }
+
+            return _clientManaged[id];
+        }
+
+        public void Increment(uint id)
+        {
+            if (IsClientManaged(id))
+            {
+                IncrementSyncpointMax(id);
+            }
+
+            IncrementSyncpointGPU(id);
+        }
+
+        public uint UpdateMin(uint id)
+        {
+            uint newValue = _device.Gpu.Synchronization.GetSyncpointValue(id);
+
+            Interlocked.Exchange(ref _counterMin[id], (int)newValue);
+
+            return newValue;
+        }
+
+        private void IncrementSyncpointGPU(uint id)
+        {
+            _device.Gpu.Synchronization.IncrementSyncpoint(id);
+        }
+
+        public void IncrementSyncpointMin(uint id)
+        {
+            Interlocked.Increment(ref _counterMin[id]);
+        }
+
+        public uint IncrementSyncpointMaxExt(uint id, int count)
+        {
+            if (count == 0)
+            {
+                return ReadSyncpointMaxValue(id);
+            }
+
+            uint result = 0;
+
+            for (int i = 0; i < count; i++)
+            {
+                result = IncrementSyncpointMax(id);
+            }
+
+            return result;
+        }
+
+        private uint IncrementSyncpointMax(uint id)
+        {
+            return (uint)Interlocked.Increment(ref _counterMax[id]);
+        }
+
+        public uint IncrementSyncpointMax(uint id, uint incrs)
+        {
+            return (uint)Interlocked.Add(ref _counterMax[id], (int)incrs);
+        }
+
+        public bool IsSyncpointExpired(uint id, uint threshold)
+        {
+            return MinCompare(id, _counterMin[id], _counterMax[id], (int)threshold);
+        }
+
+        private bool MinCompare(uint id, int min, int max, int threshold)
+        {
+            int minDiff = min - threshold;
+            int maxDiff = max - threshold;
+
+            if (IsClientManaged(id))
+            {
+                return minDiff >= 0;
+            }
+            else
+            {
+                return (uint)maxDiff >= (uint)minDiff;
+            }
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Nv/NvDrvServices/NvHostCtrl/Types/SyncptWaitArguments.cs

@@ -0,0 +1,12 @@
+using Ryujinx.HLE.HOS.Services.Nv.Types;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostCtrl.Types
+{
+    [StructLayout(LayoutKind.Sequential)]
+    struct SyncptWaitArguments
+    {
+        public NvFence Fence;
+        public int     Timeout;
+    }
+}

src/Ryujinx.HLE/HOS/Services/Nv/NvDrvServices/NvHostCtrl/Types/SyncptWaitExArguments.cs

@@ -0,0 +1,11 @@
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostCtrl.Types
+{
+    [StructLayout(LayoutKind.Sequential)]
+    struct SyncptWaitExArguments
+    {
+        public SyncptWaitArguments Input;
+        public uint                Value;
+    }
+}