Merge pull request #2285 from mailwl/csnd-format

csnd:SND: Reformat source code

src/common/logging/backend.cpp

@@ -50,6 +50,7 @@ namespace Log {
     SUB(Service, CAM)                                                                              \
     SUB(Service, CECD)                                                                             \
     SUB(Service, CFG)                                                                              \
+    SUB(Service, CSND)                                                                             \
     SUB(Service, DSP)                                                                              \
     SUB(Service, DLP)                                                                              \
     SUB(Service, HID)                                                                              \

src/common/logging/log.h

@@ -67,6 +67,7 @@ enum class Class : ClassType {
     Service_CAM,       ///< The CAM (Camera) service
     Service_CECD,      ///< The CECD (StreetPass) service
     Service_CFG,       ///< The CFG (Configuration) service
+    Service_CSND,      ///< The CSND (CWAV format process) service
     Service_DSP,       ///< The DSP (DSP control) service
     Service_DLP,       ///< The DLP (Download Play) service
     Service_HID,       ///< The HID (Human interface device) service

src/core/hle/service/csnd_snd.cpp

@@ -4,7 +4,6 @@
 
 #include <cstring>
 #include "common/alignment.h"
-#include "core/hle/hle.h"
 #include "core/hle/kernel/mutex.h"
 #include "core/hle/kernel/shared_memory.h"
 #include "core/hle/service/csnd_snd.h"
@@ -12,72 +11,129 @@
 namespace Service {
 namespace CSND {
 
-const Interface::FunctionInfo FunctionTable[] = {
-    {0x00010140, Initialize, "Initialize"},
-    {0x00020000, Shutdown, "Shutdown"},
-    {0x00030040, ExecuteType0Commands, "ExecuteType0Commands"},
-    {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"},
+struct Type0Command {
+    // command id and next command offset
+    u32 command_id;
+    u32 finished;
+    u32 flags;
+    u8 parameters[20];
 };
-
-CSND_SND::CSND_SND() {
-    Register(FunctionTable);
-}
+static_assert(sizeof(Type0Command) == 0x20, "Type0Command structure size is wrong");
 
 static Kernel::SharedPtr<Kernel::SharedMemory> shared_memory = nullptr;
 static Kernel::SharedPtr<Kernel::Mutex> mutex = nullptr;
 
-void Initialize(Interface* self) {
+/**
+ * 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);
+
     using Kernel::MemoryPermission;
     shared_memory = Kernel::SharedMemory::Create(nullptr, size, MemoryPermission::ReadWrite,
                                                  MemoryPermission::ReadWrite, 0,
                                                  Kernel::MemoryRegion::BASE, "CSND:SharedMemory");
 
-    mutex = Kernel::Mutex::Create(false);
+    mutex = Kernel::Mutex::Create(false, "CSND:mutex");
 
     cmd_buff[1] = RESULT_SUCCESS.raw;
     cmd_buff[2] = IPC::CopyHandleDesc(2);
     cmd_buff[3] = Kernel::g_handle_table.Create(mutex).MoveFrom();
     cmd_buff[4] = Kernel::g_handle_table.Create(shared_memory).MoveFrom();
+
+    LOG_WARNING(Service_CSND, "(STUBBED) called");
 }
 
-void ExecuteType0Commands(Interface* self) {
-    u32* const cmd_buff = Kernel::GetCommandBuffer();
-    u8* const ptr = shared_memory->GetPointer(cmd_buff[1]);
+/**
+ * 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();
+
+    shared_memory = nullptr;
+    mutex = nullptr;
 
-    if (shared_memory != nullptr && ptr != nullptr) {
-        Type0Command command;
-        std::memcpy(&command, ptr, sizeof(Type0Command));
+    cmd_buff[1] = RESULT_SUCCESS.raw;
+    LOG_WARNING(Service_CSND, "(STUBBED) called");
+}
 
-        LOG_WARNING(Service, "(STUBBED) CSND_SND::ExecuteType0Commands");
-        command.finished |= 1;
-        cmd_buff[1] = 0;
+/**
+ * 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();
 
-        std::memcpy(ptr, &command, sizeof(Type0Command));
-    } else {
+    if (shared_memory == nullptr) {
         cmd_buff[1] = 1;
+        LOG_ERROR(Service_CSND, "called, shared memory not allocated");
+        return;
     }
+
+    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);
 }
 
-void AcquireSoundChannels(Interface* self) {
+/**
+ * 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] = 0;
+    cmd_buff[1] = RESULT_SUCCESS.raw;
     cmd_buff[2] = 0xFFFFFF00;
+    LOG_WARNING(Service_CSND, "(STUBBED) called");
 }
 
-void Shutdown(Interface* self) {
-    shared_memory = nullptr;
-    mutex = nullptr;
+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() {
+    Register(FunctionTable);
 }
 
 } // namespace CSND

src/core/hle/service/csnd_snd.h

@@ -18,18 +18,5 @@ public:
     }
 };
 
-struct Type0Command {
-    // command id and next command offset
-    u32 command_id;
-    u32 finished;
-    u32 flags;
-    u8 parameters[20];
-};
-
-void Initialize(Interface* self);
-void ExecuteType0Commands(Interface* self);
-void AcquireSoundChannels(Interface* self);
-void Shutdown(Interface* self);
-
 } // namespace CSND
 } // namespace Service