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/hle/service/gsp.cpp | 111 ++++++++++++++++++++++++++++++++++++------- 1 file changed, 93 insertions(+), 18 deletions(-) (limited to 'src/core/hle/service/gsp.cpp') 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() { -- 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/core/hle/service/gsp.cpp') 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/core/hle/service/gsp.cpp | 88 ++++++++++++-------------------------------- 1 file changed, 24 insertions(+), 64 deletions(-) (limited to 'src/core/hle/service/gsp.cpp') 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); } } -- 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/core/hle/service/gsp.cpp') 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 ++++++++++++++++++++++---------------------- 1 file changed, 42 insertions(+), 42 deletions(-) (limited to 'src/core/hle/service/gsp.cpp') 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; } -- cgit v1.2.3