From 2003ccf09d0d542ef31821cff6cafd0b40cd2f23 Mon Sep 17 00:00:00 2001 From: bunnei Date: Mon, 21 Jul 2014 18:48:34 -0400 Subject: Qt: Removed unnecessary HW::Update. --- src/citra_qt/bootmanager.cpp | 1 - 1 file changed, 1 deletion(-) (limited to 'src') diff --git a/src/citra_qt/bootmanager.cpp b/src/citra_qt/bootmanager.cpp index 421b2af55..a162e6dfe 100644 --- a/src/citra_qt/bootmanager.cpp +++ b/src/citra_qt/bootmanager.cpp @@ -42,7 +42,6 @@ void EmuThread::run() emit CPUStepped(); } } - HW::Update(); } Core::Stop(); -- cgit v1.2.3 From 7a1f813be15aca815893139b1de125f4e3f47d84 Mon Sep 17 00:00:00 2001 From: bunnei Date: Mon, 21 Jul 2014 18:50:49 -0400 Subject: Kernel: Updated Event and Mutex to specify handle that they are blocking for. --- src/core/hle/kernel/event.cpp | 2 +- src/core/hle/kernel/mutex.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'src') diff --git a/src/core/hle/kernel/event.cpp b/src/core/hle/kernel/event.cpp index 127c0cfc6..1e417e09c 100644 --- a/src/core/hle/kernel/event.cpp +++ b/src/core/hle/kernel/event.cpp @@ -42,7 +42,7 @@ public: if (std::find(waiting_threads.begin(), waiting_threads.end(), thread) == waiting_threads.end()) { waiting_threads.push_back(thread); } - Kernel::WaitCurrentThread(WAITTYPE_EVENT); + Kernel::WaitCurrentThread(WAITTYPE_EVENT, GetHandle()); } if (reset_type != RESETTYPE_STICKY && !permanent_locked) { locked = true; diff --git a/src/core/hle/kernel/mutex.cpp b/src/core/hle/kernel/mutex.cpp index 1ccf1eb73..055f503f9 100644 --- a/src/core/hle/kernel/mutex.cpp +++ b/src/core/hle/kernel/mutex.cpp @@ -48,7 +48,7 @@ public: *wait = locked; if (locked) { - Kernel::WaitCurrentThread(WAITTYPE_MUTEX); + Kernel::WaitCurrentThread(WAITTYPE_MUTEX, GetHandle()); } return 0; -- cgit v1.2.3 From 4d4607041b2c595b635b78eab6d2e507b77bd2ca Mon Sep 17 00:00:00 2001 From: bunnei Date: Mon, 21 Jul 2014 19:20:33 -0400 Subject: SVC: Removed ArbitrateAddress log message that spams to much. --- src/core/hle/svc.cpp | 2 -- 1 file changed, 2 deletions(-) (limited to 'src') diff --git a/src/core/hle/svc.cpp b/src/core/hle/svc.cpp index 17967f260..328d048bd 100644 --- a/src/core/hle/svc.cpp +++ b/src/core/hle/svc.cpp @@ -185,8 +185,6 @@ Result CreateAddressArbiter(u32* arbiter) { /// Arbitrate address Result ArbitrateAddress(Handle arbiter, u32 address, u32 type, u32 value, s64 nanoseconds) { - DEBUG_LOG(SVC, "called arbiter=0x%08X, address=0x%08X, type=0x%08X, value=0x%08X, " - "nanoseconds=%d", arbiter, address, type, value, nanoseconds); return Kernel::ArbitrateAddress(arbiter, static_cast(type), address, value); } -- cgit v1.2.3 From 1b247b80312349fcc3790a6f0705f214ab999364 Mon Sep 17 00:00:00 2001 From: bunnei Date: Mon, 21 Jul 2014 21:25:35 -0400 Subject: SRV: Updated GetProcSemaphore to create an event instead of a mutex. --- src/core/hle/service/srv.cpp | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) (limited to 'src') diff --git a/src/core/hle/service/srv.cpp b/src/core/hle/service/srv.cpp index f45c0efc2..8f8413d02 100644 --- a/src/core/hle/service/srv.cpp +++ b/src/core/hle/service/srv.cpp @@ -5,28 +5,30 @@ #include "core/hle/hle.h" #include "core/hle/service/srv.h" #include "core/hle/service/service.h" -#include "core/hle/kernel/mutex.h" +#include "core/hle/kernel/event.h" //////////////////////////////////////////////////////////////////////////////////////////////////// // Namespace SRV namespace SRV { -Handle g_mutex = 0; +Handle g_event_handle = 0; void Initialize(Service::Interface* self) { DEBUG_LOG(OSHLE, "called"); - if (!g_mutex) { - g_mutex = Kernel::CreateMutex(true, "SRV:Lock"); - } } void GetProcSemaphore(Service::Interface* self) { DEBUG_LOG(OSHLE, "called"); - // Get process semaphore? + u32* cmd_buff = Service::GetCommandBuffer(); - cmd_buff[1] = 0; // No error - cmd_buff[3] = g_mutex; // Return something... 0 == nullptr, raises an exception + + // TODO(bunnei): Change to a semaphore once these have been implemented + g_event_handle = Kernel::CreateEvent(RESETTYPE_ONESHOT, "SRV:Event"); + Kernel::SetEventLocked(g_event_handle, false); + + cmd_buff[1] = 0; // No error + cmd_buff[3] = g_event_handle; } void GetServiceHandle(Service::Interface* self) { -- cgit v1.2.3 From 60078baab1e0efd508e2574fcd7f2970dd9d5fa1 Mon Sep 17 00:00:00 2001 From: bunnei Date: Mon, 21 Jul 2014 21:31:21 -0400 Subject: AddressArbiter: Fixed bug with break statements missing from case statements. --- src/core/hle/kernel/address_arbiter.cpp | 2 ++ 1 file changed, 2 insertions(+) (limited to 'src') diff --git a/src/core/hle/kernel/address_arbiter.cpp b/src/core/hle/kernel/address_arbiter.cpp index 61717bbe4..b5cb07f68 100644 --- a/src/core/hle/kernel/address_arbiter.cpp +++ b/src/core/hle/kernel/address_arbiter.cpp @@ -54,6 +54,7 @@ Result ArbitrateAddress(Handle handle, ArbitrationType type, u32 address, s32 va ArbitrateHighestPriorityThread(handle, address); } HLE::Reschedule(__func__); + break; // Wait current thread (acquire the arbiter)... case ArbitrationType::WaitIfLessThan: @@ -61,6 +62,7 @@ Result ArbitrateAddress(Handle handle, ArbitrationType type, u32 address, s32 va Kernel::WaitCurrentThread(WAITTYPE_ARB, handle); HLE::Reschedule(__func__); } + break; default: ERROR_LOG(KERNEL, "unknown type=%d", type); -- cgit v1.2.3 From 2542350b85d1a43d714528ba7ea87a6405ae30d4 Mon Sep 17 00:00:00 2001 From: bunnei Date: Mon, 21 Jul 2014 21:33:38 -0400 Subject: AddressArbiter: Removed unnecessary HLE::Reschedule. --- src/core/hle/kernel/address_arbiter.cpp | 1 - 1 file changed, 1 deletion(-) (limited to 'src') diff --git a/src/core/hle/kernel/address_arbiter.cpp b/src/core/hle/kernel/address_arbiter.cpp index b5cb07f68..bdf76e0c2 100644 --- a/src/core/hle/kernel/address_arbiter.cpp +++ b/src/core/hle/kernel/address_arbiter.cpp @@ -53,7 +53,6 @@ Result ArbitrateAddress(Handle handle, ArbitrationType type, u32 address, s32 va for(int i = 0; i < value; i++) ArbitrateHighestPriorityThread(handle, address); } - HLE::Reschedule(__func__); break; // Wait current thread (acquire the arbiter)... -- cgit v1.2.3 From c48ab0bd9e6ca20c3b83e64636d9e3bd9e306e94 Mon Sep 17 00:00:00 2001 From: bunnei Date: Tue, 22 Jul 2014 22:38:21 -0400 Subject: MemMap: Fixed typo with GetPointer to VRAM address. --- src/core/mem_map_funcs.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src') diff --git a/src/core/mem_map_funcs.cpp b/src/core/mem_map_funcs.cpp index 038d3bffa..305be8468 100644 --- a/src/core/mem_map_funcs.cpp +++ b/src/core/mem_map_funcs.cpp @@ -168,7 +168,7 @@ u8 *GetPointer(const u32 addr) { return g_system_mem + (vaddr & SYSTEM_MEMORY_MASK); // VRAM - } else if ((vaddr > VRAM_VADDR) && (vaddr < VRAM_VADDR_END)) { + } else if ((vaddr >= VRAM_VADDR) && (vaddr < VRAM_VADDR_END)) { return g_vram + (vaddr & VRAM_MASK); } else { -- cgit v1.2.3 From ec14ffe1cda04cd098ce07f3d3ad96c253e91eed Mon Sep 17 00:00:00 2001 From: bunnei Date: Tue, 22 Jul 2014 22:59:26 -0400 Subject: GSP: Implements preliminary command synchronization via GPU interrupts. Core: Added a comment to explain the logic for the RunLoop iterations. --- src/core/core.cpp | 20 ++++---- src/core/hle/service/gsp.cpp | 111 ++++++++++++++++++++++++++++++++++++------- src/core/hle/service/gsp.h | 16 +++++++ src/core/hw/gpu.cpp | 22 +++++++-- 4 files changed, 140 insertions(+), 29 deletions(-) (limited to 'src') diff --git a/src/core/core.cpp b/src/core/core.cpp index 7dc0809d0..fc9909377 100644 --- a/src/core/core.cpp +++ b/src/core/core.cpp @@ -26,21 +26,25 @@ ARM_Interface* g_sys_core = nullptr; ///< ARM11 system (OS) core /// Run the core CPU loop void RunLoop() { for (;;){ - g_app_core->Run(GPU::kFrameTicks); + // This function loops for 100 instructions in the CPU before trying to update hardware. + // This is a little bit faster than SingleStep, and should be pretty much equivalent. The + // number of instructions chosen is fairly arbitrary, however a large number will more + // drastically affect the frequency of GSP interrupts and likely break things. The point of + // this is to just loop in the CPU for more than 1 instruction to reduce overhead and make + // it a little bit faster... + g_app_core->Run(100); HW::Update(); - Kernel::Reschedule(); + if (HLE::g_reschedule) { + Kernel::Reschedule(); + } } } /// Step the CPU one instruction void SingleStep() { g_app_core->Step(); - - // Update and reschedule after approx. 1 frame - u64 current_ticks = Core::g_app_core->GetTicks(); - if ((current_ticks - g_last_ticks) >= GPU::kFrameTicks || HLE::g_reschedule) { - g_last_ticks = current_ticks; - HW::Update(); + HW::Update(); + if (HLE::g_reschedule) { Kernel::Reschedule(); } } diff --git a/src/core/hle/service/gsp.cpp b/src/core/hle/service/gsp.cpp index b20203e27..f3d9fd26d 100644 --- a/src/core/hle/service/gsp.cpp +++ b/src/core/hle/service/gsp.cpp @@ -21,6 +21,27 @@ // Main graphics debugger object - TODO: Here is probably not the best place for this GraphicsDebugger g_debugger; +/// GSP thread interrupt queue header +struct GX_InterruptQueue { + union { + u32 hex; + + // Index of last interrupt in the queue + BitField<0,8,u32> index; + + // Number of interrupts remaining to be processed by the userland code + BitField<8,8,u32> number_interrupts; + + // Error code - zero on success, otherwise an error has occurred + BitField<16,8,u32> error_code; + }; + + u32 unk0; + u32 unk1; + + GSP_GPU::GXInterruptId slot[0x34]; ///< Interrupt ID slots +}; + /// GSP shared memory GX command buffer header union GX_CmdBufferHeader { u32 hex; @@ -45,20 +66,28 @@ namespace GSP_GPU { Handle g_event = 0; Handle g_shared_memory = 0; -u32 g_thread_id = 0; +u32 g_thread_id = 1; /// Gets a pointer to the start (header) of a command buffer in GSP shared memory static inline u8* GX_GetCmdBufferPointer(u32 thread_id, u32 offset=0) { + if (0 == g_shared_memory) return nullptr; + return Kernel::GetSharedMemoryPointer(g_shared_memory, 0x800 + (thread_id * 0x200) + offset); } +/// Gets a pointer to the start (header) of a command buffer in GSP shared memory +static inline GX_InterruptQueue* GetInterruptQueue(u32 thread_id) { + return (GX_InterruptQueue*)Kernel::GetSharedMemoryPointer(g_shared_memory, sizeof(GX_InterruptQueue) * thread_id); +} + /// Finishes execution of a GSP command void GX_FinishCommand(u32 thread_id) { GX_CmdBufferHeader* header = (GX_CmdBufferHeader*)GX_GetCmdBufferPointer(thread_id); g_debugger.GXCommandProcessed(GX_GetCmdBufferPointer(thread_id, 0x20 + (header->index * 0x20))); - header->number_commands = header->number_commands - 1; + header->number_commands = 0; + // TODO: Increment header->index? } @@ -134,33 +163,55 @@ void RegisterInterruptRelayQueue(Service::Interface* self) { u32* cmd_buff = Service::GetCommandBuffer(); u32 flags = cmd_buff[1]; g_event = cmd_buff[3]; + g_shared_memory = Kernel::CreateSharedMemory("GSPSharedMem"); _assert_msg_(GSP, (g_event != 0), "handle is not valid!"); - Kernel::SetEventLocked(g_event, false); + cmd_buff[2] = g_thread_id++; // ThreadID + cmd_buff[4] = g_shared_memory; // GSP shared memory - // Hack - This function will permanently set the state of the GSP event such that GPU command - // synchronization barriers always passthrough. Correct solution would be to set this after the - // GPU as processed all queued up commands, but due to the emulator being single-threaded they - // will always be ready. - Kernel::SetPermanentLock(g_event, true); - - cmd_buff[0] = 0; // Result - no error - cmd_buff[2] = g_thread_id; // ThreadID - cmd_buff[4] = g_shared_memory; // GSP shared memory + Kernel::SignalEvent(GSP_GPU::g_event); // TODO(bunnei): Is this correct? } +/** + * Signals that the specified interrupt type has occurred to userland code + * @param interrupt_id ID of interrupt that is being signalled + */ +void SignalInterrupt(GXInterruptId interrupt_id) { + if (0 == GSP_GPU::g_event) { + WARN_LOG(GSP, "cannot synchronize until GSP event has been created!"); + return; + } + if (0 == g_shared_memory) { + WARN_LOG(GSP, "cannot synchronize until GSP shared memory has been created!"); + return; + } + for (int thread_id = 0; thread_id < 0x4; ++thread_id) { + GX_InterruptQueue* interrupt_queue = GetInterruptQueue(thread_id); + interrupt_queue->number_interrupts = interrupt_queue->number_interrupts + 1; + + u8 next = interrupt_queue->index; + next += interrupt_queue->number_interrupts; + next = next % 0x34; + + interrupt_queue->slot[next] = interrupt_id; + interrupt_queue->error_code = 0x0; // No error + } + Kernel::SignalEvent(GSP_GPU::g_event); +} -/// This triggers handling of the GX command written to the command buffer in shared memory. -void TriggerCmdReqQueue(Service::Interface* self) { +/// Executes the next GSP command +void ExecuteCommand(int thread_id, int command_index) { // Utility function to convert register ID to address auto WriteGPURegister = [](u32 id, u32 data) { GPU::Write(0x1EF00000 + 4 * id, data); }; - GX_CmdBufferHeader* header = (GX_CmdBufferHeader*)GX_GetCmdBufferPointer(g_thread_id); - auto& command = *(const GXCommand*)GX_GetCmdBufferPointer(g_thread_id, 0x20 + (header->index * 0x20)); + GX_CmdBufferHeader* header = (GX_CmdBufferHeader*)GX_GetCmdBufferPointer(thread_id); + auto& command = *(const GXCommand*)GX_GetCmdBufferPointer(thread_id, (command_index + 1) * 0x20); + + NOTICE_LOG(GSP, "decoding command 0x%08X", (int)command.id.Value()); switch (command.id) { @@ -186,6 +237,7 @@ void TriggerCmdReqQueue(Service::Interface* self) { g_debugger.CommandListCalled(params.address, (u32*)Memory::GetPointer(params.address), params.size); + SignalInterrupt(GXInterruptId::P3D); break; } @@ -208,6 +260,16 @@ void TriggerCmdReqQueue(Service::Interface* self) { // TODO: Check if texture copies are implemented correctly.. case GXCommandId::SET_DISPLAY_TRANSFER: + // TODO(bunnei): Signalling all of these interrupts here is totally wrong, but it seems to + // work well enough for running demos. Need to figure out how these all work and trigger + // them correctly. + SignalInterrupt(GXInterruptId::PSC0); + SignalInterrupt(GXInterruptId::PSC1); + SignalInterrupt(GXInterruptId::PPF); + SignalInterrupt(GXInterruptId::P3D); + SignalInterrupt(GXInterruptId::DMA); + break; + case GXCommandId::SET_TEXTURE_COPY: { auto& params = command.image_copy; @@ -233,8 +295,21 @@ void TriggerCmdReqQueue(Service::Interface* self) { default: ERROR_LOG(GSP, "unknown command 0x%08X", (int)command.id.Value()); } +} - GX_FinishCommand(g_thread_id); +/// This triggers handling of the GX command written to the command buffer in shared memory. +void TriggerCmdReqQueue(Service::Interface* self) { + // Iterate through each thread's command queue... + for (int thread_id = 0; thread_id < 0x4; ++thread_id) { + GX_CmdBufferHeader* header = (GX_CmdBufferHeader*)GX_GetCmdBufferPointer(thread_id); + + // Iterate through each command... + for (int command_index = 0; command_index < header->number_commands; ++command_index) { + ExecuteCommand(thread_id, command_index); + } + + GX_FinishCommand(thread_id); + } } const Interface::FunctionInfo FunctionTable[] = { @@ -275,7 +350,7 @@ const Interface::FunctionInfo FunctionTable[] = { Interface::Interface() { Register(FunctionTable, ARRAY_SIZE(FunctionTable)); - g_shared_memory = Kernel::CreateSharedMemory("GSPSharedMem"); + g_shared_memory = 0; } Interface::~Interface() { diff --git a/src/core/hle/service/gsp.h b/src/core/hle/service/gsp.h index a83cb4846..5a649d2df 100644 --- a/src/core/hle/service/gsp.h +++ b/src/core/hle/service/gsp.h @@ -29,6 +29,16 @@ enum class GXCommandId : u32 { SET_COMMAND_LIST_FIRST = 0x05, }; +enum class GXInterruptId : u8 { + PSC0 = 0x00, + PSC1 = 0x01, + PDC0 = 0x02, // Seems called every vertical screen line + PDC1 = 0x03, // Seems called every frame + PPF = 0x04, + P3D = 0x05, + DMA = 0x06, +}; + struct GXCommand { BitField<0, 8, GXCommandId> id; @@ -84,4 +94,10 @@ public: }; +/** + * Signals that the specified interrupt type has occurred to userland code + * @param interrupt_id ID of interrupt that is being signalled + */ +void SignalInterrupt(GXInterruptId interrupt_id); + } // namespace diff --git a/src/core/hw/gpu.cpp b/src/core/hw/gpu.cpp index c00be2a83..41976d989 100644 --- a/src/core/hw/gpu.cpp +++ b/src/core/hw/gpu.cpp @@ -7,7 +7,11 @@ #include "core/core.h" #include "core/mem_map.h" + +#include "core/hle/hle.h" #include "core/hle/kernel/thread.h" +#include "core/hle/service/gsp.h" + #include "core/hw/gpu.h" #include "video_core/video_core.h" @@ -17,7 +21,8 @@ namespace GPU { RegisterSet g_regs; -u64 g_last_ticks = 0; ///< Last CPU ticks +u32 g_cur_line = 0; ///< Current vertical screen line +u64 g_last_ticks = 0; ///< Last CPU ticks /** * Sets whether the framebuffers are in the GSP heap (FCRAM) or VRAM @@ -249,17 +254,28 @@ template void Write(u32 addr, const u8 data); void Update() { u64 current_ticks = Core::g_app_core->GetTicks(); - // Fake a vertical blank - if ((current_ticks - g_last_ticks) >= kFrameTicks) { + // Synchronize line... + if ((current_ticks - g_last_ticks) >= GPU::kFrameTicks / 400) { + GSP_GPU::SignalInterrupt(GSP_GPU::GXInterruptId::PDC0); + g_cur_line++; g_last_ticks = current_ticks; + } + + // Synchronize frame... + if (g_cur_line >= 400) { + g_cur_line = 0; + GSP_GPU::SignalInterrupt(GSP_GPU::GXInterruptId::PDC1); VideoCore::g_renderer->SwapBuffers(); Kernel::WaitCurrentThread(WAITTYPE_VBLANK); + HLE::Reschedule(__func__); } } /// Initialize hardware void Init() { + g_cur_line = 0; g_last_ticks = Core::g_app_core->GetTicks(); + // SetFramebufferLocation(FRAMEBUFFER_LOCATION_FCRAM); SetFramebufferLocation(FRAMEBUFFER_LOCATION_VRAM); -- cgit v1.2.3 From 99e404e2218e16925dda44bcae21bfb8cf2caf91 Mon Sep 17 00:00:00 2001 From: bunnei Date: Tue, 22 Jul 2014 23:10:02 -0400 Subject: GSP: Removed unnecessary GX_FinishCommand function. --- src/core/hle/service/gsp.cpp | 18 +++++------------- 1 file changed, 5 insertions(+), 13 deletions(-) (limited to 'src') diff --git a/src/core/hle/service/gsp.cpp b/src/core/hle/service/gsp.cpp index f3d9fd26d..bf85b1d86 100644 --- a/src/core/hle/service/gsp.cpp +++ b/src/core/hle/service/gsp.cpp @@ -80,17 +80,6 @@ static inline GX_InterruptQueue* GetInterruptQueue(u32 thread_id) { return (GX_InterruptQueue*)Kernel::GetSharedMemoryPointer(g_shared_memory, sizeof(GX_InterruptQueue) * thread_id); } -/// Finishes execution of a GSP command -void GX_FinishCommand(u32 thread_id) { - GX_CmdBufferHeader* header = (GX_CmdBufferHeader*)GX_GetCmdBufferPointer(thread_id); - - g_debugger.GXCommandProcessed(GX_GetCmdBufferPointer(thread_id, 0x20 + (header->index * 0x20))); - - header->number_commands = 0; - - // TODO: Increment header->index? -} - /// Write a GSP GPU hardware register void WriteHWRegs(Service::Interface* self) { u32* cmd_buff = Service::GetCommandBuffer(); @@ -211,6 +200,8 @@ void ExecuteCommand(int thread_id, int command_index) { GX_CmdBufferHeader* header = (GX_CmdBufferHeader*)GX_GetCmdBufferPointer(thread_id); auto& command = *(const GXCommand*)GX_GetCmdBufferPointer(thread_id, (command_index + 1) * 0x20); + g_debugger.GXCommandProcessed(GX_GetCmdBufferPointer(thread_id, 0x20 + (header->index * 0x20))); + NOTICE_LOG(GSP, "decoding command 0x%08X", (int)command.id.Value()); switch (command.id) { @@ -295,10 +286,13 @@ void ExecuteCommand(int thread_id, int command_index) { default: ERROR_LOG(GSP, "unknown command 0x%08X", (int)command.id.Value()); } + + header->number_commands = header->number_commands - 1; // Indicates that command has completed } /// This triggers handling of the GX command written to the command buffer in shared memory. void TriggerCmdReqQueue(Service::Interface* self) { + // Iterate through each thread's command queue... for (int thread_id = 0; thread_id < 0x4; ++thread_id) { GX_CmdBufferHeader* header = (GX_CmdBufferHeader*)GX_GetCmdBufferPointer(thread_id); @@ -307,8 +301,6 @@ void TriggerCmdReqQueue(Service::Interface* self) { for (int command_index = 0; command_index < header->number_commands; ++command_index) { ExecuteCommand(thread_id, command_index); } - - GX_FinishCommand(thread_id); } } -- cgit v1.2.3 From 4e9f305ed214ef0fbffd83042c86f41cd233ec3b Mon Sep 17 00:00:00 2001 From: bunnei Date: Tue, 22 Jul 2014 23:26:28 -0400 Subject: GSP: Removed dumb GX prefixes to functions/structs in GSP namespace. - Various other cleanups. --- src/citra_qt/debugger/graphics.cpp | 16 +++---- src/core/hle/service/gsp.cpp | 88 +++++++++++--------------------------- src/core/hle/service/gsp.h | 67 +++++++++++++++++++++++------ src/core/hw/gpu.cpp | 4 +- src/video_core/gpu_debugger.h | 12 +++--- 5 files changed, 94 insertions(+), 93 deletions(-) (limited to 'src') diff --git a/src/citra_qt/debugger/graphics.cpp b/src/citra_qt/debugger/graphics.cpp index 0f911a015..a86a55404 100644 --- a/src/citra_qt/debugger/graphics.cpp +++ b/src/citra_qt/debugger/graphics.cpp @@ -25,16 +25,16 @@ QVariant GPUCommandStreamItemModel::data(const QModelIndex& index, int role) con return QVariant(); int command_index = index.row(); - const GSP_GPU::GXCommand& command = GetDebugger()->ReadGXCommandHistory(command_index); + const GSP_GPU::Command& command = GetDebugger()->ReadGXCommandHistory(command_index); if (role == Qt::DisplayRole) { - std::map command_names = { - { GSP_GPU::GXCommandId::REQUEST_DMA, "REQUEST_DMA" }, - { GSP_GPU::GXCommandId::SET_COMMAND_LIST_FIRST, "SET_COMMAND_LIST_FIRST" }, - { GSP_GPU::GXCommandId::SET_MEMORY_FILL, "SET_MEMORY_FILL" }, - { GSP_GPU::GXCommandId::SET_DISPLAY_TRANSFER, "SET_DISPLAY_TRANSFER" }, - { GSP_GPU::GXCommandId::SET_TEXTURE_COPY, "SET_TEXTURE_COPY" }, - { GSP_GPU::GXCommandId::SET_COMMAND_LIST_LAST, "SET_COMMAND_LIST_LAST" } + std::map command_names = { + { GSP_GPU::CommandId::REQUEST_DMA, "REQUEST_DMA" }, + { GSP_GPU::CommandId::SET_COMMAND_LIST_FIRST, "SET_COMMAND_LIST_FIRST" }, + { GSP_GPU::CommandId::SET_MEMORY_FILL, "SET_MEMORY_FILL" }, + { GSP_GPU::CommandId::SET_DISPLAY_TRANSFER, "SET_DISPLAY_TRANSFER" }, + { GSP_GPU::CommandId::SET_TEXTURE_COPY, "SET_TEXTURE_COPY" }, + { GSP_GPU::CommandId::SET_COMMAND_LIST_LAST, "SET_COMMAND_LIST_LAST" } }; const u32* command_data = reinterpret_cast(&command); QString str = QString("%1 %2 %3 %4 %5 %6 %7 %8 %9").arg(command_names[command.id]) diff --git a/src/core/hle/service/gsp.cpp b/src/core/hle/service/gsp.cpp index bf85b1d86..8a3011e34 100644 --- a/src/core/hle/service/gsp.cpp +++ b/src/core/hle/service/gsp.cpp @@ -11,53 +11,13 @@ #include "core/hle/kernel/event.h" #include "core/hle/kernel/shared_memory.h" #include "core/hle/service/gsp.h" - #include "core/hw/gpu.h" #include "video_core/gpu_debugger.h" -//////////////////////////////////////////////////////////////////////////////////////////////////// - // Main graphics debugger object - TODO: Here is probably not the best place for this GraphicsDebugger g_debugger; -/// GSP thread interrupt queue header -struct GX_InterruptQueue { - union { - u32 hex; - - // Index of last interrupt in the queue - BitField<0,8,u32> index; - - // Number of interrupts remaining to be processed by the userland code - BitField<8,8,u32> number_interrupts; - - // Error code - zero on success, otherwise an error has occurred - BitField<16,8,u32> error_code; - }; - - u32 unk0; - u32 unk1; - - GSP_GPU::GXInterruptId slot[0x34]; ///< Interrupt ID slots -}; - -/// GSP shared memory GX command buffer header -union GX_CmdBufferHeader { - u32 hex; - - // Current command index. This index is updated by GSP module after loading the command data, - // right before the command is processed. When this index is updated by GSP module, the total - // commands field is decreased by one as well. - BitField<0,8,u32> index; - - // Total commands to process, must not be value 0 when GSP module handles commands. This must be - // <=15 when writing a command to shared memory. This is incremented by the application when - // writing a command to shared memory, after increasing this value TriggerCmdReqQueue is only - // used if this field is value 1. - BitField<8,8,u32> number_commands; -}; - //////////////////////////////////////////////////////////////////////////////////////////////////// // Namespace GSP_GPU @@ -69,15 +29,15 @@ Handle g_shared_memory = 0; u32 g_thread_id = 1; /// Gets a pointer to the start (header) of a command buffer in GSP shared memory -static inline u8* GX_GetCmdBufferPointer(u32 thread_id, u32 offset=0) { +static inline u8* GetCmdBufferPointer(u32 thread_id, u32 offset=0) { if (0 == g_shared_memory) return nullptr; return Kernel::GetSharedMemoryPointer(g_shared_memory, 0x800 + (thread_id * 0x200) + offset); } /// Gets a pointer to the start (header) of a command buffer in GSP shared memory -static inline GX_InterruptQueue* GetInterruptQueue(u32 thread_id) { - return (GX_InterruptQueue*)Kernel::GetSharedMemoryPointer(g_shared_memory, sizeof(GX_InterruptQueue) * thread_id); +static inline InterruptQueue* GetInterruptQueue(u32 thread_id) { + return (InterruptQueue*)Kernel::GetSharedMemoryPointer(g_shared_memory, sizeof(InterruptQueue) * thread_id); } /// Write a GSP GPU hardware register @@ -166,7 +126,7 @@ void RegisterInterruptRelayQueue(Service::Interface* self) { * Signals that the specified interrupt type has occurred to userland code * @param interrupt_id ID of interrupt that is being signalled */ -void SignalInterrupt(GXInterruptId interrupt_id) { +void SignalInterrupt(InterruptId interrupt_id) { if (0 == GSP_GPU::g_event) { WARN_LOG(GSP, "cannot synchronize until GSP event has been created!"); return; @@ -176,7 +136,7 @@ void SignalInterrupt(GXInterruptId interrupt_id) { return; } for (int thread_id = 0; thread_id < 0x4; ++thread_id) { - GX_InterruptQueue* interrupt_queue = GetInterruptQueue(thread_id); + InterruptQueue* interrupt_queue = GetInterruptQueue(thread_id); interrupt_queue->number_interrupts = interrupt_queue->number_interrupts + 1; u8 next = interrupt_queue->index; @@ -190,24 +150,24 @@ void SignalInterrupt(GXInterruptId interrupt_id) { } /// Executes the next GSP command -void ExecuteCommand(int thread_id, int command_index) { +void ExecuteCommand(u32 thread_id, u32 command_index) { // Utility function to convert register ID to address auto WriteGPURegister = [](u32 id, u32 data) { GPU::Write(0x1EF00000 + 4 * id, data); }; - GX_CmdBufferHeader* header = (GX_CmdBufferHeader*)GX_GetCmdBufferPointer(thread_id); - auto& command = *(const GXCommand*)GX_GetCmdBufferPointer(thread_id, (command_index + 1) * 0x20); + CmdBufferHeader* header = (CmdBufferHeader*)GetCmdBufferPointer(thread_id); + auto& command = *(const Command*)GetCmdBufferPointer(thread_id, (command_index + 1) * 0x20); - g_debugger.GXCommandProcessed(GX_GetCmdBufferPointer(thread_id, 0x20 + (header->index * 0x20))); + g_debugger.GXCommandProcessed(GetCmdBufferPointer(thread_id, 0x20 + (header->index * 0x20))); NOTICE_LOG(GSP, "decoding command 0x%08X", (int)command.id.Value()); switch (command.id) { // GX request DMA - typically used for copying memory from GSP heap to VRAM - case GXCommandId::REQUEST_DMA: + case CommandId::REQUEST_DMA: memcpy(Memory::GetPointer(command.dma_request.dest_address), Memory::GetPointer(command.dma_request.source_address), command.dma_request.size); @@ -216,7 +176,7 @@ void ExecuteCommand(int thread_id, int command_index) { // ctrulib homebrew sends all relevant command list data with this command, // hence we do all "interesting" stuff here and do nothing in SET_COMMAND_LIST_FIRST. // TODO: This will need some rework in the future. - case GXCommandId::SET_COMMAND_LIST_LAST: + case CommandId::SET_COMMAND_LIST_LAST: { auto& params = command.set_command_list_last; WriteGPURegister(GPU::Regs::CommandProcessor + 2, params.address >> 3); @@ -228,13 +188,13 @@ void ExecuteCommand(int thread_id, int command_index) { g_debugger.CommandListCalled(params.address, (u32*)Memory::GetPointer(params.address), params.size); - SignalInterrupt(GXInterruptId::P3D); + SignalInterrupt(InterruptId::P3D); break; } // It's assumed that the two "blocks" behave equivalently. // Presumably this is done simply to allow two memory fills to run in parallel. - case GXCommandId::SET_MEMORY_FILL: + case CommandId::SET_MEMORY_FILL: { auto& params = command.memory_fill; WriteGPURegister(GPU::Regs::MemoryFill, params.start1 >> 3); @@ -250,18 +210,18 @@ void ExecuteCommand(int thread_id, int command_index) { } // TODO: Check if texture copies are implemented correctly.. - case GXCommandId::SET_DISPLAY_TRANSFER: + case CommandId::SET_DISPLAY_TRANSFER: // TODO(bunnei): Signalling all of these interrupts here is totally wrong, but it seems to // work well enough for running demos. Need to figure out how these all work and trigger // them correctly. - SignalInterrupt(GXInterruptId::PSC0); - SignalInterrupt(GXInterruptId::PSC1); - SignalInterrupt(GXInterruptId::PPF); - SignalInterrupt(GXInterruptId::P3D); - SignalInterrupt(GXInterruptId::DMA); + SignalInterrupt(InterruptId::PSC0); + SignalInterrupt(InterruptId::PSC1); + SignalInterrupt(InterruptId::PPF); + SignalInterrupt(InterruptId::P3D); + SignalInterrupt(InterruptId::DMA); break; - case GXCommandId::SET_TEXTURE_COPY: + case CommandId::SET_TEXTURE_COPY: { auto& params = command.image_copy; WriteGPURegister(GPU::Regs::DisplayTransfer, params.in_buffer_address >> 3); @@ -278,7 +238,7 @@ void ExecuteCommand(int thread_id, int command_index) { // TODO: Figure out what exactly SET_COMMAND_LIST_FIRST and SET_COMMAND_LIST_LAST // are supposed to do. - case GXCommandId::SET_COMMAND_LIST_FIRST: + case CommandId::SET_COMMAND_LIST_FIRST: { break; } @@ -294,11 +254,11 @@ void ExecuteCommand(int thread_id, int command_index) { void TriggerCmdReqQueue(Service::Interface* self) { // Iterate through each thread's command queue... - for (int thread_id = 0; thread_id < 0x4; ++thread_id) { - GX_CmdBufferHeader* header = (GX_CmdBufferHeader*)GX_GetCmdBufferPointer(thread_id); + for (u32 thread_id = 0; thread_id < 0x4; ++thread_id) { + CmdBufferHeader* header = (CmdBufferHeader*)GetCmdBufferPointer(thread_id); // Iterate through each command... - for (int command_index = 0; command_index < header->number_commands; ++command_index) { + for (u32 command_index = 0; command_index < header->number_commands; ++command_index) { ExecuteCommand(thread_id, command_index); } } diff --git a/src/core/hle/service/gsp.h b/src/core/hle/service/gsp.h index 5a649d2df..66b99e94a 100644 --- a/src/core/hle/service/gsp.h +++ b/src/core/hle/service/gsp.h @@ -12,7 +12,19 @@ namespace GSP_GPU { -enum class GXCommandId : u32 { +/// GSP interrupt ID +enum class InterruptId : u8 { + PSC0 = 0x00, + PSC1 = 0x01, + PDC0 = 0x02, // Seems called every vertical screen line + PDC1 = 0x03, // Seems called every frame + PPF = 0x04, + P3D = 0x05, + DMA = 0x06, +}; + +/// GSP command ID +enum class CommandId : u32 { REQUEST_DMA = 0x00, SET_COMMAND_LIST_LAST = 0x01, @@ -29,18 +41,47 @@ enum class GXCommandId : u32 { SET_COMMAND_LIST_FIRST = 0x05, }; -enum class GXInterruptId : u8 { - PSC0 = 0x00, - PSC1 = 0x01, - PDC0 = 0x02, // Seems called every vertical screen line - PDC1 = 0x03, // Seems called every frame - PPF = 0x04, - P3D = 0x05, - DMA = 0x06, +/// GSP thread interrupt queue header +struct InterruptQueue { + union { + u32 hex; + + // Index of last interrupt in the queue + BitField<0,8,u32> index; + + // Number of interrupts remaining to be processed by the userland code + BitField<8,8,u32> number_interrupts; + + // Error code - zero on success, otherwise an error has occurred + BitField<16,8,u32> error_code; + }; + + u32 unk0; + u32 unk1; + + InterruptId slot[0x34]; ///< Interrupt ID slots +}; +static_assert(sizeof(InterruptQueue) == 0x40, "InterruptQueue struct has incorrect size"); + +/// GSP shared memory GX command buffer header +union CmdBufferHeader { + u32 hex; + + // Current command index. This index is updated by GSP module after loading the command data, + // right before the command is processed. When this index is updated by GSP module, the total + // commands field is decreased by one as well. + BitField<0,8,u32> index; + + // Total commands to process, must not be value 0 when GSP module handles commands. This must be + // <=15 when writing a command to shared memory. This is incremented by the application when + // writing a command to shared memory, after increasing this value TriggerCmdReqQueue is only + // used if this field is value 1. + BitField<8,8,u32> number_commands; }; -struct GXCommand { - BitField<0, 8, GXCommandId> id; +/// GSP command +struct Command { + BitField<0, 8, CommandId> id; union { struct { @@ -74,7 +115,7 @@ struct GXCommand { u8 raw_data[0x1C]; }; }; -static_assert(sizeof(GXCommand) == 0x20, "GXCommand struct has incorrect size"); +static_assert(sizeof(Command) == 0x20, "Command struct has incorrect size"); /// Interface to "srv:" service class Interface : public Service::Interface { @@ -98,6 +139,6 @@ public: * Signals that the specified interrupt type has occurred to userland code * @param interrupt_id ID of interrupt that is being signalled */ -void SignalInterrupt(GXInterruptId interrupt_id); +void SignalInterrupt(InterruptId interrupt_id); } // namespace diff --git a/src/core/hw/gpu.cpp b/src/core/hw/gpu.cpp index 41976d989..93b871470 100644 --- a/src/core/hw/gpu.cpp +++ b/src/core/hw/gpu.cpp @@ -256,7 +256,7 @@ void Update() { // Synchronize line... if ((current_ticks - g_last_ticks) >= GPU::kFrameTicks / 400) { - GSP_GPU::SignalInterrupt(GSP_GPU::GXInterruptId::PDC0); + GSP_GPU::SignalInterrupt(GSP_GPU::InterruptId::PDC0); g_cur_line++; g_last_ticks = current_ticks; } @@ -264,7 +264,7 @@ void Update() { // Synchronize frame... if (g_cur_line >= 400) { g_cur_line = 0; - GSP_GPU::SignalInterrupt(GSP_GPU::GXInterruptId::PDC1); + GSP_GPU::SignalInterrupt(GSP_GPU::InterruptId::PDC1); VideoCore::g_renderer->SwapBuffers(); Kernel::WaitCurrentThread(WAITTYPE_VBLANK); HLE::Reschedule(__func__); diff --git a/src/video_core/gpu_debugger.h b/src/video_core/gpu_debugger.h index d92ceaa72..5d85f90b9 100644 --- a/src/video_core/gpu_debugger.h +++ b/src/video_core/gpu_debugger.h @@ -49,7 +49,7 @@ public: */ virtual void GXCommandProcessed(int total_command_count) { - const GSP_GPU::GXCommand& cmd = observed->ReadGXCommandHistory(total_command_count-1); + const GSP_GPU::Command& cmd = observed->ReadGXCommandHistory(total_command_count-1); ERROR_LOG(GSP, "Received command: id=%x", (int)cmd.id.Value()); } @@ -81,10 +81,10 @@ public: if (observers.empty()) return; - gx_command_history.push_back(GSP_GPU::GXCommand()); - GSP_GPU::GXCommand& cmd = gx_command_history[gx_command_history.size()-1]; + gx_command_history.push_back(GSP_GPU::Command()); + GSP_GPU::Command& cmd = gx_command_history[gx_command_history.size()-1]; - memcpy(&cmd, command_data, sizeof(GSP_GPU::GXCommand)); + memcpy(&cmd, command_data, sizeof(GSP_GPU::Command)); ForEachObserver([this](DebuggerObserver* observer) { observer->GXCommandProcessed(this->gx_command_history.size()); @@ -123,7 +123,7 @@ public: } ); } - const GSP_GPU::GXCommand& ReadGXCommandHistory(int index) const + const GSP_GPU::Command& ReadGXCommandHistory(int index) const { // TODO: Is this thread-safe? return gx_command_history[index]; @@ -155,7 +155,7 @@ private: std::vector observers; - std::vector gx_command_history; + std::vector gx_command_history; // vector of pairs of command lists and their storage address std::vector> command_lists; -- cgit v1.2.3 From 36fd1c169e674619108e68c65e71acde636d0791 Mon Sep 17 00:00:00 2001 From: bunnei Date: Tue, 22 Jul 2014 23:36:50 -0400 Subject: GSP: Added reinitialization of other state objects. --- src/core/hle/service/gsp.cpp | 3 +++ 1 file changed, 3 insertions(+) (limited to 'src') diff --git a/src/core/hle/service/gsp.cpp b/src/core/hle/service/gsp.cpp index 8a3011e34..1b74f4889 100644 --- a/src/core/hle/service/gsp.cpp +++ b/src/core/hle/service/gsp.cpp @@ -302,7 +302,10 @@ const Interface::FunctionInfo FunctionTable[] = { Interface::Interface() { Register(FunctionTable, ARRAY_SIZE(FunctionTable)); + + g_event = 0; g_shared_memory = 0; + g_thread_id = 1; } Interface::~Interface() { -- cgit v1.2.3 From cad2f21985e2bfc7bed3dfa766bb3aa9ceba0d29 Mon Sep 17 00:00:00 2001 From: bunnei Date: Wed, 23 Jul 2014 00:10:37 -0400 Subject: GSP: Cleaned up command buffer decoding. GSP: Cleaned up code and added additional comments. GSP: Removed unnecessary TODO comment. GSP: Changed u32 iterators in TriggerCmdReqQueue to unsigned. --- src/core/hle/service/gsp.cpp | 84 ++++++++++++++++++++++---------------------- src/core/hle/service/gsp.h | 46 ++++++++++++++---------- 2 files changed, 69 insertions(+), 61 deletions(-) (limited to 'src') diff --git a/src/core/hle/service/gsp.cpp b/src/core/hle/service/gsp.cpp index 1b74f4889..e241b31c8 100644 --- a/src/core/hle/service/gsp.cpp +++ b/src/core/hle/service/gsp.cpp @@ -23,21 +23,23 @@ GraphicsDebugger g_debugger; namespace GSP_GPU { -Handle g_event = 0; -Handle g_shared_memory = 0; +Handle g_interrupt_event = 0; ///< Handle to event triggered when GSP interrupt has been signalled +Handle g_shared_memory = 0; ///< Handle to GSP shared memorys +u32 g_thread_id = 1; ///< Thread index into interrupt relay queue, 1 is arbitrary -u32 g_thread_id = 1; +/// Gets a pointer to a thread command buffer in GSP shared memory +static inline u8* GetCommandBuffer(u32 thread_id) { + if (0 == g_shared_memory) + return nullptr; -/// Gets a pointer to the start (header) of a command buffer in GSP shared memory -static inline u8* GetCmdBufferPointer(u32 thread_id, u32 offset=0) { - if (0 == g_shared_memory) return nullptr; - - return Kernel::GetSharedMemoryPointer(g_shared_memory, 0x800 + (thread_id * 0x200) + offset); + return Kernel::GetSharedMemoryPointer(g_shared_memory, + 0x800 + (thread_id * sizeof(CommandBuffer))); } -/// Gets a pointer to the start (header) of a command buffer in GSP shared memory -static inline InterruptQueue* GetInterruptQueue(u32 thread_id) { - return (InterruptQueue*)Kernel::GetSharedMemoryPointer(g_shared_memory, sizeof(InterruptQueue) * thread_id); +/// Gets a pointer to the interrupt relay queue for a given thread index +static inline InterruptRelayQueue* GetInterruptRelayQueue(u32 thread_id) { + return (InterruptRelayQueue*)Kernel::GetSharedMemoryPointer(g_shared_memory, + sizeof(InterruptRelayQueue) * thread_id); } /// Write a GSP GPU hardware register @@ -111,15 +113,15 @@ void ReadHWRegs(Service::Interface* self) { void RegisterInterruptRelayQueue(Service::Interface* self) { u32* cmd_buff = Service::GetCommandBuffer(); u32 flags = cmd_buff[1]; - g_event = cmd_buff[3]; + g_interrupt_event = cmd_buff[3]; g_shared_memory = Kernel::CreateSharedMemory("GSPSharedMem"); - _assert_msg_(GSP, (g_event != 0), "handle is not valid!"); + _assert_msg_(GSP, (g_interrupt_event != 0), "handle is not valid!"); cmd_buff[2] = g_thread_id++; // ThreadID cmd_buff[4] = g_shared_memory; // GSP shared memory - Kernel::SignalEvent(GSP_GPU::g_event); // TODO(bunnei): Is this correct? + Kernel::SignalEvent(g_interrupt_event); // TODO(bunnei): Is this correct? } /** @@ -127,7 +129,7 @@ void RegisterInterruptRelayQueue(Service::Interface* self) { * @param interrupt_id ID of interrupt that is being signalled */ void SignalInterrupt(InterruptId interrupt_id) { - if (0 == GSP_GPU::g_event) { + if (0 == g_interrupt_event) { WARN_LOG(GSP, "cannot synchronize until GSP event has been created!"); return; } @@ -136,34 +138,26 @@ void SignalInterrupt(InterruptId interrupt_id) { return; } for (int thread_id = 0; thread_id < 0x4; ++thread_id) { - InterruptQueue* interrupt_queue = GetInterruptQueue(thread_id); - interrupt_queue->number_interrupts = interrupt_queue->number_interrupts + 1; - - u8 next = interrupt_queue->index; - next += interrupt_queue->number_interrupts; - next = next % 0x34; - - interrupt_queue->slot[next] = interrupt_id; - interrupt_queue->error_code = 0x0; // No error + InterruptRelayQueue* interrupt_relay_queue = GetInterruptRelayQueue(thread_id); + interrupt_relay_queue->number_interrupts = interrupt_relay_queue->number_interrupts + 1; + + u8 next = interrupt_relay_queue->index; + next += interrupt_relay_queue->number_interrupts; + next = next % 0x34; // 0x34 is the number of interrupt slots + + interrupt_relay_queue->slot[next] = interrupt_id; + interrupt_relay_queue->error_code = 0x0; // No error } - Kernel::SignalEvent(GSP_GPU::g_event); + Kernel::SignalEvent(g_interrupt_event); } /// Executes the next GSP command -void ExecuteCommand(u32 thread_id, u32 command_index) { - +void ExecuteCommand(const Command& command) { // Utility function to convert register ID to address auto WriteGPURegister = [](u32 id, u32 data) { GPU::Write(0x1EF00000 + 4 * id, data); }; - CmdBufferHeader* header = (CmdBufferHeader*)GetCmdBufferPointer(thread_id); - auto& command = *(const Command*)GetCmdBufferPointer(thread_id, (command_index + 1) * 0x20); - - g_debugger.GXCommandProcessed(GetCmdBufferPointer(thread_id, 0x20 + (header->index * 0x20))); - - NOTICE_LOG(GSP, "decoding command 0x%08X", (int)command.id.Value()); - switch (command.id) { // GX request DMA - typically used for copying memory from GSP heap to VRAM @@ -181,7 +175,9 @@ void ExecuteCommand(u32 thread_id, u32 command_index) { auto& params = command.set_command_list_last; WriteGPURegister(GPU::Regs::CommandProcessor + 2, params.address >> 3); WriteGPURegister(GPU::Regs::CommandProcessor, params.size >> 3); - WriteGPURegister(GPU::Regs::CommandProcessor + 4, 1); // TODO: Not sure if we are supposed to always write this .. seems to trigger processing though + + // TODO: Not sure if we are supposed to always write this .. seems to trigger processing though + WriteGPURegister(GPU::Regs::CommandProcessor + 4, 1); // TODO: Move this to GPU // TODO: Not sure what units the size is measured in @@ -246,20 +242,24 @@ void ExecuteCommand(u32 thread_id, u32 command_index) { default: ERROR_LOG(GSP, "unknown command 0x%08X", (int)command.id.Value()); } - - header->number_commands = header->number_commands - 1; // Indicates that command has completed } /// This triggers handling of the GX command written to the command buffer in shared memory. void TriggerCmdReqQueue(Service::Interface* self) { // Iterate through each thread's command queue... - for (u32 thread_id = 0; thread_id < 0x4; ++thread_id) { - CmdBufferHeader* header = (CmdBufferHeader*)GetCmdBufferPointer(thread_id); + for (unsigned thread_id = 0; thread_id < 0x4; ++thread_id) { + CommandBuffer* command_buffer = (CommandBuffer*)GetCommandBuffer(thread_id); // Iterate through each command... - for (u32 command_index = 0; command_index < header->number_commands; ++command_index) { - ExecuteCommand(thread_id, command_index); + for (unsigned i = 0; i < command_buffer->number_commands; ++i) { + g_debugger.GXCommandProcessed((u8*)&command_buffer->commands[i]); + + // Decode and execute command + ExecuteCommand(command_buffer->commands[i]); + + // Indicates that command has completed + command_buffer->number_commands = command_buffer->number_commands - 1; } } } @@ -303,7 +303,7 @@ const Interface::FunctionInfo FunctionTable[] = { Interface::Interface() { Register(FunctionTable, ARRAY_SIZE(FunctionTable)); - g_event = 0; + g_interrupt_event = 0; g_shared_memory = 0; g_thread_id = 1; } diff --git a/src/core/hle/service/gsp.h b/src/core/hle/service/gsp.h index 66b99e94a..fccebef7e 100644 --- a/src/core/hle/service/gsp.h +++ b/src/core/hle/service/gsp.h @@ -41,8 +41,8 @@ enum class CommandId : u32 { SET_COMMAND_LIST_FIRST = 0x05, }; -/// GSP thread interrupt queue header -struct InterruptQueue { +/// GSP thread interrupt relay queue +struct InterruptRelayQueue { union { u32 hex; @@ -61,23 +61,8 @@ struct InterruptQueue { InterruptId slot[0x34]; ///< Interrupt ID slots }; -static_assert(sizeof(InterruptQueue) == 0x40, "InterruptQueue struct has incorrect size"); - -/// GSP shared memory GX command buffer header -union CmdBufferHeader { - u32 hex; - - // Current command index. This index is updated by GSP module after loading the command data, - // right before the command is processed. When this index is updated by GSP module, the total - // commands field is decreased by one as well. - BitField<0,8,u32> index; - - // Total commands to process, must not be value 0 when GSP module handles commands. This must be - // <=15 when writing a command to shared memory. This is incremented by the application when - // writing a command to shared memory, after increasing this value TriggerCmdReqQueue is only - // used if this field is value 1. - BitField<8,8,u32> number_commands; -}; +static_assert(sizeof(InterruptRelayQueue) == 0x40, + "InterruptRelayQueue struct has incorrect size"); /// GSP command struct Command { @@ -117,6 +102,29 @@ struct Command { }; static_assert(sizeof(Command) == 0x20, "Command struct has incorrect size"); +/// GSP shared memory GX command buffer header +struct CommandBuffer { + union { + u32 hex; + + // Current command index. This index is updated by GSP module after loading the command + // data, right before the command is processed. When this index is updated by GSP module, + // the total commands field is decreased by one as well. + BitField<0,8,u32> index; + + // Total commands to process, must not be value 0 when GSP module handles commands. This + // must be <=15 when writing a command to shared memory. This is incremented by the + // application when writing a command to shared memory, after increasing this value + // TriggerCmdReqQueue is only used if this field is value 1. + BitField<8,8,u32> number_commands; + }; + + u32 unk[7]; + + Command commands[0xF]; +}; +static_assert(sizeof(CommandBuffer) == 0x200, "CommandBuffer struct has incorrect size"); + /// Interface to "srv:" service class Interface : public Service::Interface { public: -- cgit v1.2.3 From d4bd2f2e5d38c865777800271a1bbb836034d41b Mon Sep 17 00:00:00 2001 From: bunnei Date: Tue, 5 Aug 2014 22:32:13 -0400 Subject: Thread: Added more descriptive comment to WaitCurrentThread. --- src/core/hle/kernel/thread.cpp | 6 +++++- src/core/hle/kernel/thread.h | 6 +++++- 2 files changed, 10 insertions(+), 2 deletions(-) (limited to 'src') diff --git a/src/core/hle/kernel/thread.cpp b/src/core/hle/kernel/thread.cpp index 86bbf29d0..1d7ded6f6 100644 --- a/src/core/hle/kernel/thread.cpp +++ b/src/core/hle/kernel/thread.cpp @@ -274,7 +274,11 @@ Thread* NextThread() { return Kernel::g_object_pool.GetFast(next); } -/// Puts the current thread in the wait state for the given type +/** + * Puts the current thread in the wait state for the given type + * @param wait_type Type of wait + * @param wait_handle Handle of Kernel object that we are waiting on, defaults to current thread + */ void WaitCurrentThread(WaitType wait_type, Handle wait_handle) { Thread* thread = GetCurrentThread(); thread->wait_type = wait_type; diff --git a/src/core/hle/kernel/thread.h b/src/core/hle/kernel/thread.h index f2bfdfa1a..39fa38b75 100644 --- a/src/core/hle/kernel/thread.h +++ b/src/core/hle/kernel/thread.h @@ -69,7 +69,11 @@ void ArbitrateAllThreads(u32 arbiter, u32 address); /// Gets the current thread handle Handle GetCurrentThreadHandle(); -/// Puts the current thread in the wait state for the given type +/** + * Puts the current thread in the wait state for the given type + * @param wait_type Type of wait + * @param wait_handle Handle of Kernel object that we are waiting on, defaults to current thread + */ void WaitCurrentThread(WaitType wait_type, Handle wait_handle=GetCurrentThreadHandle()); /// Put current thread in a wait state - on WaitSynchronization -- cgit v1.2.3 From 7ada2625fe78b7bb75232282ead77786ca215d6e Mon Sep 17 00:00:00 2001 From: bunnei Date: Tue, 5 Aug 2014 23:29:38 -0400 Subject: GPU: Updated horizontal sync line counter to use framebuffer height. --- src/core/hw/gpu.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'src') diff --git a/src/core/hw/gpu.cpp b/src/core/hw/gpu.cpp index 93b871470..7fb208e57 100644 --- a/src/core/hw/gpu.cpp +++ b/src/core/hw/gpu.cpp @@ -252,17 +252,18 @@ template void Write(u32 addr, const u8 data); /// Update hardware void Update() { + auto& framebuffer_top = g_regs.Get(); u64 current_ticks = Core::g_app_core->GetTicks(); // Synchronize line... - if ((current_ticks - g_last_ticks) >= GPU::kFrameTicks / 400) { + if ((current_ticks - g_last_ticks) >= GPU::kFrameTicks / framebuffer_top.height) { GSP_GPU::SignalInterrupt(GSP_GPU::InterruptId::PDC0); g_cur_line++; g_last_ticks = current_ticks; } // Synchronize frame... - if (g_cur_line >= 400) { + if (g_cur_line >= framebuffer_top.height) { g_cur_line = 0; GSP_GPU::SignalInterrupt(GSP_GPU::InterruptId::PDC1); VideoCore::g_renderer->SwapBuffers(); -- cgit v1.2.3 From 0805ecbaca70159ccc3d43c643b4ade7168795bc Mon Sep 17 00:00:00 2001 From: bunnei Date: Tue, 5 Aug 2014 23:33:26 -0400 Subject: GPU: Updated g_last_ticks variable to be more descriptive (represents CPU tick count of last vertical line). --- src/core/hw/gpu.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'src') diff --git a/src/core/hw/gpu.cpp b/src/core/hw/gpu.cpp index 7fb208e57..d94c2329b 100644 --- a/src/core/hw/gpu.cpp +++ b/src/core/hw/gpu.cpp @@ -21,8 +21,8 @@ namespace GPU { RegisterSet g_regs; -u32 g_cur_line = 0; ///< Current vertical screen line -u64 g_last_ticks = 0; ///< Last CPU ticks +u32 g_cur_line = 0; ///< Current vertical screen line +u64 g_last_line_ticks = 0; ///< CPU tick count from last vertical screen line /** * Sets whether the framebuffers are in the GSP heap (FCRAM) or VRAM @@ -256,10 +256,10 @@ void Update() { u64 current_ticks = Core::g_app_core->GetTicks(); // Synchronize line... - if ((current_ticks - g_last_ticks) >= GPU::kFrameTicks / framebuffer_top.height) { + if ((current_ticks - g_last_line_ticks) >= GPU::kFrameTicks / framebuffer_top.height) { GSP_GPU::SignalInterrupt(GSP_GPU::InterruptId::PDC0); g_cur_line++; - g_last_ticks = current_ticks; + g_last_line_ticks = current_ticks; } // Synchronize frame... @@ -275,7 +275,7 @@ void Update() { /// Initialize hardware void Init() { g_cur_line = 0; - g_last_ticks = Core::g_app_core->GetTicks(); + g_last_line_ticks = Core::g_app_core->GetTicks(); // SetFramebufferLocation(FRAMEBUFFER_LOCATION_FCRAM); SetFramebufferLocation(FRAMEBUFFER_LOCATION_VRAM); -- cgit v1.2.3