Ryujinx/Ryujinx.Graphics.Gpu/NvGpuFifo.cs

223 lines
6.7 KiB
C#
Raw Normal View History

2019-11-22 03:46:14 +01:00
using Ryujinx.Graphics.Gpu.State;
2020-03-13 02:30:26 +01:00
using System.IO;
2019-11-22 03:46:14 +01:00
2019-10-13 08:02:07 +02:00
namespace Ryujinx.Graphics.Gpu
{
/// <summary>
/// GPU commands FIFO.
/// </summary>
2019-10-13 08:02:07 +02:00
class NvGpuFifo
{
private const int MacrosCount = 0x80;
private const int MacroIndexMask = MacrosCount - 1;
// Note: The size of the macro memory is unknown, we just make
// a guess here and use 256kb as the size. Increase if needed.
private const int MmeWords = 256 * 256;
private GpuContext _context;
/// <summary>
/// Cached GPU macro program.
/// </summary>
2019-10-13 08:02:07 +02:00
private struct CachedMacro
{
2019-12-31 23:09:49 +01:00
/// <summary>
/// Word offset of the code on the code memory.
/// </summary>
public int Position { get; }
2019-10-13 08:02:07 +02:00
private bool _executionPending;
private int _argument;
private MacroInterpreter _interpreter;
/// <summary>
/// Creates a new instance of the GPU cached macro program.
/// </summary>
/// <param name="position">Macro code start position</param>
public CachedMacro(int position)
2019-10-13 08:02:07 +02:00
{
Position = position;
_executionPending = false;
_argument = 0;
_interpreter = new MacroInterpreter();
2019-10-13 08:02:07 +02:00
}
/// <summary>
/// Sets the first argument for the macro call.
/// </summary>
/// <param name="argument">First argument</param>
2019-10-13 08:02:07 +02:00
public void StartExecution(int argument)
{
_argument = argument;
_executionPending = true;
}
/// <summary>
/// Starts executing the macro program code.
/// </summary>
/// <param name="mme">Program code</param>
/// <param name="state">Current GPU state</param>
public void Execute(int[] mme, ShadowRamControl shadowCtrl, GpuState state)
2019-10-13 08:02:07 +02:00
{
if (_executionPending)
{
_executionPending = false;
_interpreter?.Execute(mme, Position, _argument, shadowCtrl, state);
2019-10-13 08:02:07 +02:00
}
}
/// <summary>
/// Pushes an argument to the macro call argument FIFO.
/// </summary>
/// <param name="argument">Argument to be pushed</param>
2019-10-13 08:02:07 +02:00
public void PushArgument(int argument)
{
_interpreter?.Fifo.Enqueue(argument);
}
}
private int _currMacroPosition;
private int _currMacroBindIndex;
2020-03-13 02:30:26 +01:00
private ShadowRamControl _shadowCtrl;
2019-10-13 08:02:07 +02:00
private CachedMacro[] _macros;
private int[] _mme;
/// <summary>
/// GPU sub-channel information.
/// </summary>
2019-11-22 03:46:14 +01:00
private class SubChannel
{
/// <summary>
/// Sub-channel GPU state.
/// </summary>
2019-11-22 03:46:14 +01:00
public GpuState State { get; }
/// <summary>
/// Engine bound to the sub-channel.
/// </summary>
2019-11-22 03:46:14 +01:00
public ClassId Class { get; set; }
/// <summary>
/// Creates a new instance of the GPU sub-channel.
/// </summary>
2019-11-22 03:46:14 +01:00
public SubChannel()
{
State = new GpuState();
}
}
private SubChannel[] _subChannels;
2019-10-13 08:02:07 +02:00
private SubChannel _fifoChannel;
/// <summary>
/// Creates a new instance of the GPU commands FIFO.
/// </summary>
/// <param name="context">GPU emulation context</param>
2019-10-13 08:02:07 +02:00
public NvGpuFifo(GpuContext context)
{
_context = context;
_macros = new CachedMacro[MacrosCount];
_mme = new int[MmeWords];
_fifoChannel = new SubChannel();
_context.Methods.RegisterCallbacksForFifo(_fifoChannel.State);
2019-11-22 03:46:14 +01:00
_subChannels = new SubChannel[8];
for (int index = 0; index < _subChannels.Length; index++)
{
_subChannels[index] = new SubChannel();
_context.Methods.RegisterCallbacks(_subChannels[index].State);
2019-11-22 03:46:14 +01:00
}
2019-10-13 08:02:07 +02:00
}
/// <summary>
/// Send macro code/data to the MME
/// </summary>
/// <param name="index">The index in the MME</param>
/// <param name="data">The data to use</param>
public void SendMacroCodeData(int index, int data)
{
_mme[index] = data;
}
/// <summary>
/// Bind a macro index to a position for the MME
/// </summary>
/// <param name="index">The macro index</param>
/// <param name="position">The position of the macro</param>
public void BindMacro(int index, int position)
{
_macros[index] = new CachedMacro(position);
}
/// <summary>
/// Change the shadow RAM setting
/// </summary>
/// <param name="shadowCtrl">The new Shadow RAM setting</param>
public void SetMmeShadowRamControl(ShadowRamControl shadowCtrl)
{
_shadowCtrl = shadowCtrl;
}
/// <summary>
/// Calls a GPU method.
/// </summary>
/// <param name="meth">GPU method call parameters</param>
2019-10-13 08:02:07 +02:00
public void CallMethod(MethodParams meth)
{
if ((MethodOffset)meth.Method == MethodOffset.BindChannel)
2019-10-13 08:02:07 +02:00
{
_subChannels[meth.SubChannel] = new SubChannel
{
Class = (ClassId)meth.Argument
};
_context.Methods.RegisterCallbacks(_subChannels[meth.SubChannel].State);
2019-10-13 08:02:07 +02:00
}
else if (meth.Method < 0x60)
{
// TODO: check if macros are shared between subchannels or not. For now let's assume they are.
2020-04-25 16:17:22 +02:00
_fifoChannel.State.CallMethod(meth, _shadowCtrl);
2019-10-13 08:02:07 +02:00
}
else if (meth.Method < 0xe00)
{
_subChannels[meth.SubChannel].State.CallMethod(meth, _shadowCtrl);
2019-10-13 08:02:07 +02:00
}
else
{
int macroIndex = (meth.Method >> 1) & MacroIndexMask;
if ((meth.Method & 1) != 0)
{
_macros[macroIndex].PushArgument(meth.Argument);
}
else
{
_macros[macroIndex].StartExecution(meth.Argument);
}
if (meth.IsLastCall)
{
_macros[macroIndex].Execute(_mme, _shadowCtrl, _subChannels[meth.SubChannel].State);
2019-10-13 08:02:07 +02:00
_context.Methods.PerformDeferredDraws();
}
}
}
}
}