Merge pull request #8 from wheremyfoodat/meow

Better DSP HLE, add DLP:SRVR service

CMakeLists.txt

@@ -82,7 +82,7 @@ set(SERVICE_SOURCE_FILES src/core/services/service_manager.cpp src/core/services
                          src/core/services/ac.cpp src/core/services/am.cpp src/core/services/boss.cpp
                          src/core/services/frd.cpp src/core/services/nim.cpp src/core/services/shared_font.cpp
                          src/core/services/y2r.cpp src/core/services/cam.cpp src/core/services/ldr_ro.cpp
-                         src/core/services/act.cpp src/core/services/nfc.cpp
+                         src/core/services/act.cpp src/core/services/nfc.cpp src/core/services/dlp_srvr.cpp
 )
 set(PICA_SOURCE_FILES src/core/PICA/gpu.cpp src/core/PICA/regs.cpp src/core/PICA/shader_unit.cpp
                       src/core/PICA/shader_interpreter.cpp
@@ -112,7 +112,7 @@ set(HEADER_FILES include/emulator.hpp include/helpers.hpp include/opengl.hpp inc
                  include/fs/archive_ext_save_data.hpp include/services/shared_font.hpp include/fs/archive_ncch.hpp
                  include/renderer_gl/textures.hpp include/colour.hpp include/services/y2r.hpp include/services/cam.hpp
                  include/services/ldr_ro.hpp include/ipc.hpp include/services/act.hpp include/services/nfc.hpp
-                 include/system_models.hpp
+                 include/system_models.hpp include/services/dlp_srvr.hpp
 )
 
 set(THIRD_PARTY_SOURCE_FILES third_party/imgui/imgui.cpp

include/kernel/handles.hpp

@@ -18,11 +18,12 @@ namespace KernelHandles {
 		CAM,  // Camera service
 		CECD, // More Streetpass stuff?
 		CFG,  // CFG service (Console & region info)
+		DLP_SRVR, // Download Play: Server. Used for network play.
+		DSP,  // DSP service (Used for audio decoding and output)
 		HID,  // HID service (Handles everything input-related including gyro)
         FRD,  // Friend service (Miiverse friend service)
 		FS,   // Filesystem service
 		GPU,  // GPU service
-		DSP,  // DSP service (Used for audio decoding and output)
 		LCD,  // LCD service (Used for configuring the displays)
 		LDR_RO, // Loader service. Used for loading CROs.
 		MIC,  // MIC service (Controls the microphone)
@@ -64,10 +65,11 @@ namespace KernelHandles {
 			case CAM: return "CAM";
 			case CECD: return "CECD";
 			case CFG: return "CFG";
+			case DSP: return "DSP";
+			case DLP_SRVR: return "DLP::SRVR";
 			case HID: return "HID";
 			case FRD: return "FRD";
 			case FS: return "FS";
-			case DSP: return "DSP";
 			case GPU: return "GSP::GPU";
 			case LCD: return "GSP::LCD";
 			case LDR_RO: return "LDR:RO";

include/logger.hpp

@@ -38,6 +38,7 @@ namespace Log {
     static Logger<false> cecdLogger;
     static Logger<false> cfgLogger;
     static Logger<false> dspServiceLogger;
+    static Logger<false> dlpSrvrLogger;
     static Logger<false> frdLogger;
     static Logger<false> fsLogger;
     static Logger<false> hidLogger;

include/services/dlp_srvr.hpp

@@ -0,0 +1,21 @@
+#pragma once
+#include "helpers.hpp"
+#include "kernel_types.hpp"
+#include "logger.hpp"
+#include "memory.hpp"
+
+// Please forgive me for how everything in this file is named
+// "dlp:SRVR" is not a nice name to work with
+class DlpSrvrService {
+	Handle handle = KernelHandles::DLP_SRVR;
+	Memory& mem;
+	MAKE_LOG_FUNCTION(log, dlpSrvrLogger)
+
+	// Service commands
+	void isChild(u32 messagePointer);
+
+public:
+	DlpSrvrService(Memory& mem) : mem(mem) {}
+	void reset();
+	void handleSyncRequest(u32 messagePointer);
+};

include/services/dsp.hpp

@@ -8,23 +8,25 @@
 // Stub for DSP audio pipe
 class DSPPipe {
 	// Hardcoded responses for now
+	// These are DSP DRAM offsets for various variables
+	// https://www.3dbrew.org/wiki/DSP_Memory_Region
 	static constexpr std::array<u16, 16> pipeData = {
-		0x000F, //Number of responses
-		0xBFFF,
-		0x9E8E,
-		0x8680,
-		0xA78E,
-		0x9430,
-		0x8400,
-		0x8540,
-		0x948E,
-		0x8710,
-		0x8410,
-		0xA90E,
-		0xAA0E,
-		0xAACE,
-		0xAC4E,
-		0xAC58
+		0x000F, // Number of responses
+		0xBFFF, // Frame counter
+		0x9E92, // Source configs
+		0x8680, // Source statuses
+		0xA792, // ADPCM coefficients
+		0x9430, // DSP configs
+		0x8400, // DSP status
+		0x8540, // Final samples
+		0x9492, // Intermediate mix samples
+		0x8710, // Compressor
+		0x8410, // Debug
+		0xA912, // ??
+		0xAA12, // ??
+		0xAAD2, // ??
+		0xAC52, // Surround sound biquad filter 1
+		0xAC5C  // Surround sound biquad filter 2
 	};
 	uint index = 0;
 
@@ -43,6 +45,12 @@ public:
 	}
 };
 
+namespace DSPPipeType {
+	enum : u32 {
+		Debug = 0, DMA = 1, Audio = 2, Binary = 3
+	};
+}
+
 // Circular dependencies!
 class Kernel;
 
@@ -52,9 +60,14 @@ class DSPService {
 	Kernel& kernel;
 	MAKE_LOG_FUNCTION(log, dspServiceLogger)
 
+	enum class DSPState : u32 {
+		Off, On, Slep
+	};
+
 	// Number of DSP pipes
 	static constexpr size_t pipeCount = 8;
 	DSPPipe audioPipe;
+	DSPState dspState;
 
 	// DSP service event handles
 	using DSPEvent = std::optional<Handle>;
@@ -78,9 +91,12 @@ class DSPService {
 	void invalidateDCache(u32 messagePointer);
 	void loadComponent(u32 messagePointer);
 	void readPipeIfPossible(u32 messagePointer);
+	void recvData(u32 messagePointer);
+	void recvDataIsReady(u32 messagePointer);
 	void registerInterruptEvents(u32 messagePointer);
 	void setSemaphore(u32 messagePointer);
 	void setSemaphoreMask(u32 messagePointer);
+	void unloadComponent(u32 messagePointer);
 	void writeProcessPipe(u32 messagePointer);
 
 public:

include/services/service_manager.hpp

@@ -12,6 +12,7 @@
 #include "services/cam.hpp"
 #include "services/cecd.hpp"
 #include "services/cfg.hpp"
+#include "services/dlp_srvr.hpp"
 #include "services/dsp.hpp"
 #include "services/hid.hpp"
 #include "services/frd.hpp"
@@ -46,6 +47,7 @@ class ServiceManager {
 	CAMService cam;
 	CECDService cecd;
 	CFGService cfg;
+	DlpSrvrService dlp_srvr;
 	DSPService dsp;
 	HIDService hid;
 	FRDService frd;

readme.md

@@ -0,0 +1,51 @@
+# Panda3DS
+
+Panda3DS is an HLE, red-panda-themed Nintendo 3DS emulator written in C++ which started out as a fun project out of curiosity, but evolved into something that can sort of play games!
+
+# Compatibility
+Panda3DS is still in the early stages of development. Many games boot, many don't. Most games have at least some hilariously broken graphics, audio is not supported, performance leaves a bit to be desired mainly thanks to lack of shader acceleration, and most QoL features (including input, or a GUI!) are missing.
+
+In fact, the screenshots in the repo were created after I hooked the input state to rand() locally.
+
+In addition, some games don't quiiite work with the upstream code. A lot of them might need some panics in the source code to be commented out before they work, etc. However, just the fact things can work as well as they do now is promising in itself.
+
+# Why?
+The 3DS emulation scene is already pretty mature, with offerings such as [Citra](https://github.com/citra-emu/citra) which can offer a great playing experience for most games in the library, [Corgi3DS](https://github.com/PSI-Rockin/Corgi3DS), an innovative LLE emulator, or [Mikage](https://mikage.app/). However, there's always room for more emulators! While Panda3DS was initially a mere curiosity, there's many different concepts I would like to explore with it in the future, such as:
+
+- Virtualization. What motivated the creation of this emulator was actually a discussion on whether it is possible to get fast 3DS emulation on low-end hardware such as the Raspberry Pi 4, using the KVM API. At the moment, Panda3DS is powered by dynarmic rather than using virtualization, but this is definitely a concept I want to explore in the future.
+
+- Debugging, reverse engineering and modding tools. While contributing to [PCSX-Redux](https://github.com/grumpycoders/pcsx-redux) and collaborating with the other developers, I had the chance to find out how useful tools like these can be. They can serve as indispensable tools for the homebrew devs, modders, reverse engineers, as well as emulator developers themselves. Some tools can even become fun toys the casual user can mess around with. As such, I think they can really improve the experience in a project like this. Of course, I'd like to thank @nicolasnoble and the entire Redux team for helping me learn the value of these tools, as well as making me improve as a programmer.
+
+- Trying out various other unique features, such as different graphics or audio enhancements, or supporting other niche things such as amiibo.
+
+- Fun. Writing code is fun and I strongly encourage anyone to do it.
+
+Keep in mind, these are all long-term plans. Until then, the main focus is just improving compatibility
+
+# How to build
+Panda3DS compiles on Windows, Linux and MacOS (if you use a compiler other than AppleClang), without needing to download any system dependencies.
+
+All you need is CMake and a generator of your choice (Make, Visual Studio, Ninja, etc). Simply clone the repo recursively and build it like your average CMake project.
+
+```sh
+git clone https://github.com/wheremyfoodat/Panda3DS --recursive
+
+cd Panda3DS && mkdir build && cd build
+cmake . -DCMAKE_BUILD_TYPE=Release # Set up compilers etc here if you'd like
+
+<Invoke Make, Visual Studio, or whatever you would like to use>
+```
+
+# How to use
+Simply drag and drop a ROM to the executable if supported, or invoke the executable from the command line with the path to the ROM as the first argument.
+
+# Acknowledgements
+- [3DBrew](https://www.3dbrew.org/wiki/Main_Page), a wiki full of 3DS information and the main source of documentation used.
+- [GBATek](https://www.problemkaputt.de/gbatek.htm#3dsreference), a GBA, DS and 3DS reference which provided insights on some pieces of hardware as well as neatly documenting things like certain file formats used in games.
+- [Libctru](https://github.com/devkitPro/libctru), the most well-known 3DS homebrew SDK. Used for developing test ROMs, as well as a source of documentation thanks to its doxygen wiki.
+
+- [Citra](https://github.com/citra-emu/citra), an HLE 3DS emulator. Very useful as a reference, with some code snippets inspired or adapted from it.
+- [3dmoo](https://github.com/plutooo/3dmoo), an HLE 3DS emulator which helped similarly to Citra
+- [Corgi3DS](https://github.com/PSI-Rockin/Corgi3DS), an LLE 3DS emulator which both served as an inspiration, as well as a nice source of documentation for some PICA200-related things
+
+Nintendo 3DS is a registered trademark of Nintendo Co., Ltd.

src/core/services/dlp_srvr.cpp

@@ -0,0 +1,32 @@
+#include "services/dlp_srvr.hpp"
+#include "ipc.hpp"
+
+namespace DlpSrvrCommands {
+	enum : u32 {
+		IsChild = 0x000E0040
+	};
+}
+
+namespace Result {
+	enum : u32 {
+		Success = 0,
+	};
+}
+
+void DlpSrvrService::reset() {}
+
+void DlpSrvrService::handleSyncRequest(u32 messagePointer) {
+	const u32 command = mem.read32(messagePointer);
+	switch (command) {
+		case DlpSrvrCommands::IsChild: isChild(messagePointer); break;
+		default: Helpers::panic("DLP::SRVR service requested. Command: %08X\n", command);
+	}
+}
+
+void DlpSrvrService::isChild(u32 messagePointer) {
+	log("DLP::SRVR: IsChild\n");
+
+	mem.write32(messagePointer, IPC::responseHeader(0x0E, 2, 0));
+	mem.write32(messagePointer + 4, Result::Success);
+	mem.write32(messagePointer + 8, 0); // We are responsible adults
+}

src/core/services/dsp.cpp

@@ -4,11 +4,14 @@
 
 namespace DSPCommands {
 	enum : u32 {
+		RecvData = 0x00010040,
+		RecvDataIsReady = 0x00020040,
 		SetSemaphore = 0x00070040,
 		ConvertProcessAddressFromDspDram = 0x000C0040,
 		WriteProcessPipe = 0x000D0082,
 		ReadPipeIfPossible = 0x001000C0,
 		LoadComponent = 0x001100C2,
+		UnloadComponent = 0x00120000,
 		FlushDataCache = 0x00130082,
 		InvalidateDataCache = 0x00140082,
 		RegisterInterruptEvents = 0x00150082,
@@ -29,6 +32,7 @@ namespace Result {
 void DSPService::reset() {
 	audioPipe.reset();
 	totalEventCount = 0;
+	dspState = DSPState::Off;
 
 	semaphoreEvent = std::nullopt;
 	interrupt0 = std::nullopt;
@@ -49,9 +53,12 @@ void DSPService::handleSyncRequest(u32 messagePointer) {
 		case DSPCommands::GetSemaphoreEventHandle: getSemaphoreEventHandle(messagePointer); break;
 		case DSPCommands::LoadComponent: loadComponent(messagePointer); break;
 		case DSPCommands::ReadPipeIfPossible: readPipeIfPossible(messagePointer); break;
+		case DSPCommands::RecvData: [[likely]] recvData(messagePointer); break;
+		case DSPCommands::RecvDataIsReady: [[likely]] recvDataIsReady(messagePointer); break;
 		case DSPCommands::RegisterInterruptEvents: registerInterruptEvents(messagePointer); break;
 		case DSPCommands::SetSemaphore: setSemaphore(messagePointer); break;
 		case DSPCommands::SetSemaphoreMask: setSemaphoreMask(messagePointer); break;
+		case DSPCommands::UnloadComponent: unloadComponent(messagePointer); break;
 		case DSPCommands::WriteProcessPipe: [[likely]] writeProcessPipe(messagePointer); break;
 		default: Helpers::panic("DSP service requested. Command: %08X\n", command);
 	}
@@ -80,6 +87,12 @@ void DSPService::loadComponent(u32 messagePointer) {
 	mem.write32(messagePointer + 16, mem.read32(messagePointer + 20)); // Component buffer
 }
 
+void DSPService::unloadComponent(u32 messagePointer) {
+	log("DSP::UnloadComponent\n");
+	mem.write32(messagePointer, IPC::responseHeader(0x12, 1, 0));
+	mem.write32(messagePointer + 4, Result::Success);
+}
+
 void DSPService::readPipeIfPossible(u32 messagePointer) {
 	u32 channel = mem.read32(messagePointer + 4);
 	u32 peer = mem.read32(messagePointer + 8);
@@ -107,6 +120,29 @@ void DSPService::readPipeIfPossible(u32 messagePointer) {
 	mem.write16(messagePointer + 8, i); // Number of bytes read
 }
 
+void DSPService::recvData(u32 messagePointer) {
+	const u32 registerIndex = mem.read32(messagePointer + 4);
+	log("DSP::RecvData (register = %d)\n", registerIndex);
+	if (registerIndex != 0) Helpers::panic("Unknown register in DSP::RecvData");
+
+	// Return 0 if the DSP is running, otherwise 1
+	const u16 ret = dspState == DSPState::On ? 0 : 1;
+
+	mem.write32(messagePointer, IPC::responseHeader(0x01, 2, 0));
+	mem.write32(messagePointer + 4, Result::Success);
+	mem.write16(messagePointer + 8, ret); // Always return that the DSP is on
+}
+
+void DSPService::recvDataIsReady(u32 messagePointer) {
+	const u32 registerIndex = mem.read32(messagePointer + 4);
+	log("DSP::RecvDataIsReady (register = %d)\n", registerIndex);
+	if (registerIndex != 0) Helpers::panic("Unknown register in DSP::RecvDataIsReady");
+
+	mem.write32(messagePointer, IPC::responseHeader(0x02, 2, 0));
+	mem.write32(messagePointer + 4, Result::Success);
+	mem.write32(messagePointer + 8, 1); // Always return that the register is ready for now
+}
+
 DSPService::DSPEvent& DSPService::getEventRef(u32 type, u32 pipe) {
 	switch (type) {
 		case 0: return interrupt0;
@@ -130,7 +166,11 @@ void DSPService::registerInterruptEvents(u32 messagePointer) {
 	
 	// The event handle being 0 means we're removing an event
 	if (eventHandle == 0) {
-		Helpers::panic("DSP::DSP::RegisterinterruptEvents Trying to remove a registered interrupt");
+		DSPEvent& e = getEventRef(interrupt, channel); // Get event
+		if (e.has_value()) { // Remove if it exists
+			totalEventCount--;
+			e = std::nullopt;
+		}
 	} else {
 		const KernelObject* object = kernel.getObject(eventHandle, KernelObjectType::Event);
 		if (!object) {
@@ -192,8 +232,49 @@ void DSPService::writeProcessPipe(u32 messagePointer) {
 	const u32 channel = mem.read32(messagePointer + 4);
 	const u32 size = mem.read32(messagePointer + 8);
 	const u32 buffer = mem.read32(messagePointer + 16);
-
 	log("DSP::writeProcessPipe (channel = %d, size = %X, buffer = %08X)\n", channel, size, buffer);
+
+	enum class StateChange : u8 {
+		Initialize = 0,
+		Shutdown = 1,
+		Wakeup = 2,
+		Sleep = 3,
+	};
+
+	switch (channel) {
+		case DSPPipeType::Audio: {
+			if (size != 4) {
+				printf("Invalid size written to DSP Audio Pipe\n");
+				break;
+			}
+
+			// Get new state
+			const u8 state = mem.read8(buffer);
+			if (state > 3) {
+				log("WriteProcessPipe::Audio: Unknown state change type");
+			} else {
+				switch (static_cast<StateChange>(state)) {
+					case StateChange::Initialize:
+						// TODO: Other initialization stuff here
+						dspState = DSPState::On;
+						audioPipe.reset();
+						break;
+
+					case StateChange::Shutdown:
+						dspState = DSPState::Off;
+						break;
+
+					default: Helpers::panic("Unimplemented DSP audio pipe state change %d", state);
+				}
+			}
+			break;
+		}
+
+		default:
+			log("DSP: Wrote to unimplemented pipe %d\n", channel);
+			break;
+	}
+
 	mem.write32(messagePointer, IPC::responseHeader(0xD, 1, 0));
 	mem.write32(messagePointer + 4, Result::Success);
 }

src/core/services/service_manager.cpp

@@ -5,7 +5,7 @@
 
 ServiceManager::ServiceManager(std::array<u32, 16>& regs, Memory& mem, GPU& gpu, u32& currentPID, Kernel& kernel)
 	: regs(regs), mem(mem), kernel(kernel), ac(mem), am(mem), boss(mem), act(mem), apt(mem, kernel), cam(mem),
-	cecd(mem, kernel), cfg(mem), dsp(mem, kernel), hid(mem, kernel), frd(mem), fs(mem, kernel),
+	cecd(mem, kernel), cfg(mem), dlp_srvr(mem), dsp(mem, kernel), hid(mem, kernel), frd(mem), fs(mem, kernel),
 	gsp_gpu(mem, gpu, kernel, currentPID), gsp_lcd(mem), ldr(mem), mic(mem), nfc(mem, kernel), nim(mem), ndm(mem),
 	ptm(mem), y2r(mem, kernel) {}
 
@@ -21,6 +21,7 @@ void ServiceManager::reset() {
 	cam.reset();
 	cecd.reset();
 	cfg.reset();
+	dlp_srvr.reset();
 	dsp.reset();
 	hid.reset();
 	frd.reset();
@@ -97,6 +98,7 @@ static std::map<std::string, Handle> serviceMap = {
 	{ "cam:u", KernelHandles::CAM },
 	{ "cecd:u", KernelHandles::CECD },
 	{ "cfg:u", KernelHandles::CFG },
+	{ "dlp:SRVR", KernelHandles::DLP_SRVR },
 	{ "dsp::DSP", KernelHandles::DSP },
 	{ "hid:USER", KernelHandles::HID },
 	{ "frd:u", KernelHandles::FRD },
@@ -170,6 +172,7 @@ void ServiceManager::sendCommandToService(u32 messagePointer, Handle handle) {
 		case KernelHandles::GPU: [[likely]] gsp_gpu.handleSyncRequest(messagePointer); break;
 		case KernelHandles::FS: [[likely]] fs.handleSyncRequest(messagePointer); break;
 		case KernelHandles::APT: [[likely]] apt.handleSyncRequest(messagePointer); break;
+		case KernelHandles::DSP: [[likely]] dsp.handleSyncRequest(messagePointer); break;
 
         case KernelHandles::AC: ac.handleSyncRequest(messagePointer); break;
 		case KernelHandles::ACT: act.handleSyncRequest(messagePointer); break;
@@ -178,7 +181,7 @@ void ServiceManager::sendCommandToService(u32 messagePointer, Handle handle) {
 		case KernelHandles::CAM: cam.handleSyncRequest(messagePointer); break;
 		case KernelHandles::CECD: cecd.handleSyncRequest(messagePointer); break;
 		case KernelHandles::CFG: cfg.handleSyncRequest(messagePointer); break;
-		case KernelHandles::DSP: dsp.handleSyncRequest(messagePointer); break;
+		case KernelHandles::DLP_SRVR: dlp_srvr.handleSyncRequest(messagePointer); break;
 		case KernelHandles::HID: hid.handleSyncRequest(messagePointer); break;
         case KernelHandles::FRD: frd.handleSyncRequest(messagePointer); break;
 		case KernelHandles::LCD: gsp_lcd.handleSyncRequest(messagePointer); break;