rjx-mirror/Ryujinx.HLE/HOS/Services/Nv/NvDrvServices/NvHostCtrl/NvHostCtrlDeviceFile.cs

543 lines
18 KiB
C#
Raw Normal View History

using Ryujinx.Common.Logging;
using Ryujinx.Graphics.Gpu.Synchronization;
using Ryujinx.HLE.HOS.Kernel.Common;
using Ryujinx.HLE.HOS.Kernel.Threading;
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, long 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;
}
}
}
}
}
}
}