kmather73
330 lines
11 KiB
C++
330 lines
11 KiB
C++
// Copyright 2018 yuzu Emulator Project
|
|
// Licensed under GPLv2 or any later version
|
|
// Refer to the license.txt file included.
|
|
|
|
#include "common/assert.h"
|
|
#include "core/core_timing.h"
|
|
#include "core/memory.h"
|
|
#include "video_core/engines/fermi_2d.h"
|
|
#include "video_core/engines/kepler_memory.h"
|
|
#include "video_core/engines/maxwell_3d.h"
|
|
#include "video_core/engines/maxwell_compute.h"
|
|
#include "video_core/engines/maxwell_dma.h"
|
|
#include "video_core/gpu.h"
|
|
#include "video_core/rasterizer_interface.h"
|
|
|
|
namespace Tegra {
|
|
|
|
u32 FramebufferConfig::BytesPerPixel(PixelFormat format) {
|
|
switch (format) {
|
|
case PixelFormat::ABGR8:
|
|
return 4;
|
|
default:
|
|
return 4;
|
|
}
|
|
|
|
UNREACHABLE();
|
|
}
|
|
|
|
GPU::GPU(VideoCore::RasterizerInterface& rasterizer) {
|
|
memory_manager = std::make_unique<Tegra::MemoryManager>();
|
|
dma_pusher = std::make_unique<Tegra::DmaPusher>(*this);
|
|
maxwell_3d = std::make_unique<Engines::Maxwell3D>(rasterizer, *memory_manager);
|
|
fermi_2d = std::make_unique<Engines::Fermi2D>(rasterizer, *memory_manager);
|
|
maxwell_compute = std::make_unique<Engines::MaxwellCompute>();
|
|
maxwell_dma = std::make_unique<Engines::MaxwellDMA>(rasterizer, *memory_manager);
|
|
kepler_memory = std::make_unique<Engines::KeplerMemory>(rasterizer, *memory_manager);
|
|
}
|
|
|
|
GPU::~GPU() = default;
|
|
|
|
Engines::Maxwell3D& GPU::Maxwell3D() {
|
|
return *maxwell_3d;
|
|
}
|
|
|
|
const Engines::Maxwell3D& GPU::Maxwell3D() const {
|
|
return *maxwell_3d;
|
|
}
|
|
|
|
MemoryManager& GPU::MemoryManager() {
|
|
return *memory_manager;
|
|
}
|
|
|
|
const MemoryManager& GPU::MemoryManager() const {
|
|
return *memory_manager;
|
|
}
|
|
|
|
DmaPusher& GPU::DmaPusher() {
|
|
return *dma_pusher;
|
|
}
|
|
|
|
const DmaPusher& GPU::DmaPusher() const {
|
|
return *dma_pusher;
|
|
}
|
|
|
|
u32 RenderTargetBytesPerPixel(RenderTargetFormat format) {
|
|
ASSERT(format != RenderTargetFormat::NONE);
|
|
|
|
switch (format) {
|
|
case RenderTargetFormat::RGBA32_FLOAT:
|
|
case RenderTargetFormat::RGBA32_UINT:
|
|
return 16;
|
|
case RenderTargetFormat::RGBA16_UINT:
|
|
case RenderTargetFormat::RGBA16_UNORM:
|
|
case RenderTargetFormat::RGBA16_FLOAT:
|
|
case RenderTargetFormat::RG32_FLOAT:
|
|
case RenderTargetFormat::RG32_UINT:
|
|
return 8;
|
|
case RenderTargetFormat::RGBA8_UNORM:
|
|
case RenderTargetFormat::RGBA8_SNORM:
|
|
case RenderTargetFormat::RGBA8_SRGB:
|
|
case RenderTargetFormat::RGBA8_UINT:
|
|
case RenderTargetFormat::RGB10_A2_UNORM:
|
|
case RenderTargetFormat::BGRA8_UNORM:
|
|
case RenderTargetFormat::BGRA8_SRGB:
|
|
case RenderTargetFormat::RG16_UNORM:
|
|
case RenderTargetFormat::RG16_SNORM:
|
|
case RenderTargetFormat::RG16_UINT:
|
|
case RenderTargetFormat::RG16_SINT:
|
|
case RenderTargetFormat::RG16_FLOAT:
|
|
case RenderTargetFormat::R32_FLOAT:
|
|
case RenderTargetFormat::R11G11B10_FLOAT:
|
|
case RenderTargetFormat::R32_UINT:
|
|
return 4;
|
|
case RenderTargetFormat::R16_UNORM:
|
|
case RenderTargetFormat::R16_SNORM:
|
|
case RenderTargetFormat::R16_UINT:
|
|
case RenderTargetFormat::R16_SINT:
|
|
case RenderTargetFormat::R16_FLOAT:
|
|
case RenderTargetFormat::RG8_UNORM:
|
|
case RenderTargetFormat::RG8_SNORM:
|
|
return 2;
|
|
case RenderTargetFormat::R8_UNORM:
|
|
case RenderTargetFormat::R8_UINT:
|
|
return 1;
|
|
default:
|
|
UNIMPLEMENTED_MSG("Unimplemented render target format {}", static_cast<u32>(format));
|
|
}
|
|
}
|
|
|
|
u32 DepthFormatBytesPerPixel(DepthFormat format) {
|
|
switch (format) {
|
|
case DepthFormat::Z32_S8_X24_FLOAT:
|
|
return 8;
|
|
case DepthFormat::Z32_FLOAT:
|
|
case DepthFormat::S8_Z24_UNORM:
|
|
case DepthFormat::Z24_X8_UNORM:
|
|
case DepthFormat::Z24_S8_UNORM:
|
|
case DepthFormat::Z24_C8_UNORM:
|
|
return 4;
|
|
case DepthFormat::Z16_UNORM:
|
|
return 2;
|
|
default:
|
|
UNIMPLEMENTED_MSG("Unimplemented Depth format {}", static_cast<u32>(format));
|
|
}
|
|
}
|
|
|
|
enum class BufferMethods {
|
|
BIND_OBJECT = 0x0,
|
|
NOP = 0x8,
|
|
SEMAPHORE_ADDRESS_HIGH = 0x10,
|
|
SEMAPHORE_ADDRESS_LOW = 0x14,
|
|
SEMAPHORE_SEQUENCE = 0x18,
|
|
SEMAPHORE_TRIGGER = 0x1C,
|
|
NOTIFY_INTR = 0x20,
|
|
WRCACHE_FLUSH = 0x24,
|
|
UNK28 = 0x28,
|
|
UNK2C = 0x2C,
|
|
REF_CNT = 0x50,
|
|
SEMAPHORE_ACQUIRE = 0x68,
|
|
SEMAPHORE_RELEASE = 0x6C,
|
|
UNK70 = 0x70,
|
|
UNK74 = 0x74,
|
|
UNK78 = 0x78,
|
|
UNK7C = 0x7C,
|
|
YEILD = 0x80,
|
|
NONPULLERMETHODS = 0x100,
|
|
};
|
|
|
|
enum class GpuSemaphoreOperation {
|
|
ACQUIRE_EQUAL = 0x1,
|
|
WRITE_LONG = 0x2,
|
|
ACQUIRE_GEQUAL = 0x4,
|
|
ACQUIRE_MASK = 0x8,
|
|
};
|
|
|
|
void GPU::CallMethod(const MethodCall& method_call) {
|
|
LOG_TRACE(HW_GPU, "Processing method {:08X} on subchannel {}", method_call.method,
|
|
method_call.subchannel);
|
|
|
|
ASSERT(method_call.subchannel < bound_engines.size());
|
|
|
|
// Note that, traditionally, methods are treated as 4-byte addressable locations, and hence
|
|
// their numbers are written down multiplied by 4 in Docs. Hence why we multiply by 4 here.
|
|
BufferMethods method = static_cast<BufferMethods>(method_call.method * 4);
|
|
if (method < BufferMethods::NONPULLERMETHODS)
|
|
{
|
|
switch (method) {
|
|
case BufferMethods::BIND_OBJECT:
|
|
{
|
|
// Bind the current subchannel to the desired engine id.
|
|
LOG_DEBUG(HW_GPU, "Binding subchannel {} to engine {}", method_call.subchannel,method_call.argument);
|
|
bound_engines[method_call.subchannel] = static_cast<EngineID>(method_call.argument);
|
|
break;
|
|
}
|
|
case BufferMethods::NOP:
|
|
break;
|
|
case BufferMethods::SEMAPHORE_ADDRESS_HIGH:
|
|
{
|
|
if (method_call.argument & 0xffffff00)
|
|
{
|
|
LOG_ERROR(HW_GPU, "SEMAPHORE_ADDRESS_HIGH too large");
|
|
return;
|
|
}
|
|
semaphore_addr.high.Assign(method_call.argument);
|
|
break;
|
|
}
|
|
case BufferMethods::SEMAPHORE_ADDRESS_LOW:
|
|
{
|
|
if (method_call.argument & 3)
|
|
{
|
|
LOG_ERROR(HW_GPU, "SEMAPHORE_ADDRESS_LOW unaligned");
|
|
return;
|
|
}
|
|
semaphore_addr.low.Assign(method_call.argument);
|
|
break;
|
|
}
|
|
case BufferMethods::SEMAPHORE_SEQUENCE:
|
|
{
|
|
semaphore_sequence = method_call.argument;
|
|
break;
|
|
}
|
|
case BufferMethods::SEMAPHORE_TRIGGER:
|
|
{
|
|
GpuSemaphoreOperation op = static_cast<GpuSemaphoreOperation>(method_call.argument & 7);
|
|
// TODO(Kmather73): Generate a real GPU timestamp and write it here instead of CoreTiming
|
|
u64 acquire_timestamp = CoreTiming::GetTicks();
|
|
if (method_call.argument == 2)
|
|
{
|
|
Memory::Write32(semaphore_addr.addr, method_call.argument);
|
|
Memory::Write32(semaphore_addr.addr + 0x4, 0);
|
|
Memory::Write64(semaphore_addr.addr + 0x8, acquire_timestamp);
|
|
}
|
|
else
|
|
{
|
|
u32 word = Memory::Read32(semaphore_addr.addr);
|
|
if ((op == GpuSemaphoreOperation::ACQUIRE_EQUAL && word == semaphore_sequence)
|
|
|| (op == GpuSemaphoreOperation::ACQUIRE_GEQUAL && (s32)(word - semaphore_sequence) > 0)
|
|
|| (op == GpuSemaphoreOperation::ACQUIRE_MASK && (word & semaphore_sequence)))
|
|
{
|
|
// Nothing to do in this case
|
|
}
|
|
else
|
|
{
|
|
acquire_source = true;
|
|
acquire_value = semaphore_sequence;
|
|
if (op == GpuSemaphoreOperation::ACQUIRE_EQUAL)
|
|
{
|
|
acquire_active = true;
|
|
acquire_mode = false;
|
|
}
|
|
else if (op == GpuSemaphoreOperation::ACQUIRE_GEQUAL)
|
|
{
|
|
acquire_active = true;
|
|
acquire_mode = true;
|
|
}
|
|
else
|
|
{
|
|
LOG_ERROR(HW_GPU, "Invalid semaphore operation");
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case BufferMethods::NOTIFY_INTR:
|
|
{
|
|
// TODO(Kmather73): Research and implement this method.
|
|
LOG_ERROR(HW_GPU, "Special puller engine method NOTIFY_INTR not implemented");
|
|
break;
|
|
}
|
|
case BufferMethods::WRCACHE_FLUSH:
|
|
{
|
|
// TODO(Kmather73): Research and implement this method.
|
|
LOG_ERROR(HW_GPU, "Special puller engine method WRCACHE_FLUSH not implemented");
|
|
break;
|
|
}
|
|
case BufferMethods::UNK28: {
|
|
// TODO(Kmather73): Research and implement this method.
|
|
LOG_ERROR(HW_GPU, "Special puller engine method UNK28 not implemented");
|
|
break;
|
|
}
|
|
case BufferMethods::UNK2C:
|
|
{
|
|
// TODO(Kmather73): Research and implement this method.
|
|
LOG_ERROR(HW_GPU, "Special puller engine method UNK2C not implemented");
|
|
break;
|
|
}
|
|
case BufferMethods::SEMAPHORE_ACQUIRE:
|
|
{
|
|
if (!semaphore_off_val)
|
|
{
|
|
LOG_ERROR(HW_GPU, "Semaphore has already be acquired");
|
|
return;
|
|
}
|
|
u32 word = Memory::Read32(semaphore_addr.addr);
|
|
if (word != method_call.argument)
|
|
{
|
|
acquire_active = true;
|
|
acquire_value = method_call.argument;
|
|
acquire_mode = false;
|
|
acquire_source = false;
|
|
}
|
|
break;
|
|
}
|
|
case BufferMethods::SEMAPHORE_RELEASE:
|
|
{
|
|
if (!semaphore_off_val)
|
|
{
|
|
LOG_ERROR(HW_GPU, "Semaphore can't be released since it is not currently been acquired");
|
|
return;
|
|
}
|
|
Memory::Write32(semaphore_addr.addr, method_call.method);
|
|
break;
|
|
}
|
|
case BufferMethods::YEILD:
|
|
{
|
|
// TODO(Kmather73): Research and implement this method.
|
|
LOG_ERROR(HW_GPU, "Special puller engine method YEILD not implemented");
|
|
break;
|
|
}
|
|
default:
|
|
LOG_ERROR(HW_GPU, "Special puller engine method {:X} not implemented", static_cast<u32>(method));
|
|
}
|
|
return;
|
|
}
|
|
|
|
const EngineID engine = bound_engines[method_call.subchannel];
|
|
|
|
switch (engine) {
|
|
case EngineID::FERMI_TWOD_A:
|
|
fermi_2d->CallMethod(method_call);
|
|
break;
|
|
case EngineID::MAXWELL_B:
|
|
maxwell_3d->CallMethod(method_call);
|
|
break;
|
|
case EngineID::MAXWELL_COMPUTE_B:
|
|
maxwell_compute->CallMethod(method_call);
|
|
break;
|
|
case EngineID::MAXWELL_DMA_COPY_A:
|
|
maxwell_dma->CallMethod(method_call);
|
|
break;
|
|
case EngineID::KEPLER_INLINE_TO_MEMORY_B:
|
|
kepler_memory->CallMethod(method_call);
|
|
break;
|
|
default:
|
|
UNIMPLEMENTED_MSG("Unimplemented engine");
|
|
}
|
|
}
|
|
|
|
} // namespace Tegra
|