Merge pull request #218 from wheremyfoodat/sd-card

SD card support

include/fs/archive_sdmc.hpp

@@ -8,13 +8,16 @@ class SDMCArchive : public ArchiveBase {
 public:
 	SDMCArchive(Memory& mem) : ArchiveBase(mem) {}
 
-	u64 getFreeBytes() override { Helpers::panic("SDMC::GetFreeBytes unimplemented"); return 0;  }
+	u64 getFreeBytes() override { return 1_GB; }
 	std::string name() override { return "SDMC"; }
 
 	HorizonResult createFile(const FSPath& path, u64 size) override;
 	HorizonResult deleteFile(const FSPath& path) override;
+	HorizonResult createDirectory(const FSPath& path) override;
 
 	Rust::Result<ArchiveBase*, HorizonResult> openArchive(const FSPath& path) override;
+	Rust::Result<DirectorySession, HorizonResult> openDirectory(const FSPath& path) override;
+
 	FileDescriptor openFile(const FSPath& path, const FilePerms& perms) override;
 	std::optional<u32> readFile(FileSession* file, u64 offset, u32 size, u32 dataPointer) override;
 };

include/services/fs.hpp

@@ -1,4 +1,5 @@
 #pragma once
+#include "config.hpp"
 #include "fs/archive_ext_save_data.hpp"
 #include "fs/archive_ncch.hpp"
 #include "fs/archive_save_data.hpp"
@@ -9,7 +10,6 @@
 #include "kernel_types.hpp"
 #include "logger.hpp"
 #include "memory.hpp"
-#include "result/result.hpp"
 
 // Yay, more circular dependencies
 class Kernel;
@@ -40,6 +40,8 @@ class FSService {
 	std::optional<Handle> openFileHandle(ArchiveBase* archive, const FSPath& path, const FSPath& archivePath, const FilePerms& perms);
 	FSPath readPath(u32 type, u32 pointer, u32 size);
 
+	const EmulatorConfig& config;
+
 	// Service commands
 	void abnegateAccessRight(u32 messagePointer);
 	void createDirectory(u32 messagePointer);
@@ -73,9 +75,9 @@ class FSService {
 	u32 priority;
 
 public:
-	FSService(Memory& mem, Kernel& kernel)
+	FSService(Memory& mem, Kernel& kernel, const EmulatorConfig& config)
 		: mem(mem), saveData(mem), sharedExtSaveData_nand(mem, "../SharedFiles/NAND", true), extSaveData_sdmc(mem, "SDMC"), sdmc(mem), selfNcch(mem),
-		  ncch(mem), userSaveData1(mem, ArchiveID::UserSaveData1), userSaveData2(mem, ArchiveID::UserSaveData2), kernel(kernel) {}
+		  ncch(mem), userSaveData1(mem, ArchiveID::UserSaveData1), userSaveData2(mem, ArchiveID::UserSaveData2), kernel(kernel), config(config) {}
 
 	void reset();
 	void handleSyncRequest(u32 messagePointer);

include/services/http.hpp

@@ -12,7 +12,9 @@ class HTTPService {
 	bool initialized = false;
 
 	// Service commands
+	void createRootCertChain(u32 messagePointer);
 	void initialize(u32 messagePointer);
+	void rootCertChainAddDefaultCert(u32 messagePointer);
 
   public:
 	HTTPService(Memory& mem) : mem(mem) {}

include/services/ptm.hpp

@@ -16,6 +16,7 @@ class PTMService {
 	// Service commands
 	void configureNew3DSCPU(u32 messagePointer);
 	void getAdapterState(u32 messagePointer);
+	void getBatteryChargeState(u32 messagePointer);
 	void getBatteryLevel(u32 messagePointer);
 	void getStepHistory(u32 messagePointer);
 	void getTotalStepCount(u32 messagePointer);

src/core/fs/archive_save_data.cpp

@@ -39,14 +39,17 @@ HorizonResult SaveDataArchive::createFile(const FSPath& path, u64 size) {
 
 HorizonResult SaveDataArchive::createDirectory(const FSPath& path) {
 	if (path.type == PathType::UTF16) {
-		if (!isPathSafe<PathType::UTF16>(path))
+		if (!isPathSafe<PathType::UTF16>(path)) {
 			Helpers::panic("Unsafe path in SaveData::OpenFile");
+		}
 
 		fs::path p = IOFile::getAppData() / "SaveData";
 		p += fs::path(path.utf16_string).make_preferred();
 
-		if (fs::is_directory(p))
+		if (fs::is_directory(p)) {
 			return Result::FS::AlreadyExists;
+		}
+
 		if (fs::is_regular_file(p)) {
 			Helpers::panic("File path passed to SaveData::CreateDirectory");
 		}
@@ -92,11 +95,13 @@ HorizonResult SaveDataArchive::deleteFile(const FSPath& path) {
 
 FileDescriptor SaveDataArchive::openFile(const FSPath& path, const FilePerms& perms) {
 	if (path.type == PathType::UTF16) {
-		if (!isPathSafe<PathType::UTF16>(path))
+		if (!isPathSafe<PathType::UTF16>(path)) {
 			Helpers::panic("Unsafe path in SaveData::OpenFile");
+		}
 
-		if (perms.raw == 0 || (perms.create() && !perms.write()))
+		if (perms.raw == 0 || (perms.create() && !perms.write())) {
 			Helpers::panic("[SaveData] Unsupported flags for OpenFile");
+		}
 
 		fs::path p = IOFile::getAppData() / "SaveData";
 		p += fs::path(path.utf16_string).make_preferred();
@@ -126,8 +131,9 @@ FileDescriptor SaveDataArchive::openFile(const FSPath& path, const FilePerms& pe
 
 Rust::Result<DirectorySession, HorizonResult> SaveDataArchive::openDirectory(const FSPath& path) {
 	if (path.type == PathType::UTF16) {
-		if (!isPathSafe<PathType::UTF16>(path))
+		if (!isPathSafe<PathType::UTF16>(path)) {
 			Helpers::panic("Unsafe path in SaveData::OpenDirectory");
+		}
 
 		fs::path p = IOFile::getAppData() / "SaveData";
 		p += fs::path(path.utf16_string).make_preferred();

src/core/fs/archive_sdmc.cpp

@@ -1,6 +1,8 @@
 #include "fs/archive_sdmc.hpp"
 #include <memory>
 
+namespace fs = std::filesystem;
+
 HorizonResult SDMCArchive::createFile(const FSPath& path, u64 size) {
 	Helpers::panic("[SDMC] CreateFile not yet supported");
 	return Result::Success;
@@ -12,13 +14,123 @@ HorizonResult SDMCArchive::deleteFile(const FSPath& path) {
 }
 
 FileDescriptor SDMCArchive::openFile(const FSPath& path, const FilePerms& perms) {
-	printf("SDMCArchive::OpenFile: Failed");
-	return FileError;
+	FilePerms realPerms = perms;
+	// SD card always has read permission
+	realPerms.raw |= (1 << 0);
+
+	if ((realPerms.create() && !realPerms.write())) {
+		Helpers::panic("[SDMC] Unsupported flags for OpenFile");
+	}
+
+	std::filesystem::path p = IOFile::getAppData() / "SDMC";
+
+	switch (path.type) {
+		case PathType::ASCII:
+			if (!isPathSafe<PathType::ASCII>(path)) {
+				Helpers::panic("Unsafe path in SDMCArchive::OpenFile");
+			}
+
+			p += fs::path(path.string).make_preferred();
+			break;
+
+		case PathType::UTF16:
+			if (!isPathSafe<PathType::UTF16>(path)) {
+				Helpers::panic("Unsafe path in SDMCArchive::OpenFile");
+			}
+
+			p += fs::path(path.utf16_string).make_preferred();
+			break;
+
+		default: Helpers::panic("SDMCArchive::OpenFile: Failed. Path type: %d", path.type); return FileError;
+	}
+
+	const char* permString = perms.write() ? "r+b" : "rb";
+
+	if (fs::exists(p)) {  // Return file descriptor if the file exists
+		IOFile file(p.string().c_str(), permString);
+		return file.isOpen() ? file.getHandle() : FileError;
+	} else {
+		// If the file is not found, create it if the create flag is on
+		if (realPerms.create()) {
+			IOFile file(p.string().c_str(), "wb");  // Create file
+			file.close();                           // Close it
+
+			file.open(p.string().c_str(), permString);  // Reopen with proper perms
+			return file.isOpen() ? file.getHandle() : FileError;
+		} else {
+			return FileError;
+		}
+	}
+}
+
+HorizonResult SDMCArchive::createDirectory(const FSPath& path) {
+	std::filesystem::path p = IOFile::getAppData() / "SDMC";
+
+	switch (path.type) {
+		case PathType::ASCII:
+			if (!isPathSafe<PathType::ASCII>(path)) {
+				Helpers::panic("Unsafe path in SDMCArchive::OpenFile");
+			}
+
+			p += fs::path(path.string).make_preferred();
+			break;
+
+		case PathType::UTF16:
+			if (!isPathSafe<PathType::UTF16>(path)) {
+				Helpers::panic("Unsafe path in SDMCArchive::OpenFile");
+			}
+
+			p += fs::path(path.utf16_string).make_preferred();
+			break;
+
+		default: Helpers::panic("SDMCArchive::CreateDirectory: Failed. Path type: %d", path.type); return Result::FailurePlaceholder;
+	}
+
+	if (fs::is_directory(p)) {
+		return Result::FS::AlreadyExists;
+	}
+
+	if (fs::is_regular_file(p)) {
+		Helpers::panic("File path passed to SDMCArchive::CreateDirectory");
+	}
+
+	std::error_code ec;
+	bool success = fs::create_directory(p, ec);
+	return success ? Result::Success : Result::FS::UnexpectedFileOrDir;
+}
+
+Rust::Result<DirectorySession, HorizonResult> SDMCArchive::openDirectory(const FSPath& path) {
+	if (path.type == PathType::UTF16) {
+		if (!isPathSafe<PathType::UTF16>(path)) {
+			Helpers::panic("Unsafe path in SaveData::OpenDirectory");
+		}
+
+		fs::path p = IOFile::getAppData() / "SDMC";
+		p += fs::path(path.utf16_string).make_preferred();
+
+		if (fs::is_regular_file(p)) {
+			printf("SDMC: OpenDirectory used with a file path");
+			return Err(Result::FS::UnexpectedFileOrDir);
+		}
+
+		if (fs::is_directory(p)) {
+			return Ok(DirectorySession(this, p));
+		} else {
+			return Err(Result::FS::FileNotFoundAlt);
+		}
+	}
+
+	Helpers::panic("SDMCArchive::OpenDirectory: Unimplemented path type");
+	return Err(Result::Success);
 }
 
 Rust::Result<ArchiveBase*, HorizonResult> SDMCArchive::openArchive(const FSPath& path) {
-	printf("SDMCArchive::OpenArchive: Failed\n");
-	return Err(Result::FS::NotFormatted);
+	// TODO: Fail here if the SD is disabled in the connfig.
+	if (path.type != PathType::Empty) {
+		Helpers::panic("Unimplemented path type for SDMC::OpenArchive");
+	}
+
+	return Ok((ArchiveBase*)this);
 }
 
 std::optional<u32> SDMCArchive::readFile(FileSession* file, u64 offset, u32 size, u32 dataPointer) {

src/core/renderer_gl/renderer_gl.cpp

@@ -695,6 +695,7 @@ void RendererGL::textureCopy(u32 inputAddr, u32 outputAddr, u32 totalBytes, u32
 	if (inputGap != 0 || outputGap != 0) {
 		// Helpers::warn("Strided texture copy\n");
 	}
+
 	if (inputWidth != outputWidth) {
 		Helpers::warn("Input width does not match output width, cannot accelerate texture copy!");
 		return;
@@ -716,7 +717,12 @@ void RendererGL::textureCopy(u32 inputAddr, u32 outputAddr, u32 totalBytes, u32
 	// inputHeight/outputHeight are typically set to zero so they cannot be used to get the height of the copy region
 	// in contrast to display transfer. Compute height manually by dividing the copy size with the copy width. The result
 	// is the number of vertical tiles so multiply that by eight to get the actual copy height.
-	const u32 copyHeight = (copySize / inputWidth) * 8;
+	u32 copyHeight;
+	if (inputWidth != 0) [[likely]] {
+		copyHeight = (copySize / inputWidth) * 8;
+	} else {
+		copyHeight = 0;
+	}
 
 	// Find the source surface.
 	auto srcFramebuffer = getColourBuffer(inputAddr, PICA::ColorFmt::RGBA8, copyStride, copyHeight, false);

src/core/services/fs.cpp

@@ -2,6 +2,7 @@
 #include "kernel/kernel.hpp"
 #include "io_file.hpp"
 #include "ipc.hpp"
+#include "result/result.hpp"
 
 #ifdef CreateFile // windows.h defines CreateFile & DeleteFile because of course it does.
 #undef CreateDirectory
@@ -352,7 +353,8 @@ void FSService::openFileDirectly(u32 messagePointer) {
 	std::optional<Handle> handle = openFileHandle(archive, filePath, archivePath, perms);
 	mem.write32(messagePointer, IPC::responseHeader(0x803, 1, 2));
 	if (!handle.has_value()) {
-		Helpers::panic("OpenFileDirectly: Failed to open file with given path");
+		printf("OpenFileDirectly failed\n");
+		mem.write32(messagePointer + 4, Result::FS::FileNotFound);
 	} else {
 		mem.write32(messagePointer + 4, Result::Success);
 		mem.write32(messagePointer + 12, handle.value());
@@ -665,21 +667,21 @@ void FSService::theGameboyVCFunction(u32 messagePointer) {
 	mem.write32(messagePointer + 4, Result::Success);
 }
 
-// Shows whether an SD card is inserted. At the moment stubbed to no
-constexpr bool sdInserted = false;
-
 void FSService::isSdmcDetected(u32 messagePointer) {
 	log("FS::IsSdmcDetected\n");
+
 	mem.write32(messagePointer, IPC::responseHeader(0x817, 2, 0));
 	mem.write32(messagePointer + 4, Result::Success);
-	mem.write8(messagePointer + 8, sdInserted ? 1 : 0);
+	mem.write8(messagePointer + 8, config.sdCardInserted ? 1 : 0);
 }
 
-// We consider our SD card to always be writable if oen is inserted for now
-// So isSdmcWritable returns 1 if an SD card is inserted (because it's always writable) and 0 if not.
+// We consider our SD card to always be writable if one is inserted for now
+// However we do make sure to respect the configs and properly return the correct value here
 void FSService::isSdmcWritable(u32 messagePointer) {
 	log("FS::isSdmcWritable\n");
+	const bool writeProtected = (!config.sdCardInserted) || (config.sdCardInserted && config.sdWriteProtected);
+
 	mem.write32(messagePointer, IPC::responseHeader(0x818, 2, 0));
 	mem.write32(messagePointer + 4, Result::Success);
-	mem.write8(messagePointer + 8, sdInserted ? 1 : 0);
+	mem.write8(messagePointer + 8, writeProtected ? 0 : 1);
 }

src/core/services/http.cpp

@@ -6,6 +6,8 @@
 namespace HTTPCommands {
 	enum : u32 {
 		Initialize = 0x00010044,
+		CreateRootCertChain = 0x002D0000,
+		RootCertChainAddDefaultCert = 0x00300080,
 	};
 }
 
@@ -14,7 +16,9 @@ void HTTPService::reset() { initialized = false; }
 void HTTPService::handleSyncRequest(u32 messagePointer) {
 	const u32 command = mem.read32(messagePointer);
 	switch (command) {
+		case HTTPCommands::CreateRootCertChain: createRootCertChain(messagePointer); break;
 		case HTTPCommands::Initialize: initialize(messagePointer); break;
+		case HTTPCommands::RootCertChainAddDefaultCert: rootCertChainAddDefaultCert(messagePointer); break;
 		default: Helpers::panic("HTTP service requested. Command: %08X\n", command);
 	}
 }
@@ -39,4 +43,28 @@ void HTTPService::initialize(u32 messagePointer) {
 	initialized = true;
 	// We currently don't emulate HTTP properly. TODO: Prepare POST buffer here
 	mem.write32(messagePointer + 4, Result::Success);
+}
+
+void HTTPService::createRootCertChain(u32 messagePointer) {
+	log("HTTP::CreateRootCertChain (Unimplemented)\n");
+
+	// TODO: Verify response header
+	mem.write32(messagePointer, IPC::responseHeader(0x2D, 2, 0));
+	mem.write32(messagePointer + 4, Result::Success);
+
+	// RootCertChain context handle. No need to emulate this yet
+	mem.write32(messagePointer + 8, 0x66666666);
+}
+
+void HTTPService::rootCertChainAddDefaultCert(u32 messagePointer) {
+	log("HTTP::RootCertChainAddDefaultCert (Unimplemented)\n");
+	const u32 contextHandle = mem.read32(messagePointer + 4);
+	const u32 certID = mem.read32(messagePointer + 8);
+
+	// TODO: Verify response header
+	mem.write32(messagePointer, IPC::responseHeader(0x30, 2, 0));
+	mem.write32(messagePointer + 4, Result::Success);
+
+	// Cert context handle. No need to emulate this yet
+	mem.write32(messagePointer + 8, 0x66666666);
 }

src/core/services/ptm.cpp

@@ -5,6 +5,7 @@ namespace PTMCommands {
 	enum : u32 {
 		GetAdapterState = 0x00050000,
 		GetBatteryLevel = 0x00070000,
+		GetBatteryChargeState = 0x00080000,
 		GetStepHistory = 0x000B00C2,
 		GetTotalStepCount = 0x000C0000,
 		ConfigureNew3DSCPU = 0x08180040,
@@ -18,6 +19,7 @@ void PTMService::handleSyncRequest(u32 messagePointer) {
 	switch (command) {
 		case PTMCommands::ConfigureNew3DSCPU: configureNew3DSCPU(messagePointer); break;
 		case PTMCommands::GetAdapterState: getAdapterState(messagePointer); break;
+		case PTMCommands::GetBatteryChargeState: getBatteryChargeState(messagePointer); break;
 		case PTMCommands::GetBatteryLevel: getBatteryLevel(messagePointer); break;
 		case PTMCommands::GetStepHistory: getStepHistory(messagePointer); break;
 		case PTMCommands::GetTotalStepCount: getTotalStepCount(messagePointer); break;
@@ -33,6 +35,16 @@ void PTMService::getAdapterState(u32 messagePointer) {
 	mem.write8(messagePointer + 8, config.chargerPlugged ? 1 : 0);
 }
 
+void PTMService::getBatteryChargeState(u32 messagePointer) {
+	log("PTM::GetBatteryChargeState");
+	// We're only charging if the battery is not already full
+	const bool charging = config.chargerPlugged && (config.batteryPercentage < 100);
+
+	mem.write32(messagePointer, IPC::responseHeader(0x7, 2, 0));
+	mem.write32(messagePointer + 4, Result::Success);
+	mem.write8(messagePointer + 8, charging ? 1 : 0);
+}
+
 void PTMService::getBatteryLevel(u32 messagePointer) {
 	log("PTM::GetBatteryLevel");
 

src/core/services/service_manager.cpp

@@ -7,7 +7,7 @@
 
 ServiceManager::ServiceManager(std::span<u32, 16> regs, Memory& mem, GPU& gpu, u32& currentPID, Kernel& kernel, const EmulatorConfig& config)
 	: regs(regs), mem(mem), kernel(kernel), ac(mem), am(mem), boss(mem), act(mem), apt(mem, kernel), cam(mem, kernel), cecd(mem, kernel), cfg(mem),
-	  dlp_srvr(mem), dsp(mem, kernel), hid(mem, kernel), http(mem), ir_user(mem, kernel), frd(mem), fs(mem, kernel),
+	  dlp_srvr(mem), dsp(mem, kernel), hid(mem, kernel), http(mem), ir_user(mem, kernel), frd(mem), fs(mem, kernel, config),
 	  gsp_gpu(mem, gpu, kernel, currentPID), gsp_lcd(mem), ldr(mem), mcu_hwc(mem, config), mic(mem, kernel), nfc(mem, kernel), nim(mem), ndm(mem),
 	  news_u(mem), ptm(mem, config), soc(mem), ssl(mem), y2r(mem, kernel) {}