2018-02-11 20:44:12 -08:00
|
|
|
// Copyright 2018 yuzu Emulator Project
|
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
|
|
|
#include <memory>
|
2021-09-30 21:57:02 -07:00
|
|
|
|
|
|
|
#include "common/bit_field.h"
|
2018-02-11 20:44:12 -08:00
|
|
|
#include "common/common_types.h"
|
2020-10-26 20:07:36 -07:00
|
|
|
#include "video_core/cdma_pusher.h"
|
2020-12-11 22:26:14 -08:00
|
|
|
#include "video_core/framebuffer_config.h"
|
2018-02-11 20:44:12 -08:00
|
|
|
|
2019-02-15 19:05:17 -08:00
|
|
|
namespace Core {
|
2020-03-24 19:58:49 -07:00
|
|
|
namespace Frontend {
|
|
|
|
class EmuWindow;
|
2019-02-15 19:05:17 -08:00
|
|
|
}
|
2020-03-24 19:58:49 -07:00
|
|
|
class System;
|
|
|
|
} // namespace Core
|
2019-02-15 19:05:17 -08:00
|
|
|
|
2018-08-03 09:55:58 -07:00
|
|
|
namespace VideoCore {
|
2019-01-07 20:32:02 -08:00
|
|
|
class RendererBase;
|
2020-07-09 20:36:38 -07:00
|
|
|
class ShaderNotify;
|
2019-01-07 20:32:02 -08:00
|
|
|
} // namespace VideoCore
|
2018-08-03 09:55:58 -07:00
|
|
|
|
2018-02-11 20:44:12 -08:00
|
|
|
namespace Tegra {
|
2021-09-30 21:57:02 -07:00
|
|
|
class DmaPusher;
|
|
|
|
class CDmaPusher;
|
|
|
|
struct CommandList;
|
2018-02-11 20:44:12 -08:00
|
|
|
|
2018-03-23 21:45:24 -07:00
|
|
|
enum class RenderTargetFormat : u32 {
|
2018-03-25 14:57:53 -07:00
|
|
|
NONE = 0x0,
|
2020-06-30 22:28:53 -07:00
|
|
|
R32B32G32A32_FLOAT = 0xC0,
|
|
|
|
R32G32B32A32_SINT = 0xC1,
|
|
|
|
R32G32B32A32_UINT = 0xC2,
|
|
|
|
R16G16B16A16_UNORM = 0xC6,
|
|
|
|
R16G16B16A16_SNORM = 0xC7,
|
|
|
|
R16G16B16A16_SINT = 0xC8,
|
|
|
|
R16G16B16A16_UINT = 0xC9,
|
|
|
|
R16G16B16A16_FLOAT = 0xCA,
|
|
|
|
R32G32_FLOAT = 0xCB,
|
|
|
|
R32G32_SINT = 0xCC,
|
|
|
|
R32G32_UINT = 0xCD,
|
|
|
|
R16G16B16X16_FLOAT = 0xCE,
|
|
|
|
B8G8R8A8_UNORM = 0xCF,
|
|
|
|
B8G8R8A8_SRGB = 0xD0,
|
|
|
|
A2B10G10R10_UNORM = 0xD1,
|
|
|
|
A2B10G10R10_UINT = 0xD2,
|
|
|
|
A8B8G8R8_UNORM = 0xD5,
|
|
|
|
A8B8G8R8_SRGB = 0xD6,
|
|
|
|
A8B8G8R8_SNORM = 0xD7,
|
|
|
|
A8B8G8R8_SINT = 0xD8,
|
|
|
|
A8B8G8R8_UINT = 0xD9,
|
|
|
|
R16G16_UNORM = 0xDA,
|
|
|
|
R16G16_SNORM = 0xDB,
|
|
|
|
R16G16_SINT = 0xDC,
|
|
|
|
R16G16_UINT = 0xDD,
|
|
|
|
R16G16_FLOAT = 0xDE,
|
|
|
|
B10G11R11_FLOAT = 0xE0,
|
2020-02-25 12:19:34 -08:00
|
|
|
R32_SINT = 0xE3,
|
2018-08-13 05:55:16 -07:00
|
|
|
R32_UINT = 0xE4,
|
2018-08-01 06:31:42 -07:00
|
|
|
R32_FLOAT = 0xE5,
|
2020-06-30 22:28:53 -07:00
|
|
|
R5G6B5_UNORM = 0xE8,
|
|
|
|
A1R5G5B5_UNORM = 0xE9,
|
|
|
|
R8G8_UNORM = 0xEA,
|
|
|
|
R8G8_SNORM = 0xEB,
|
|
|
|
R8G8_SINT = 0xEC,
|
|
|
|
R8G8_UINT = 0xED,
|
2018-08-11 11:01:50 -07:00
|
|
|
R16_UNORM = 0xEE,
|
|
|
|
R16_SNORM = 0xEF,
|
|
|
|
R16_SINT = 0xF0,
|
|
|
|
R16_UINT = 0xF1,
|
2018-07-25 21:19:15 -07:00
|
|
|
R16_FLOAT = 0xF2,
|
2018-07-24 14:47:50 -07:00
|
|
|
R8_UNORM = 0xF3,
|
2020-06-29 23:51:42 -07:00
|
|
|
R8_SNORM = 0xF4,
|
2020-06-30 00:00:23 -07:00
|
|
|
R8_SINT = 0xF5,
|
2018-08-11 18:44:42 -07:00
|
|
|
R8_UINT = 0xF6,
|
2018-03-22 14:40:11 -07:00
|
|
|
};
|
|
|
|
|
2018-07-02 10:42:04 -07:00
|
|
|
enum class DepthFormat : u32 {
|
2020-06-30 22:28:53 -07:00
|
|
|
D32_FLOAT = 0xA,
|
|
|
|
D16_UNORM = 0x13,
|
|
|
|
S8_UINT_Z24_UNORM = 0x14,
|
|
|
|
D24X8_UNORM = 0x15,
|
|
|
|
D24S8_UNORM = 0x16,
|
2021-11-17 12:04:38 -08:00
|
|
|
S8_UINT = 0x17,
|
2020-06-30 22:28:53 -07:00
|
|
|
D24C8_UNORM = 0x18,
|
|
|
|
D32_FLOAT_S8X24_UINT = 0x19,
|
2018-07-02 10:42:04 -07:00
|
|
|
};
|
|
|
|
|
2018-09-06 06:48:08 -07:00
|
|
|
struct CommandListHeader;
|
2018-03-22 13:19:35 -07:00
|
|
|
class DebugContext;
|
|
|
|
|
2018-03-18 13:15:05 -07:00
|
|
|
namespace Engines {
|
|
|
|
class Fermi2D;
|
|
|
|
class Maxwell3D;
|
2018-06-10 15:02:33 -07:00
|
|
|
class MaxwellDMA;
|
2019-01-22 15:49:31 -08:00
|
|
|
class KeplerCompute;
|
2018-09-08 13:58:20 -07:00
|
|
|
class KeplerMemory;
|
2018-03-18 13:15:05 -07:00
|
|
|
} // namespace Engines
|
|
|
|
|
2018-02-11 20:44:12 -08:00
|
|
|
enum class EngineID {
|
|
|
|
FERMI_TWOD_A = 0x902D, // 2D Engine
|
|
|
|
MAXWELL_B = 0xB197, // 3D Engine
|
2019-01-22 15:49:31 -08:00
|
|
|
KEPLER_COMPUTE_B = 0xB1C0,
|
2018-02-11 20:44:12 -08:00
|
|
|
KEPLER_INLINE_TO_MEMORY_B = 0xA140,
|
|
|
|
MAXWELL_DMA_COPY_A = 0xB0B5,
|
|
|
|
};
|
|
|
|
|
2019-03-03 20:54:16 -08:00
|
|
|
class MemoryManager;
|
|
|
|
|
2020-12-11 22:26:14 -08:00
|
|
|
class GPU final {
|
2018-02-11 20:44:12 -08:00
|
|
|
public:
|
2018-11-23 20:20:56 -08:00
|
|
|
struct MethodCall {
|
|
|
|
u32 method{};
|
|
|
|
u32 argument{};
|
|
|
|
u32 subchannel{};
|
|
|
|
u32 method_count{};
|
|
|
|
|
2020-12-04 11:39:12 -08:00
|
|
|
explicit MethodCall(u32 method_, u32 argument_, u32 subchannel_ = 0, u32 method_count_ = 0)
|
|
|
|
: method(method_), argument(argument_), subchannel(subchannel_),
|
|
|
|
method_count(method_count_) {}
|
2020-11-17 04:14:44 -08:00
|
|
|
|
|
|
|
[[nodiscard]] bool IsLastCall() const {
|
|
|
|
return method_count <= 1;
|
|
|
|
}
|
2018-11-23 20:20:56 -08:00
|
|
|
};
|
|
|
|
|
2021-09-30 21:57:02 -07:00
|
|
|
enum class FenceOperation : u32 {
|
|
|
|
Acquire = 0,
|
|
|
|
Increment = 1,
|
|
|
|
};
|
|
|
|
|
|
|
|
union FenceAction {
|
|
|
|
u32 raw;
|
|
|
|
BitField<0, 1, FenceOperation> op;
|
|
|
|
BitField<8, 24, u32> syncpoint_id;
|
|
|
|
};
|
|
|
|
|
|
|
|
explicit GPU(Core::System& system, bool is_async, bool use_nvdec);
|
2020-12-11 22:26:14 -08:00
|
|
|
~GPU();
|
2020-06-10 20:58:57 -07:00
|
|
|
|
|
|
|
/// Binds a renderer to the GPU.
|
|
|
|
void BindRenderer(std::unique_ptr<VideoCore::RendererBase> renderer);
|
|
|
|
|
2018-11-23 20:20:56 -08:00
|
|
|
/// Calls a GPU method.
|
|
|
|
void CallMethod(const MethodCall& method_call);
|
2018-02-11 20:44:12 -08:00
|
|
|
|
2020-04-19 23:16:56 -07:00
|
|
|
/// Calls a GPU multivalue method.
|
2020-04-20 10:42:14 -07:00
|
|
|
void CallMultiMethod(u32 method, u32 subchannel, const u32* base_start, u32 amount,
|
|
|
|
u32 methods_pending);
|
2020-04-19 23:16:56 -07:00
|
|
|
|
2020-04-16 09:29:53 -07:00
|
|
|
/// Flush all current written commands into the host GPU for execution.
|
2019-07-26 11:20:43 -07:00
|
|
|
void FlushCommands();
|
2020-04-16 09:29:53 -07:00
|
|
|
/// Synchronizes CPU writes with Host GPU memory.
|
2020-02-16 05:51:37 -08:00
|
|
|
void SyncGuestHost();
|
2020-04-16 09:29:53 -07:00
|
|
|
/// Signal the ending of command list.
|
2020-12-11 22:26:14 -08:00
|
|
|
void OnCommandListEnd();
|
2019-07-26 11:20:43 -07:00
|
|
|
|
2020-04-16 09:29:53 -07:00
|
|
|
/// Request a host GPU memory flush from the CPU.
|
2020-11-17 04:14:44 -08:00
|
|
|
[[nodiscard]] u64 RequestFlush(VAddr addr, std::size_t size);
|
2020-02-20 07:55:32 -08:00
|
|
|
|
2020-04-16 09:29:53 -07:00
|
|
|
/// Obtains current flush request fence id.
|
2021-09-30 21:57:02 -07:00
|
|
|
[[nodiscard]] u64 CurrentFlushRequestFence() const;
|
2020-02-20 07:55:32 -08:00
|
|
|
|
2020-04-16 09:29:53 -07:00
|
|
|
/// Tick pending requests within the GPU.
|
2020-02-20 07:55:32 -08:00
|
|
|
void TickWork();
|
|
|
|
|
2018-08-28 07:57:56 -07:00
|
|
|
/// Returns a reference to the Maxwell3D GPU engine.
|
2020-11-17 04:14:44 -08:00
|
|
|
[[nodiscard]] Engines::Maxwell3D& Maxwell3D();
|
2018-08-28 07:57:56 -07:00
|
|
|
|
2018-07-20 15:31:36 -07:00
|
|
|
/// Returns a const reference to the Maxwell3D GPU engine.
|
2020-11-17 04:14:44 -08:00
|
|
|
[[nodiscard]] const Engines::Maxwell3D& Maxwell3D() const;
|
2018-07-20 15:31:36 -07:00
|
|
|
|
2019-07-14 18:25:13 -07:00
|
|
|
/// Returns a reference to the KeplerCompute GPU engine.
|
2020-11-17 04:14:44 -08:00
|
|
|
[[nodiscard]] Engines::KeplerCompute& KeplerCompute();
|
2019-07-14 18:25:13 -07:00
|
|
|
|
|
|
|
/// Returns a reference to the KeplerCompute GPU engine.
|
2020-11-17 04:14:44 -08:00
|
|
|
[[nodiscard]] const Engines::KeplerCompute& KeplerCompute() const;
|
2019-07-14 18:25:13 -07:00
|
|
|
|
2018-08-28 07:57:56 -07:00
|
|
|
/// Returns a reference to the GPU memory manager.
|
2020-11-17 04:14:44 -08:00
|
|
|
[[nodiscard]] Tegra::MemoryManager& MemoryManager();
|
2018-03-22 13:19:35 -07:00
|
|
|
|
2018-08-28 07:57:56 -07:00
|
|
|
/// Returns a const reference to the GPU memory manager.
|
2020-11-17 04:14:44 -08:00
|
|
|
[[nodiscard]] const Tegra::MemoryManager& MemoryManager() const;
|
2018-02-11 20:44:12 -08:00
|
|
|
|
2018-11-23 20:20:56 -08:00
|
|
|
/// Returns a reference to the GPU DMA pusher.
|
2020-11-17 04:14:44 -08:00
|
|
|
[[nodiscard]] Tegra::DmaPusher& DmaPusher();
|
2018-11-23 20:20:56 -08:00
|
|
|
|
2020-10-26 20:07:36 -07:00
|
|
|
/// Returns a const reference to the GPU DMA pusher.
|
2020-11-17 04:14:44 -08:00
|
|
|
[[nodiscard]] const Tegra::DmaPusher& DmaPusher() const;
|
2020-10-26 20:07:36 -07:00
|
|
|
|
|
|
|
/// Returns a reference to the GPU CDMA pusher.
|
2020-11-17 04:14:44 -08:00
|
|
|
[[nodiscard]] Tegra::CDmaPusher& CDmaPusher();
|
2020-10-26 20:07:36 -07:00
|
|
|
|
|
|
|
/// Returns a const reference to the GPU CDMA pusher.
|
2020-11-17 04:14:44 -08:00
|
|
|
[[nodiscard]] const Tegra::CDmaPusher& CDmaPusher() const;
|
2020-10-26 20:07:36 -07:00
|
|
|
|
2020-11-17 04:14:44 -08:00
|
|
|
/// Returns a reference to the underlying renderer.
|
2021-09-30 21:57:02 -07:00
|
|
|
[[nodiscard]] VideoCore::RendererBase& Renderer();
|
2020-03-24 19:58:49 -07:00
|
|
|
|
2020-11-17 04:14:44 -08:00
|
|
|
/// Returns a const reference to the underlying renderer.
|
2021-09-30 21:57:02 -07:00
|
|
|
[[nodiscard]] const VideoCore::RendererBase& Renderer() const;
|
2020-03-24 19:58:49 -07:00
|
|
|
|
2020-11-17 04:14:44 -08:00
|
|
|
/// Returns a reference to the shader notifier.
|
2021-09-30 21:57:02 -07:00
|
|
|
[[nodiscard]] VideoCore::ShaderNotify& ShaderNotify();
|
2020-07-09 20:36:38 -07:00
|
|
|
|
2020-11-17 04:14:44 -08:00
|
|
|
/// Returns a const reference to the shader notifier.
|
2021-09-30 21:57:02 -07:00
|
|
|
[[nodiscard]] const VideoCore::ShaderNotify& ShaderNotify() const;
|
2020-07-09 20:36:38 -07:00
|
|
|
|
2019-09-25 16:43:23 -07:00
|
|
|
/// Allows the CPU/NvFlinger to wait on the GPU before presenting a frame.
|
2022-01-03 17:28:54 -08:00
|
|
|
void WaitFence(u32 syncpoint_id, u32 value);
|
2019-09-25 16:43:23 -07:00
|
|
|
|
2019-06-18 17:53:21 -07:00
|
|
|
void IncrementSyncPoint(u32 syncpoint_id);
|
2019-06-07 09:56:30 -07:00
|
|
|
|
2020-11-17 04:14:44 -08:00
|
|
|
[[nodiscard]] u32 GetSyncpointValue(u32 syncpoint_id) const;
|
2019-06-07 09:56:30 -07:00
|
|
|
|
2019-06-18 17:53:21 -07:00
|
|
|
void RegisterSyncptInterrupt(u32 syncpoint_id, u32 value);
|
2019-06-07 18:13:20 -07:00
|
|
|
|
2020-11-17 04:14:44 -08:00
|
|
|
[[nodiscard]] bool CancelSyncptInterrupt(u32 syncpoint_id, u32 value);
|
2019-06-07 09:56:30 -07:00
|
|
|
|
2020-11-17 04:14:44 -08:00
|
|
|
[[nodiscard]] u64 GetTicks() const;
|
2020-02-10 06:32:51 -08:00
|
|
|
|
2021-09-30 21:57:02 -07:00
|
|
|
[[nodiscard]] bool IsAsync() const;
|
2019-06-10 05:19:27 -07:00
|
|
|
|
2021-09-30 21:57:02 -07:00
|
|
|
[[nodiscard]] bool UseNvdec() const;
|
2018-11-23 20:20:56 -08:00
|
|
|
|
2021-05-15 17:34:20 -07:00
|
|
|
void RendererFrameEndNotify();
|
|
|
|
|
2019-04-09 11:02:00 -07:00
|
|
|
/// Performs any additional setup necessary in order to begin GPU emulation.
|
|
|
|
/// This can be used to launch any necessary threads and register any necessary
|
|
|
|
/// core timing events.
|
2020-12-11 22:26:14 -08:00
|
|
|
void Start();
|
2019-04-09 11:02:00 -07:00
|
|
|
|
2022-01-03 17:31:51 -08:00
|
|
|
/// Performs any additional necessary steps to shutdown GPU emulation.
|
|
|
|
void NotifyShutdown();
|
|
|
|
|
2020-04-03 08:58:43 -07:00
|
|
|
/// Obtain the CPU Context
|
2020-12-11 22:26:14 -08:00
|
|
|
void ObtainContext();
|
2020-04-03 08:58:43 -07:00
|
|
|
|
|
|
|
/// Release the CPU Context
|
2020-12-11 22:26:14 -08:00
|
|
|
void ReleaseContext();
|
2020-04-03 08:58:43 -07:00
|
|
|
|
2019-01-21 12:18:09 -08:00
|
|
|
/// Push GPU command entries to be processed
|
2020-12-11 22:26:14 -08:00
|
|
|
void PushGPUEntries(Tegra::CommandList&& entries);
|
2019-01-21 12:18:09 -08:00
|
|
|
|
2020-10-26 20:07:36 -07:00
|
|
|
/// Push GPU command buffer entries to be processed
|
2021-12-01 20:19:43 -08:00
|
|
|
void PushCommandBuffer(u32 id, Tegra::ChCommandHeaderList& entries);
|
2020-10-26 20:07:36 -07:00
|
|
|
|
2021-04-24 16:22:09 -07:00
|
|
|
/// Frees the CDMAPusher instance to free up resources
|
2021-12-01 20:19:43 -08:00
|
|
|
void ClearCdmaInstance(u32 id);
|
2021-03-30 02:37:40 -07:00
|
|
|
|
2019-01-21 12:18:09 -08:00
|
|
|
/// Swap buffers (render frame)
|
2020-12-11 22:26:14 -08:00
|
|
|
void SwapBuffers(const Tegra::FramebufferConfig* framebuffer);
|
2019-01-29 18:49:18 -08:00
|
|
|
|
2019-01-23 19:17:55 -08:00
|
|
|
/// Notify rasterizer that any caches of the specified region should be flushed to Switch memory
|
2020-12-11 22:26:14 -08:00
|
|
|
void FlushRegion(VAddr addr, u64 size);
|
2019-01-23 19:17:55 -08:00
|
|
|
|
|
|
|
/// Notify rasterizer that any caches of the specified region should be invalidated
|
2020-12-11 22:26:14 -08:00
|
|
|
void InvalidateRegion(VAddr addr, u64 size);
|
2019-01-23 19:17:55 -08:00
|
|
|
|
|
|
|
/// Notify rasterizer that any caches of the specified region should be flushed and invalidated
|
2020-12-11 22:26:14 -08:00
|
|
|
void FlushAndInvalidateRegion(VAddr addr, u64 size);
|
2019-01-23 19:17:55 -08:00
|
|
|
|
2019-02-08 20:21:53 -08:00
|
|
|
private:
|
2021-09-30 21:57:02 -07:00
|
|
|
struct Impl;
|
|
|
|
std::unique_ptr<Impl> impl;
|
2018-02-11 20:44:12 -08:00
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace Tegra
|