From 41d5b31a76f7580c557a9ac0f7e4a33353257180 Mon Sep 17 00:00:00 2001 From: NarcolepticK Date: Sun, 1 Jul 2018 15:40:28 -0400 Subject: [PATCH 1/4] service/csnd: Migrate to ServiceFramework --- src/core/hle/service/csnd_snd.cpp | 167 +++++++++++++----------------- src/core/hle/service/csnd_snd.h | 61 ++++++++++- src/core/hle/service/service.cpp | 2 +- 3 files changed, 128 insertions(+), 102 deletions(-) diff --git a/src/core/hle/service/csnd_snd.cpp b/src/core/hle/service/csnd_snd.cpp index df5a33d7c..27ade2470 100644 --- a/src/core/hle/service/csnd_snd.cpp +++ b/src/core/hle/service/csnd_snd.cpp @@ -2,14 +2,9 @@ // Licensed under GPLv2 or any later version // Refer to the license.txt file included. -#include #include "common/alignment.h" -#include "core/hle/ipc.h" -#include "core/hle/kernel/handle_table.h" -#include "core/hle/kernel/mutex.h" -#include "core/hle/kernel/shared_memory.h" +#include "core/hle/ipc_helpers.h" #include "core/hle/service/csnd_snd.h" -#include "core/memory.h" namespace Service { namespace CSND { @@ -23,120 +18,98 @@ struct Type0Command { }; static_assert(sizeof(Type0Command) == 0x20, "Type0Command structure size is wrong"); -static Kernel::SharedPtr shared_memory = nullptr; -static Kernel::SharedPtr mutex = nullptr; - -/** - * CSND_SND::Initialize service function - * Inputs: - * 0 : Header Code[0x00010140] - * 1 : Shared memory block size, for mem-block creation - * Outputs: - * 1 : Result of function, 0 on success, otherwise error code - * 2 : Handle-list header - * 3 : Mutex handle - * 4 : Shared memory block handle - */ -static void Initialize(Interface* self) { - u32* cmd_buff = Kernel::GetCommandBuffer(); - - u32 size = Common::AlignUp(cmd_buff[1], Memory::PAGE_SIZE); +void CSND_SND::Initialize(Kernel::HLERequestContext& ctx) { + IPC::RequestParser rp(ctx, 0x01, 5, 0); + u32 size = Common::AlignUp(rp.Pop(), Memory::PAGE_SIZE); + VAddr offset0 = rp.Pop(); + VAddr offset1 = rp.Pop(); + VAddr offset2 = rp.Pop(); + VAddr offset3 = rp.Pop(); using Kernel::MemoryPermission; + mutex = Kernel::Mutex::Create(false, "CSND:mutex"); shared_memory = Kernel::SharedMemory::Create(nullptr, size, MemoryPermission::ReadWrite, MemoryPermission::ReadWrite, 0, Kernel::MemoryRegion::BASE, "CSND:SharedMemory"); - mutex = Kernel::Mutex::Create(false, "CSND:mutex"); + IPC::RequestBuilder rb = rp.MakeBuilder(1, 3); + rb.Push(RESULT_SUCCESS); + rb.PushCopyObjects(mutex, shared_memory); - cmd_buff[1] = RESULT_SUCCESS.raw; - cmd_buff[2] = IPC::CopyHandleDesc(2); - cmd_buff[3] = Kernel::g_handle_table.Create(mutex).Unwrap(); - cmd_buff[4] = Kernel::g_handle_table.Create(shared_memory).Unwrap(); + LOG_WARNING(Service_CSND, "(STUBBED) called, size=0x{:08X} " + "offset0=0x{:08X} offset1=0x{:08X} offset2=0x{:08X} offset3=0x{:08X}", + size, offset0, offset1, offset2, offset3); +} + +void CSND_SND::Shutdown(Kernel::HLERequestContext& ctx) { + IPC::RequestParser rp(ctx, 0x02, 0, 0); + + if (shared_memory) shared_memory = nullptr; + if (mutex) mutex = nullptr; + + IPC::RequestBuilder rb = rp.MakeBuilder(1, 0); + rb.Push(RESULT_SUCCESS); LOG_WARNING(Service_CSND, "(STUBBED) called"); } -/** - * CSND_SND::Shutdown service function - * Inputs: - * 0 : Header Code[0x00020000] - * Outputs: - * 1 : Result of function, 0 on success, otherwise error code - */ -static void Shutdown(Interface* self) { - u32* cmd_buff = Kernel::GetCommandBuffer(); +void CSND_SND::ExecuteCommands(Kernel::HLERequestContext& ctx) { + IPC::RequestParser rp(ctx, 0x03, 1, 0); + VAddr addr = rp.Pop(); - shared_memory = nullptr; - mutex = nullptr; - - cmd_buff[1] = RESULT_SUCCESS.raw; - LOG_WARNING(Service_CSND, "(STUBBED) called"); -} - -/** - * CSND_SND::ExecuteCommands service function - * Inputs: - * 0 : Header Code[0x00030040] - * 1 : Command offset in shared memory. - * Outputs: - * 1 : Result of function, 0 on success, otherwise error code - * 2 : Available channel bit mask - */ -static void ExecuteCommands(Interface* self) { - u32* cmd_buff = Kernel::GetCommandBuffer(); - - if (shared_memory == nullptr) { - cmd_buff[1] = 1; + IPC::RequestBuilder rb = rp.MakeBuilder(2, 0); + if (!shared_memory) { + rb.Push(1); + rb.Skip(1, false); LOG_ERROR(Service_CSND, "called, shared memory not allocated"); - return; + } else { + u8* ptr = shared_memory->GetPointer(addr); + Type0Command command; + + std::memcpy(&command, ptr, sizeof(Type0Command)); + command.finished |= 1; + std::memcpy(ptr, &command, sizeof(Type0Command)); + + rb.Push(RESULT_SUCCESS); + rb.Push(0xFFFFFF00); } - VAddr addr = cmd_buff[1]; - u8* ptr = shared_memory->GetPointer(addr); - - Type0Command command; - std::memcpy(&command, ptr, sizeof(Type0Command)); - command.finished |= 1; - std::memcpy(ptr, &command, sizeof(Type0Command)); - - cmd_buff[1] = RESULT_SUCCESS.raw; - LOG_WARNING(Service_CSND, "(STUBBED) called, addr=0x{:08X}", addr); } -/** - * CSND_SND::AcquireSoundChannels service function - * Inputs: - * 0 : Header Code[0x00050000] - * Outputs: - * 1 : Result of function, 0 on success, otherwise error code - * 2 : Available channel bit mask - */ -static void AcquireSoundChannels(Interface* self) { - u32* cmd_buff = Kernel::GetCommandBuffer(); - cmd_buff[1] = RESULT_SUCCESS.raw; - cmd_buff[2] = 0xFFFFFF00; +void CSND_SND::AcquireSoundChannels(Kernel::HLERequestContext& ctx) { + IPC::RequestParser rp(ctx, 0x05, 0, 0); + + IPC::RequestBuilder rb = rp.MakeBuilder(2, 0); + rb.Push(RESULT_SUCCESS); + rb.Push(0xFFFFFF00); + LOG_WARNING(Service_CSND, "(STUBBED) called"); } -const Interface::FunctionInfo FunctionTable[] = { - {0x00010140, Initialize, "Initialize"}, - {0x00020000, Shutdown, "Shutdown"}, - {0x00030040, ExecuteCommands, "ExecuteCommands"}, - {0x00040080, nullptr, "ExecuteType1Commands"}, - {0x00050000, AcquireSoundChannels, "AcquireSoundChannels"}, - {0x00060000, nullptr, "ReleaseSoundChannels"}, - {0x00070000, nullptr, "AcquireCaptureDevice"}, - {0x00080040, nullptr, "ReleaseCaptureDevice"}, - {0x00090082, nullptr, "FlushDataCache"}, - {0x000A0082, nullptr, "StoreDataCache"}, - {0x000B0082, nullptr, "InvalidateDataCache"}, - {0x000C0000, nullptr, "Reset"}, +CSND_SND::CSND_SND() : ServiceFramework("csnd:SND", 4) { + static const FunctionInfo functions[] = { + // clang-format off + {0x00010140, &CSND_SND::Initialize, "Initialize"}, + {0x00020000, &CSND_SND::Shutdown, "Shutdown"}, + {0x00030040, &CSND_SND::ExecuteCommands, "ExecuteCommands"}, + {0x00040080, nullptr, "ExecuteType1Commands"}, + {0x00050000, &CSND_SND::AcquireSoundChannels, "AcquireSoundChannels"}, + {0x00060000, nullptr, "ReleaseSoundChannels"}, + {0x00070000, nullptr, "AcquireCaptureDevice"}, + {0x00080040, nullptr, "ReleaseCaptureDevice"}, + {0x00090082, nullptr, "FlushDataCache"}, + {0x000A0082, nullptr, "StoreDataCache"}, + {0x000B0082, nullptr, "InvalidateDataCache"}, + {0x000C0000, nullptr, "Reset"}, + // clang-format on + }; + + RegisterHandlers(functions); }; -CSND_SND::CSND_SND() { - Register(FunctionTable); +void InstallInterfaces(SM::ServiceManager& service_manager) { + std::make_shared()->InstallAsService(service_manager); } } // namespace CSND diff --git a/src/core/hle/service/csnd_snd.h b/src/core/hle/service/csnd_snd.h index ca6d4513e..2221b3b3c 100644 --- a/src/core/hle/service/csnd_snd.h +++ b/src/core/hle/service/csnd_snd.h @@ -4,19 +4,72 @@ #pragma once +#include "core/hle/kernel/mutex.h" +#include "core/hle/kernel/shared_memory.h" #include "core/hle/service/service.h" namespace Service { namespace CSND { -class CSND_SND final : public Interface { +class CSND_SND final : public ServiceFramework { public: CSND_SND(); + ~CSND_SND() = default; - std::string GetPortName() const override { - return "csnd:SND"; - } +private: + /** + * CSND_SND::Initialize service function + * Inputs: + * 0 : Header Code[0x00010140] + * 1 : Shared memory block size, for mem-block creation + * 2 : Offset0 located in the shared-memory, region size=8 + * 3 : Offset1 located in the shared-memory, region size=12*num_channels + * 4 : Offset2 located in the shared-memory, region size=8*num_capturedevices + * 5 : Offset3 located in the shared-memory. + * Outputs: + * 1 : Result of function, 0 on success, otherwise error code + * 2 : Handle-list header + * 3 : Mutex handle + * 4 : Shared memory block handle + */ + void Initialize(Kernel::HLERequestContext& ctx); + + /** + * CSND_SND::Shutdown service function + * Inputs: + * 0 : Header Code[0x00020000] + * Outputs: + * 1 : Result of function, 0 on success, otherwise error code + */ + void Shutdown(Kernel::HLERequestContext& ctx); + + /** + * CSND_SND::ExecuteCommands service function + * Inputs: + * 0 : Header Code[0x00030040] + * 1 : Command offset in shared memory. + * Outputs: + * 1 : Result of function, 0 on success, otherwise error code + * 2 : Available channel bit mask + */ + void ExecuteCommands(Kernel::HLERequestContext& ctx); + + /** + * CSND_SND::AcquireSoundChannels service function + * Inputs: + * 0 : Header Code[0x00050000] + * Outputs: + * 1 : Result of function, 0 on success, otherwise error code + * 2 : Available channel bit mask + */ + void AcquireSoundChannels(Kernel::HLERequestContext& ctx); + + Kernel::SharedPtr shared_memory = nullptr; + Kernel::SharedPtr mutex = nullptr; }; +/// Initializes the CSND_SND Service +void InstallInterfaces(SM::ServiceManager& service_manager); + } // namespace CSND } // namespace Service diff --git a/src/core/hle/service/service.cpp b/src/core/hle/service/service.cpp index d5979c4dd..2cdc98dc8 100644 --- a/src/core/hle/service/service.cpp +++ b/src/core/hle/service/service.cpp @@ -255,7 +255,7 @@ void Init(std::shared_ptr& sm) { PTM::InstallInterfaces(*sm); QTM::InstallInterfaces(*sm); - AddService(new CSND::CSND_SND); + CSND::InstallInterfaces(*sm); AddService(new DSP_DSP::Interface); AddService(new HTTP::HTTP_C); PM::InstallInterfaces(*sm); From 1f345642c4743b62ae7f879b1083a900a30205ff Mon Sep 17 00:00:00 2001 From: NarcolepticK Date: Sun, 1 Jul 2018 16:16:34 -0400 Subject: [PATCH 2/4] service/csnd: Stubbed DataCache functions --- src/core/hle/service/csnd_snd.cpp | 62 ++++++++++++++++++++++++++++--- src/core/hle/service/csnd_snd.h | 59 ++++++++++++++++++++++++++++- 2 files changed, 114 insertions(+), 7 deletions(-) diff --git a/src/core/hle/service/csnd_snd.cpp b/src/core/hle/service/csnd_snd.cpp index 27ade2470..5d4093ff0 100644 --- a/src/core/hle/service/csnd_snd.cpp +++ b/src/core/hle/service/csnd_snd.cpp @@ -44,8 +44,10 @@ void CSND_SND::Initialize(Kernel::HLERequestContext& ctx) { void CSND_SND::Shutdown(Kernel::HLERequestContext& ctx) { IPC::RequestParser rp(ctx, 0x02, 0, 0); - if (shared_memory) shared_memory = nullptr; - if (mutex) mutex = nullptr; + if (mutex) + mutex = nullptr; + if (shared_memory) + shared_memory = nullptr; IPC::RequestBuilder rb = rp.MakeBuilder(1, 0); rb.Push(RESULT_SUCCESS); @@ -87,6 +89,54 @@ void CSND_SND::AcquireSoundChannels(Kernel::HLERequestContext& ctx) { LOG_WARNING(Service_CSND, "(STUBBED) called"); } +void CSND_SND::ReleaseSoundChannels(Kernel::HLERequestContext& ctx) { + IPC::RequestParser rp(ctx, 0x06, 0, 0); + + IPC::RequestBuilder rb = rp.MakeBuilder(1, 0); + rb.Push(RESULT_SUCCESS); + + LOG_WARNING(Service_CSND, "(STUBBED) called"); +} + +void CSND_SND::FlushDataCache(Kernel::HLERequestContext& ctx) { + IPC::RequestParser rp(ctx, 0x9, 2, 2); + u32 address = rp.Pop(); + u32 size = rp.Pop(); + auto process = rp.PopObject(); + + IPC::RequestBuilder rb = rp.MakeBuilder(1, 0); + rb.Push(RESULT_SUCCESS); + + LOG_DEBUG(Service_CSND, "(STUBBED) called address=0x{:08X}, size=0x{:08X}, process={}", address, + size, process->process_id); +} + +void CSND_SND::StoreDataCache(Kernel::HLERequestContext& ctx) { + IPC::RequestParser rp(ctx, 0xA, 2, 2); + u32 address = rp.Pop(); + u32 size = rp.Pop(); + auto process = rp.PopObject(); + + IPC::RequestBuilder rb = rp.MakeBuilder(1, 0); + rb.Push(RESULT_SUCCESS); + + LOG_DEBUG(Service_CSND, "(STUBBED) called address=0x{:08X}, size=0x{:08X}, process={}", address, + size, process->process_id); +} + +void CSND_SND::InvalidateDataCache(Kernel::HLERequestContext& ctx) { + IPC::RequestParser rp(ctx, 0xB, 2, 2); + u32 address = rp.Pop(); + u32 size = rp.Pop(); + auto process = rp.PopObject(); + + IPC::RequestBuilder rb = rp.MakeBuilder(1, 0); + rb.Push(RESULT_SUCCESS); + + LOG_DEBUG(Service_CSND, "(STUBBED) called address=0x{:08X}, size=0x{:08X}, process={}", address, + size, process->process_id); +} + CSND_SND::CSND_SND() : ServiceFramework("csnd:SND", 4) { static const FunctionInfo functions[] = { // clang-format off @@ -95,12 +145,12 @@ CSND_SND::CSND_SND() : ServiceFramework("csnd:SND", 4) { {0x00030040, &CSND_SND::ExecuteCommands, "ExecuteCommands"}, {0x00040080, nullptr, "ExecuteType1Commands"}, {0x00050000, &CSND_SND::AcquireSoundChannels, "AcquireSoundChannels"}, - {0x00060000, nullptr, "ReleaseSoundChannels"}, + {0x00060000, &CSND_SND::ReleaseSoundChannels, "ReleaseSoundChannels"}, {0x00070000, nullptr, "AcquireCaptureDevice"}, {0x00080040, nullptr, "ReleaseCaptureDevice"}, - {0x00090082, nullptr, "FlushDataCache"}, - {0x000A0082, nullptr, "StoreDataCache"}, - {0x000B0082, nullptr, "InvalidateDataCache"}, + {0x00090082, &CSND_SND::FlushDataCache, "FlushDataCache"}, + {0x000A0082, &CSND_SND::StoreDataCache, "StoreDataCache"}, + {0x000B0082, &CSND_SND::InvalidateDataCache, "InvalidateDataCache"}, {0x000C0000, nullptr, "Reset"}, // clang-format on }; diff --git a/src/core/hle/service/csnd_snd.h b/src/core/hle/service/csnd_snd.h index 2221b3b3c..3f1d2a55e 100644 --- a/src/core/hle/service/csnd_snd.h +++ b/src/core/hle/service/csnd_snd.h @@ -64,8 +64,65 @@ private: */ void AcquireSoundChannels(Kernel::HLERequestContext& ctx); - Kernel::SharedPtr shared_memory = nullptr; + /** + * CSND_SND::ReleaseSoundChannels service function + * Inputs: + * 0 : Header Code[0x00060000] + * Outputs: + * 1 : Result of function, 0 on success, otherwise error code + */ + void ReleaseSoundChannels(Kernel::HLERequestContext& ctx); + + /** + * CSND_SND::FlushDataCache service function + * + * This Function is a no-op, We aren't emulating the CPU cache any time soon. + * + * Inputs: + * 0 : Header Code[0x00090082] + * 1 : Address + * 2 : Size + * 3 : Value 0, some descriptor for the KProcess Handle + * 4 : KProcess handle + * Outputs: + * 1 : Result of function, 0 on success, otherwise error code + */ + void FlushDataCache(Kernel::HLERequestContext& ctx); + + /** + * CSND_SND::StoreDataCache service function + * + * This Function is a no-op, We aren't emulating the CPU cache any time soon. + * + * Inputs: + * 0 : Header Code[0x000A0082] + * 1 : Address + * 2 : Size + * 3 : Value 0, some descriptor for the KProcess Handle + * 4 : KProcess handle + * Outputs: + * 1 : Result of function, 0 on success, otherwise error code + */ + void StoreDataCache(Kernel::HLERequestContext& ctx); + + /** + * CSND_SND::InvalidateDataCache service function + * + * This Function is a no-op, We aren't emulating the CPU cache any time soon. + * + * Inputs: + * 0 : Header Code[0x000B0082] + * 1 : Address + * 2 : Size + * 3 : Value 0, some descriptor for the KProcess Handle + * 4 : KProcess handle + * Outputs: + * 1 : Result of function, 0 on success, otherwise error code + */ + void InvalidateDataCache(Kernel::HLERequestContext& ctx); + Kernel::SharedPtr mutex = nullptr; + Kernel::SharedPtr shared_memory = nullptr; }; /// Initializes the CSND_SND Service From 84c23ce2e50c2c43537533184cf4a67251a7fd8a Mon Sep 17 00:00:00 2001 From: NarcolepticK Date: Sun, 1 Jul 2018 16:41:25 -0400 Subject: [PATCH 3/4] service/csnd: Fix clang format --- src/core/hle/service/csnd_snd.cpp | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/core/hle/service/csnd_snd.cpp b/src/core/hle/service/csnd_snd.cpp index 5d4093ff0..25a6d0141 100644 --- a/src/core/hle/service/csnd_snd.cpp +++ b/src/core/hle/service/csnd_snd.cpp @@ -36,9 +36,10 @@ void CSND_SND::Initialize(Kernel::HLERequestContext& ctx) { rb.Push(RESULT_SUCCESS); rb.PushCopyObjects(mutex, shared_memory); - LOG_WARNING(Service_CSND, "(STUBBED) called, size=0x{:08X} " - "offset0=0x{:08X} offset1=0x{:08X} offset2=0x{:08X} offset3=0x{:08X}", - size, offset0, offset1, offset2, offset3); + LOG_WARNING(Service_CSND, + "(STUBBED) called, size=0x{:08X} " + "offset0=0x{:08X} offset1=0x{:08X} offset2=0x{:08X} offset3=0x{:08X}", + size, offset0, offset1, offset2, offset3); } void CSND_SND::Shutdown(Kernel::HLERequestContext& ctx) { From acefa81ae3750d8bbf3bd239f77779279d8da4fe Mon Sep 17 00:00:00 2001 From: NarcolepticK Date: Mon, 2 Jul 2018 22:09:10 -0400 Subject: [PATCH 4/4] service/csnd: Addressed comments and removed outdated information --- src/core/hle/service/csnd_snd.cpp | 20 +++++++++----------- src/core/hle/service/csnd_snd.h | 1 - 2 files changed, 9 insertions(+), 12 deletions(-) diff --git a/src/core/hle/service/csnd_snd.cpp b/src/core/hle/service/csnd_snd.cpp index 25a6d0141..19a795213 100644 --- a/src/core/hle/service/csnd_snd.cpp +++ b/src/core/hle/service/csnd_snd.cpp @@ -21,10 +21,10 @@ static_assert(sizeof(Type0Command) == 0x20, "Type0Command structure size is wron void CSND_SND::Initialize(Kernel::HLERequestContext& ctx) { IPC::RequestParser rp(ctx, 0x01, 5, 0); u32 size = Common::AlignUp(rp.Pop(), Memory::PAGE_SIZE); - VAddr offset0 = rp.Pop(); - VAddr offset1 = rp.Pop(); - VAddr offset2 = rp.Pop(); - VAddr offset3 = rp.Pop(); + u32 offset0 = rp.Pop(); + u32 offset1 = rp.Pop(); + u32 offset2 = rp.Pop(); + u32 offset3 = rp.Pop(); using Kernel::MemoryPermission; mutex = Kernel::Mutex::Create(false, "CSND:mutex"); @@ -58,12 +58,11 @@ void CSND_SND::Shutdown(Kernel::HLERequestContext& ctx) { void CSND_SND::ExecuteCommands(Kernel::HLERequestContext& ctx) { IPC::RequestParser rp(ctx, 0x03, 1, 0); - VAddr addr = rp.Pop(); + u32 addr = rp.Pop(); - IPC::RequestBuilder rb = rp.MakeBuilder(2, 0); + IPC::RequestBuilder rb = rp.MakeBuilder(1, 0); if (!shared_memory) { rb.Push(1); - rb.Skip(1, false); LOG_ERROR(Service_CSND, "called, shared memory not allocated"); } else { u8* ptr = shared_memory->GetPointer(addr); @@ -74,7 +73,6 @@ void CSND_SND::ExecuteCommands(Kernel::HLERequestContext& ctx) { std::memcpy(ptr, &command, sizeof(Type0Command)); rb.Push(RESULT_SUCCESS); - rb.Push(0xFFFFFF00); } LOG_WARNING(Service_CSND, "(STUBBED) called, addr=0x{:08X}", addr); @@ -101,7 +99,7 @@ void CSND_SND::ReleaseSoundChannels(Kernel::HLERequestContext& ctx) { void CSND_SND::FlushDataCache(Kernel::HLERequestContext& ctx) { IPC::RequestParser rp(ctx, 0x9, 2, 2); - u32 address = rp.Pop(); + VAddr address = rp.Pop(); u32 size = rp.Pop(); auto process = rp.PopObject(); @@ -114,7 +112,7 @@ void CSND_SND::FlushDataCache(Kernel::HLERequestContext& ctx) { void CSND_SND::StoreDataCache(Kernel::HLERequestContext& ctx) { IPC::RequestParser rp(ctx, 0xA, 2, 2); - u32 address = rp.Pop(); + VAddr address = rp.Pop(); u32 size = rp.Pop(); auto process = rp.PopObject(); @@ -127,7 +125,7 @@ void CSND_SND::StoreDataCache(Kernel::HLERequestContext& ctx) { void CSND_SND::InvalidateDataCache(Kernel::HLERequestContext& ctx) { IPC::RequestParser rp(ctx, 0xB, 2, 2); - u32 address = rp.Pop(); + VAddr address = rp.Pop(); u32 size = rp.Pop(); auto process = rp.PopObject(); diff --git a/src/core/hle/service/csnd_snd.h b/src/core/hle/service/csnd_snd.h index 3f1d2a55e..34722874d 100644 --- a/src/core/hle/service/csnd_snd.h +++ b/src/core/hle/service/csnd_snd.h @@ -50,7 +50,6 @@ private: * 1 : Command offset in shared memory. * Outputs: * 1 : Result of function, 0 on success, otherwise error code - * 2 : Available channel bit mask */ void ExecuteCommands(Kernel::HLERequestContext& ctx);