mirror of
https://git.ryujinx.app/ryubing/ryujinx.git
synced 2025-08-03 00:27:11 +02:00
Rewrite nvservices (#800)
* Start rewriting nvservices internals TODO: - nvgpu device interface - nvhost generic device interface * Some clean up and fixes - Make sure to remove the fd of a closed channel. - NvFileDevice now doesn't implement Disposable as it was never used. - Rename NvHostCtrlGetConfigurationArgument to GetConfigurationArguments to follow calling convention. - Make sure to check every ioctls magic. * Finalize migration for ioctl standard variant TODO: ioctl2 migration * Implement SubmitGpfifoEx and fix nvdec * Implement Ioctl3 * Implement some ioctl3 required by recent games * Remove unused code and outdated comments * Return valid event handles with QueryEvent Also add an exception for unimplemented event ids. This commit doesn't implement accurately the events, this only define different events for different event ids. * Rename all occurance of FileDevice to DeviceFile * Restub SetClientPid to not cause regressions * Address comments * Remove GlobalStateTable * Address comments * Align variables in ioctl3 * Some missing alignments * GetVaRegionsArguments realign * Make Owner public in NvDeviceFile * Address LDj3SNuD's comments
This commit is contained in:
Thomas Guillemard
jduncanator
parent
848cda1837
commit
9426ef3f06
75 changed files with 2798 additions and 2005 deletions
|
|
@ -0,0 +1,401 @@
|
|||
using Ryujinx.Common.Logging;
|
||||
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 System;
|
||||
using System.Text;
|
||||
using System.Threading;
|
||||
|
||||
namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostCtrl
|
||||
{
|
||||
internal class NvHostCtrlDeviceFile : NvDeviceFile
|
||||
{
|
||||
private const int EventsCount = 64;
|
||||
|
||||
private bool _isProductionMode;
|
||||
private NvHostSyncpt _syncpt;
|
||||
private NvHostEvent[] _events;
|
||||
private KEvent _dummyEvent;
|
||||
|
||||
public NvHostCtrlDeviceFile(ServiceCtx context) : base(context)
|
||||
{
|
||||
if (NxSettings.Settings.TryGetValue("nv!rmos_set_production_mode", out object productionModeSetting))
|
||||
{
|
||||
_isProductionMode = ((string)productionModeSetting) != "0"; // Default value is ""
|
||||
}
|
||||
else
|
||||
{
|
||||
_isProductionMode = true;
|
||||
}
|
||||
|
||||
_syncpt = new NvHostSyncpt();
|
||||
_events = new NvHostEvent[EventsCount];
|
||||
_dummyEvent = new KEvent(context.Device.System);
|
||||
}
|
||||
|
||||
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 0x1d:
|
||||
result = CallIoctlMethod<EventWaitArguments>(EventWait, arguments);
|
||||
break;
|
||||
case 0x1e:
|
||||
result = CallIoctlMethod<EventWaitArguments>(EventWaitAsync, arguments);
|
||||
break;
|
||||
case 0x1f:
|
||||
result = CallIoctlMethod<uint>(EventRegister, arguments);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
public override NvInternalResult QueryEvent(out int eventHandle, uint eventId)
|
||||
{
|
||||
// TODO: implement SyncPts <=> KEvent logic accurately. For now we return a dummy event.
|
||||
KEvent targetEvent = _dummyEvent;
|
||||
|
||||
if (targetEvent != null)
|
||||
{
|
||||
if (Owner.HandleTable.GenerateHandle(targetEvent.ReadableEvent, out eventHandle) != KernelResult.Success)
|
||||
{
|
||||
throw new InvalidOperationException("Out of handles!");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
eventHandle = 0;
|
||||
|
||||
return NvInternalResult.InvalidInput;
|
||||
}
|
||||
|
||||
return NvInternalResult.Success;
|
||||
}
|
||||
|
||||
private NvInternalResult SyncptRead(ref NvFence arguments)
|
||||
{
|
||||
return SyncptReadMinOrMax(ref arguments, max: false);
|
||||
}
|
||||
|
||||
private NvInternalResult SyncptIncr(ref uint id)
|
||||
{
|
||||
if (id >= NvHostSyncpt.SyncptsCount)
|
||||
{
|
||||
return NvInternalResult.InvalidInput;
|
||||
}
|
||||
|
||||
_syncpt.Increment((int)id);
|
||||
|
||||
return NvInternalResult.Success;
|
||||
}
|
||||
|
||||
private NvInternalResult SyncptWait(ref SyncptWaitArguments arguments)
|
||||
{
|
||||
return SyncptWait(ref arguments, out _);
|
||||
}
|
||||
|
||||
private NvInternalResult SyncptWaitEx(ref SyncptWaitExArguments arguments)
|
||||
{
|
||||
return SyncptWait(ref arguments.Input, out arguments.Value);
|
||||
}
|
||||
|
||||
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.PrintError(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.PrintDebug(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, async: false);
|
||||
}
|
||||
|
||||
private NvInternalResult EventWaitAsync(ref EventWaitArguments arguments)
|
||||
{
|
||||
return EventWait(ref arguments, async: true);
|
||||
}
|
||||
|
||||
private NvInternalResult EventRegister(ref uint userEventId)
|
||||
{
|
||||
Logger.PrintStub(LogClass.ServiceNv);
|
||||
|
||||
return NvInternalResult.Success;
|
||||
}
|
||||
|
||||
private NvInternalResult SyncptReadMinOrMax(ref NvFence arguments, bool max)
|
||||
{
|
||||
if (arguments.Id >= NvHostSyncpt.SyncptsCount)
|
||||
{
|
||||
return NvInternalResult.InvalidInput;
|
||||
}
|
||||
|
||||
if (max)
|
||||
{
|
||||
arguments.Value = (uint)_syncpt.GetMax((int)arguments.Id);
|
||||
}
|
||||
else
|
||||
{
|
||||
arguments.Value = (uint)_syncpt.GetMin((int)arguments.Id);
|
||||
}
|
||||
|
||||
return NvInternalResult.Success;
|
||||
}
|
||||
|
||||
private NvInternalResult SyncptWait(ref SyncptWaitArguments arguments, out int value)
|
||||
{
|
||||
if (arguments.Id >= NvHostSyncpt.SyncptsCount)
|
||||
{
|
||||
value = 0;
|
||||
|
||||
return NvInternalResult.InvalidInput;
|
||||
}
|
||||
|
||||
NvInternalResult result;
|
||||
|
||||
if (_syncpt.MinCompare((int)arguments.Id, arguments.Thresh))
|
||||
{
|
||||
result = NvInternalResult.Success;
|
||||
}
|
||||
else if (arguments.Timeout == 0)
|
||||
{
|
||||
result = NvInternalResult.TryAgain;
|
||||
}
|
||||
else
|
||||
{
|
||||
Logger.PrintDebug(LogClass.ServiceNv, $"Waiting syncpt with timeout of {arguments.Timeout}ms...");
|
||||
|
||||
using (ManualResetEvent waitEvent = new ManualResetEvent(false))
|
||||
{
|
||||
_syncpt.AddWaiter(arguments.Thresh, waitEvent);
|
||||
|
||||
// Note: Negative (> INT_MAX) timeouts aren't valid on .NET,
|
||||
// in this case we just use the maximum timeout possible.
|
||||
int timeout = arguments.Timeout;
|
||||
|
||||
if (timeout < -1)
|
||||
{
|
||||
timeout = int.MaxValue;
|
||||
}
|
||||
|
||||
if (timeout == -1)
|
||||
{
|
||||
waitEvent.WaitOne();
|
||||
|
||||
result = NvInternalResult.Success;
|
||||
}
|
||||
else if (waitEvent.WaitOne(timeout))
|
||||
{
|
||||
result = NvInternalResult.Success;
|
||||
}
|
||||
else
|
||||
{
|
||||
result = NvInternalResult.TimedOut;
|
||||
}
|
||||
}
|
||||
|
||||
Logger.PrintDebug(LogClass.ServiceNv, "Resuming...");
|
||||
}
|
||||
|
||||
value = _syncpt.GetMin((int)arguments.Id);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
private NvInternalResult EventWait(ref EventWaitArguments arguments, bool async)
|
||||
{
|
||||
if (arguments.Id >= NvHostSyncpt.SyncptsCount)
|
||||
{
|
||||
return NvInternalResult.InvalidInput;
|
||||
}
|
||||
|
||||
if (_syncpt.MinCompare(arguments.Id, arguments.Thresh))
|
||||
{
|
||||
arguments.Value = _syncpt.GetMin(arguments.Id);
|
||||
|
||||
return NvInternalResult.Success;
|
||||
}
|
||||
|
||||
if (!async)
|
||||
{
|
||||
arguments.Value = 0;
|
||||
}
|
||||
|
||||
if (arguments.Timeout == 0)
|
||||
{
|
||||
return NvInternalResult.TryAgain;
|
||||
}
|
||||
|
||||
NvHostEvent Event;
|
||||
|
||||
NvInternalResult result;
|
||||
|
||||
int eventIndex;
|
||||
|
||||
if (async)
|
||||
{
|
||||
eventIndex = arguments.Value;
|
||||
|
||||
if ((uint)eventIndex >= EventsCount)
|
||||
{
|
||||
return NvInternalResult.InvalidInput;
|
||||
}
|
||||
|
||||
Event = _events[eventIndex];
|
||||
}
|
||||
else
|
||||
{
|
||||
Event = GetFreeEvent(arguments.Id, out eventIndex);
|
||||
}
|
||||
|
||||
if (Event != null &&
|
||||
(Event.State == NvHostEventState.Registered ||
|
||||
Event.State == NvHostEventState.Free))
|
||||
{
|
||||
Event.Id = arguments.Id;
|
||||
Event.Thresh = arguments.Thresh;
|
||||
|
||||
Event.State = NvHostEventState.Waiting;
|
||||
|
||||
if (!async)
|
||||
{
|
||||
arguments.Value = ((arguments.Id & 0xfff) << 16) | 0x10000000;
|
||||
}
|
||||
else
|
||||
{
|
||||
arguments.Value = arguments.Id << 4;
|
||||
}
|
||||
|
||||
arguments.Value |= eventIndex;
|
||||
|
||||
result = NvInternalResult.TryAgain;
|
||||
}
|
||||
else
|
||||
{
|
||||
result = NvInternalResult.InvalidInput;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
private NvHostEvent GetFreeEvent(int id, out int eventIndex)
|
||||
{
|
||||
eventIndex = EventsCount;
|
||||
|
||||
int nullIndex = EventsCount;
|
||||
|
||||
for (int index = 0; index < EventsCount; index++)
|
||||
{
|
||||
NvHostEvent Event = _events[index];
|
||||
|
||||
if (Event != null)
|
||||
{
|
||||
if (Event.State == NvHostEventState.Registered ||
|
||||
Event.State == NvHostEventState.Free)
|
||||
{
|
||||
eventIndex = index;
|
||||
|
||||
if (Event.Id == id)
|
||||
{
|
||||
return Event;
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (nullIndex == EventsCount)
|
||||
{
|
||||
nullIndex = index;
|
||||
}
|
||||
}
|
||||
|
||||
if (nullIndex < EventsCount)
|
||||
{
|
||||
eventIndex = nullIndex;
|
||||
|
||||
return _events[nullIndex] = new NvHostEvent();
|
||||
}
|
||||
|
||||
if (eventIndex < EventsCount)
|
||||
{
|
||||
return _events[eventIndex];
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
public override void Close() { }
|
||||
}
|
||||
}
|
||||
|
|
@ -1,400 +0,0 @@
|
|||
using ARMeilleure.Memory;
|
||||
using Ryujinx.Common.Logging;
|
||||
using Ryujinx.HLE.HOS.Kernel.Process;
|
||||
using Ryujinx.HLE.HOS.Services.Settings;
|
||||
using System;
|
||||
using System.Collections.Concurrent;
|
||||
using System.Text;
|
||||
using System.Threading;
|
||||
|
||||
namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostCtrl
|
||||
{
|
||||
class NvHostCtrlIoctl
|
||||
{
|
||||
private static ConcurrentDictionary<KProcess, NvHostCtrlUserCtx> _userCtxs;
|
||||
|
||||
private static bool _isProductionMode = true;
|
||||
|
||||
static NvHostCtrlIoctl()
|
||||
{
|
||||
_userCtxs = new ConcurrentDictionary<KProcess, NvHostCtrlUserCtx>();
|
||||
|
||||
if (NxSettings.Settings.TryGetValue("nv!rmos_set_production_mode", out object productionModeSetting))
|
||||
{
|
||||
_isProductionMode = ((string)productionModeSetting) != "0"; // Default value is ""
|
||||
}
|
||||
}
|
||||
|
||||
public static int ProcessIoctl(ServiceCtx context, int cmd)
|
||||
{
|
||||
switch (cmd & 0xffff)
|
||||
{
|
||||
case 0x0014: return SyncptRead (context);
|
||||
case 0x0015: return SyncptIncr (context);
|
||||
case 0x0016: return SyncptWait (context);
|
||||
case 0x0019: return SyncptWaitEx (context);
|
||||
case 0x001a: return SyncptReadMax (context);
|
||||
case 0x001b: return GetConfig (context);
|
||||
case 0x001d: return EventWait (context);
|
||||
case 0x001e: return EventWaitAsync(context);
|
||||
case 0x001f: return EventRegister (context);
|
||||
}
|
||||
|
||||
throw new NotImplementedException(cmd.ToString("x8"));
|
||||
}
|
||||
|
||||
private static int SyncptRead(ServiceCtx context)
|
||||
{
|
||||
return SyncptReadMinOrMax(context, max: false);
|
||||
}
|
||||
|
||||
private static int SyncptIncr(ServiceCtx context)
|
||||
{
|
||||
long inputPosition = context.Request.GetBufferType0x21().Position;
|
||||
|
||||
int id = context.Memory.ReadInt32(inputPosition);
|
||||
|
||||
if ((uint)id >= NvHostSyncpt.SyncptsCount)
|
||||
{
|
||||
return NvResult.InvalidInput;
|
||||
}
|
||||
|
||||
GetUserCtx(context).Syncpt.Increment(id);
|
||||
|
||||
return NvResult.Success;
|
||||
}
|
||||
|
||||
private static int SyncptWait(ServiceCtx context)
|
||||
{
|
||||
return SyncptWait(context, extended: false);
|
||||
}
|
||||
|
||||
private static int SyncptWaitEx(ServiceCtx context)
|
||||
{
|
||||
return SyncptWait(context, extended: true);
|
||||
}
|
||||
|
||||
private static int SyncptReadMax(ServiceCtx context)
|
||||
{
|
||||
return SyncptReadMinOrMax(context, max: true);
|
||||
}
|
||||
|
||||
private static int GetConfig(ServiceCtx context)
|
||||
{
|
||||
if (!_isProductionMode)
|
||||
{
|
||||
long inputPosition = context.Request.GetBufferType0x21().Position;
|
||||
long outputPosition = context.Request.GetBufferType0x22().Position;
|
||||
|
||||
string domain = MemoryHelper.ReadAsciiString(context.Memory, inputPosition + 0, 0x41);
|
||||
string name = MemoryHelper.ReadAsciiString(context.Memory, inputPosition + 0x41, 0x41);
|
||||
|
||||
if (NxSettings.Settings.TryGetValue($"{domain}!{name}", out object nvSetting))
|
||||
{
|
||||
byte[] settingBuffer = new byte[0x101];
|
||||
|
||||
if (nvSetting is string stringValue)
|
||||
{
|
||||
if (stringValue.Length > 0x100)
|
||||
{
|
||||
Logger.PrintError(LogClass.ServiceNv, $"{domain}!{name} String value size is too big!");
|
||||
}
|
||||
else
|
||||
{
|
||||
settingBuffer = Encoding.ASCII.GetBytes(stringValue + "\0");
|
||||
}
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
context.Memory.WriteBytes(outputPosition + 0x82, settingBuffer);
|
||||
|
||||
Logger.PrintDebug(LogClass.ServiceNv, $"Got setting {domain}!{name}");
|
||||
}
|
||||
|
||||
return NvResult.Success;
|
||||
}
|
||||
|
||||
return NvResult.NotAvailableInProduction;
|
||||
}
|
||||
|
||||
private static int EventWait(ServiceCtx context)
|
||||
{
|
||||
return EventWait(context, async: false);
|
||||
}
|
||||
|
||||
private static int EventWaitAsync(ServiceCtx context)
|
||||
{
|
||||
return EventWait(context, async: true);
|
||||
}
|
||||
|
||||
private static int EventRegister(ServiceCtx context)
|
||||
{
|
||||
long inputPosition = context.Request.GetBufferType0x21().Position;
|
||||
long outputPosition = context.Request.GetBufferType0x22().Position;
|
||||
|
||||
int eventId = context.Memory.ReadInt32(inputPosition);
|
||||
|
||||
Logger.PrintStub(LogClass.ServiceNv);
|
||||
|
||||
return NvResult.Success;
|
||||
}
|
||||
|
||||
private static int SyncptReadMinOrMax(ServiceCtx context, bool max)
|
||||
{
|
||||
long inputPosition = context.Request.GetBufferType0x21().Position;
|
||||
long outputPosition = context.Request.GetBufferType0x22().Position;
|
||||
|
||||
NvHostCtrlSyncptRead args = MemoryHelper.Read<NvHostCtrlSyncptRead>(context.Memory, inputPosition);
|
||||
|
||||
if ((uint)args.Id >= NvHostSyncpt.SyncptsCount)
|
||||
{
|
||||
return NvResult.InvalidInput;
|
||||
}
|
||||
|
||||
if (max)
|
||||
{
|
||||
args.Value = GetUserCtx(context).Syncpt.GetMax(args.Id);
|
||||
}
|
||||
else
|
||||
{
|
||||
args.Value = GetUserCtx(context).Syncpt.GetMin(args.Id);
|
||||
}
|
||||
|
||||
MemoryHelper.Write(context.Memory, outputPosition, args);
|
||||
|
||||
return NvResult.Success;
|
||||
}
|
||||
|
||||
private static int SyncptWait(ServiceCtx context, bool extended)
|
||||
{
|
||||
long inputPosition = context.Request.GetBufferType0x21().Position;
|
||||
long outputPosition = context.Request.GetBufferType0x22().Position;
|
||||
|
||||
NvHostCtrlSyncptWait args = MemoryHelper.Read<NvHostCtrlSyncptWait>(context.Memory, inputPosition);
|
||||
|
||||
NvHostSyncpt syncpt = GetUserCtx(context).Syncpt;
|
||||
|
||||
if ((uint)args.Id >= NvHostSyncpt.SyncptsCount)
|
||||
{
|
||||
return NvResult.InvalidInput;
|
||||
}
|
||||
|
||||
int result;
|
||||
|
||||
if (syncpt.MinCompare(args.Id, args.Thresh))
|
||||
{
|
||||
result = NvResult.Success;
|
||||
}
|
||||
else if (args.Timeout == 0)
|
||||
{
|
||||
result = NvResult.TryAgain;
|
||||
}
|
||||
else
|
||||
{
|
||||
Logger.PrintDebug(LogClass.ServiceNv, "Waiting syncpt with timeout of " + args.Timeout + "ms...");
|
||||
|
||||
using (ManualResetEvent waitEvent = new ManualResetEvent(false))
|
||||
{
|
||||
syncpt.AddWaiter(args.Thresh, waitEvent);
|
||||
|
||||
// Note: Negative (> INT_MAX) timeouts aren't valid on .NET,
|
||||
// in this case we just use the maximum timeout possible.
|
||||
int timeout = args.Timeout;
|
||||
|
||||
if (timeout < -1)
|
||||
{
|
||||
timeout = int.MaxValue;
|
||||
}
|
||||
|
||||
if (timeout == -1)
|
||||
{
|
||||
waitEvent.WaitOne();
|
||||
|
||||
result = NvResult.Success;
|
||||
}
|
||||
else if (waitEvent.WaitOne(timeout))
|
||||
{
|
||||
result = NvResult.Success;
|
||||
}
|
||||
else
|
||||
{
|
||||
result = NvResult.TimedOut;
|
||||
}
|
||||
}
|
||||
|
||||
Logger.PrintDebug(LogClass.ServiceNv, "Resuming...");
|
||||
}
|
||||
|
||||
if (extended)
|
||||
{
|
||||
context.Memory.WriteInt32(outputPosition + 0xc, syncpt.GetMin(args.Id));
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
private static int EventWait(ServiceCtx context, bool async)
|
||||
{
|
||||
long inputPosition = context.Request.GetBufferType0x21().Position;
|
||||
long outputPosition = context.Request.GetBufferType0x22().Position;
|
||||
|
||||
NvHostCtrlSyncptWaitEx args = MemoryHelper.Read<NvHostCtrlSyncptWaitEx>(context.Memory, inputPosition);
|
||||
|
||||
if ((uint)args.Id >= NvHostSyncpt.SyncptsCount)
|
||||
{
|
||||
return NvResult.InvalidInput;
|
||||
}
|
||||
|
||||
void WriteArgs()
|
||||
{
|
||||
MemoryHelper.Write(context.Memory, outputPosition, args);
|
||||
}
|
||||
|
||||
NvHostSyncpt syncpt = GetUserCtx(context).Syncpt;
|
||||
|
||||
if (syncpt.MinCompare(args.Id, args.Thresh))
|
||||
{
|
||||
args.Value = syncpt.GetMin(args.Id);
|
||||
|
||||
WriteArgs();
|
||||
|
||||
return NvResult.Success;
|
||||
}
|
||||
|
||||
if (!async)
|
||||
{
|
||||
args.Value = 0;
|
||||
}
|
||||
|
||||
if (args.Timeout == 0)
|
||||
{
|
||||
WriteArgs();
|
||||
|
||||
return NvResult.TryAgain;
|
||||
}
|
||||
|
||||
NvHostEvent Event;
|
||||
|
||||
int result, eventIndex;
|
||||
|
||||
if (async)
|
||||
{
|
||||
eventIndex = args.Value;
|
||||
|
||||
if ((uint)eventIndex >= NvHostCtrlUserCtx.EventsCount)
|
||||
{
|
||||
return NvResult.InvalidInput;
|
||||
}
|
||||
|
||||
Event = GetUserCtx(context).Events[eventIndex];
|
||||
}
|
||||
else
|
||||
{
|
||||
Event = GetFreeEvent(context, syncpt, args.Id, out eventIndex);
|
||||
}
|
||||
|
||||
if (Event != null &&
|
||||
(Event.State == NvHostEventState.Registered ||
|
||||
Event.State == NvHostEventState.Free))
|
||||
{
|
||||
Event.Id = args.Id;
|
||||
Event.Thresh = args.Thresh;
|
||||
|
||||
Event.State = NvHostEventState.Waiting;
|
||||
|
||||
if (!async)
|
||||
{
|
||||
args.Value = ((args.Id & 0xfff) << 16) | 0x10000000;
|
||||
}
|
||||
else
|
||||
{
|
||||
args.Value = args.Id << 4;
|
||||
}
|
||||
|
||||
args.Value |= eventIndex;
|
||||
|
||||
result = NvResult.TryAgain;
|
||||
}
|
||||
else
|
||||
{
|
||||
result = NvResult.InvalidInput;
|
||||
}
|
||||
|
||||
WriteArgs();
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
private static NvHostEvent GetFreeEvent(
|
||||
ServiceCtx context,
|
||||
NvHostSyncpt syncpt,
|
||||
int id,
|
||||
out int eventIndex)
|
||||
{
|
||||
NvHostEvent[] events = GetUserCtx(context).Events;
|
||||
|
||||
eventIndex = NvHostCtrlUserCtx.EventsCount;
|
||||
|
||||
int nullIndex = NvHostCtrlUserCtx.EventsCount;
|
||||
|
||||
for (int index = 0; index < NvHostCtrlUserCtx.EventsCount; index++)
|
||||
{
|
||||
NvHostEvent Event = events[index];
|
||||
|
||||
if (Event != null)
|
||||
{
|
||||
if (Event.State == NvHostEventState.Registered ||
|
||||
Event.State == NvHostEventState.Free)
|
||||
{
|
||||
eventIndex = index;
|
||||
|
||||
if (Event.Id == id)
|
||||
{
|
||||
return Event;
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (nullIndex == NvHostCtrlUserCtx.EventsCount)
|
||||
{
|
||||
nullIndex = index;
|
||||
}
|
||||
}
|
||||
|
||||
if (nullIndex < NvHostCtrlUserCtx.EventsCount)
|
||||
{
|
||||
eventIndex = nullIndex;
|
||||
|
||||
return events[nullIndex] = new NvHostEvent();
|
||||
}
|
||||
|
||||
if (eventIndex < NvHostCtrlUserCtx.EventsCount)
|
||||
{
|
||||
return events[eventIndex];
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
public static NvHostCtrlUserCtx GetUserCtx(ServiceCtx context)
|
||||
{
|
||||
return _userCtxs.GetOrAdd(context.Process, (key) => new NvHostCtrlUserCtx());
|
||||
}
|
||||
|
||||
public static void UnloadProcess(KProcess process)
|
||||
{
|
||||
_userCtxs.TryRemove(process, out _);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
using System.Runtime.InteropServices;
|
||||
|
||||
namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostCtrl.Types
|
||||
{
|
||||
[StructLayout(LayoutKind.Sequential)]
|
||||
struct EventWaitArguments
|
||||
{
|
||||
public int Id;
|
||||
public int Thresh;
|
||||
public int Timeout;
|
||||
public int Value;
|
||||
}
|
||||
}
|
||||
|
|
@ -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));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,8 +0,0 @@
|
|||
namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostCtrl
|
||||
{
|
||||
struct NvHostCtrlSyncptRead
|
||||
{
|
||||
public int Id;
|
||||
public int Value;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostCtrl
|
||||
{
|
||||
struct NvHostCtrlSyncptWait
|
||||
{
|
||||
public int Id;
|
||||
public int Thresh;
|
||||
public int Timeout;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,10 +0,0 @@
|
|||
namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostCtrl
|
||||
{
|
||||
struct NvHostCtrlSyncptWaitEx
|
||||
{
|
||||
public int Id;
|
||||
public int Thresh;
|
||||
public int Timeout;
|
||||
public int Value;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,19 +0,0 @@
|
|||
namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostCtrl
|
||||
{
|
||||
class NvHostCtrlUserCtx
|
||||
{
|
||||
public const int LocksCount = 16;
|
||||
public const int EventsCount = 64;
|
||||
|
||||
public NvHostSyncpt Syncpt { get; private set; }
|
||||
|
||||
public NvHostEvent[] Events { get; private set; }
|
||||
|
||||
public NvHostCtrlUserCtx()
|
||||
{
|
||||
Syncpt = new NvHostSyncpt();
|
||||
|
||||
Events = new NvHostEvent[EventsCount];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
using System.Runtime.InteropServices;
|
||||
|
||||
namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostCtrl.Types
|
||||
{
|
||||
[StructLayout(LayoutKind.Sequential)]
|
||||
struct SyncptWaitArguments
|
||||
{
|
||||
public uint Id;
|
||||
public int Thresh;
|
||||
public int Timeout;
|
||||
}
|
||||
}
|
||||
|
|
@ -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 int Value;
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue