Merge pull request #194 from wheremyfoodat/services

BOSS/CECD stuff

include/services/boss.hpp

@@ -19,8 +19,10 @@ class BOSSService {
 	void getTaskIdList(u32 messagePointer);
 	void getTaskInfo(u32 messagePointer);
 	void getTaskState(u32 messagePointer);
+	void getTaskStatus(u32 messagePointer);
 	void getTaskStorageInfo(u32 messagePointer);
 	void receiveProperty(u32 messagePointer);
+	void registerNewArrivalEvent(u32 messagePointer);
 	void registerStorageEntry(u32 messagePointer);
 	void unregisterStorage(u32 messagePointer);
 	void unregisterTask(u32 messagePointer);

include/services/cecd.hpp

@@ -18,6 +18,7 @@ class CECDService {
 
 	// Service commands
 	void getInfoEventHandle(u32 messagePointer);
+	void openAndRead(u32 messagePointer);
 
 public:
 	CECDService(Memory& mem, Kernel& kernel) : mem(mem), kernel(kernel) {}

src/core/services/boss.cpp

@@ -6,6 +6,7 @@ namespace BOSSCommands {
 		InitializeSession = 0x00010082,
 		UnregisterStorage = 0x00030000,
 		GetTaskStorageInfo = 0x00040000,
+		RegisterNewArrivalEvent = 0x00080002,
 		GetOptoutFlag = 0x000A0000,
 		UnregisterTask = 0x000C0082,
 		GetTaskIdList = 0x000E0000,
@@ -13,6 +14,7 @@ namespace BOSSCommands {
 		ReceiveProperty = 0x00160082,
 		CancelTask = 0x001E0042,
 		GetTaskState = 0x00200082,
+		GetTaskStatus = 0x002300C2,
 		GetTaskInfo = 0x00250082,
 		RegisterStorageEntry = 0x002F0140,
 		GetStorageEntryInfo = 0x00300000,
@@ -33,9 +35,11 @@ void BOSSService::handleSyncRequest(u32 messagePointer) {
 		case BOSSCommands::GetTaskIdList: getTaskIdList(messagePointer); break;
 		case BOSSCommands::GetTaskInfo: getTaskInfo(messagePointer); break;
 		case BOSSCommands::GetTaskState: getTaskState(messagePointer); break;
+		case BOSSCommands::GetTaskStatus: getTaskStatus(messagePointer); break;
 		case BOSSCommands::GetTaskStorageInfo: getTaskStorageInfo(messagePointer); break;
 		case BOSSCommands::InitializeSession: initializeSession(messagePointer); break;
 		case BOSSCommands::ReceiveProperty: receiveProperty(messagePointer); break;
+		case BOSSCommands::RegisterNewArrivalEvent: registerNewArrivalEvent(messagePointer); break;
 		case BOSSCommands::RegisterStorageEntry: registerStorageEntry(messagePointer); break;
 		case BOSSCommands::UnregisterStorage: unregisterStorage(messagePointer); break;
 		case BOSSCommands::UnregisterTask: unregisterTask(messagePointer); break;
@@ -68,6 +72,17 @@ void BOSSService::getTaskState(u32 messagePointer) {
 	mem.write8(messagePointer + 16, 0);  // TODO: Figure out what this should be
 }
 
+void BOSSService::getTaskStatus(u32 messagePointer) {
+	// TODO: 3DBrew does not mention what the parameters are, or what the return values are.
+	log("BOSS::GetTaskStatus (Stubbed)\n");
+
+	// Response values stubbed based on Citra
+	mem.write32(messagePointer, IPC::responseHeader(0x23, 2, 2));
+	mem.write32(messagePointer + 4, Result::Success);
+	mem.write8(messagePointer + 8, 0);
+	// TODO: Citra pushes a buffer here?
+}
+
 void BOSSService::getTaskStorageInfo(u32 messagePointer) {
 	log("BOSS::GetTaskStorageInfo (stubbed)\n");
 	mem.write32(messagePointer, IPC::responseHeader(0x4, 2, 0));
@@ -109,6 +124,16 @@ void BOSSService::receiveProperty(u32 messagePointer) {
 	mem.write32(messagePointer + 8, 0); // Read size
 }
 
+// This seems to accept a KEvent as a parameter and register it for something Spotpass related
+// I need to update the 3DBrew page when it's known what it does properly
+void BOSSService::registerNewArrivalEvent(u32 messagePointer) {
+	const Handle eventHandle = mem.read32(messagePointer + 4); // Kernel event handle to register
+	log("BOSS::RegisterNewArrivalEvent (handle = %X)\n", eventHandle);
+
+	mem.write32(messagePointer, IPC::responseHeader(0x8, 1, 0));
+	mem.write32(messagePointer + 4, Result::Success);
+}
+
 void BOSSService::cancelTask(u32 messagePointer) {
 	log("BOSS::CancelTask (stubbed)\n");
 	mem.write32(messagePointer, IPC::responseHeader(0x1E, 1, 2));

src/core/services/cecd.cpp

@@ -1,21 +1,22 @@
 #include "services/cecd.hpp"
+
 #include "ipc.hpp"
 #include "kernel.hpp"
 
 namespace CECDCommands {
 	enum : u32 {
-		GetInfoEventHandle = 0x000F0000
+		GetInfoEventHandle = 0x000F0000,
+		OpenAndRead = 0x00120104,
 	};
 }
 
-void CECDService::reset() {
+void CECDService::reset() { infoEvent = std::nullopt; }
-	infoEvent = std::nullopt;
-}
 
 void CECDService::handleSyncRequest(u32 messagePointer) {
 	const u32 command = mem.read32(messagePointer);
 	switch (command) {
 		case CECDCommands::GetInfoEventHandle: getInfoEventHandle(messagePointer); break;
+		case CECDCommands::OpenAndRead: openAndRead(messagePointer); break;
 		default:
 			Helpers::panicDev("CECD service requested. Command: %08X\n", command);
 			mem.write32(messagePointer + 4, Result::Success);
@@ -34,4 +35,17 @@ void CECDService::getInfoEventHandle(u32 messagePointer) {
 	mem.write32(messagePointer + 4, Result::Success);
 	// TODO: Translation descriptor here?
 	mem.write32(messagePointer + 12, infoEvent.value());
+}
+
+void CECDService::openAndRead(u32 messagePointer) {
+	const u32 bufferSize = mem.read32(messagePointer + 4);
+	const u32 programID = mem.read32(messagePointer + 8);
+	const u32 pathType = mem.read32(messagePointer + 12);
+	const u32 bufferAddress = mem.read32(messagePointer + 32);
+	log("CECD::OpenAndRead (size = %08X, address = %08X, path type = %d)\n", bufferSize, bufferAddress, pathType);
+
+	// TODO: We should implement this properly the time comes
+	mem.write32(messagePointer, IPC::responseHeader(0x12, 2, 2));
+	mem.write32(messagePointer + 4, Result::Success);
+	mem.write32(messagePointer + 8, 0); // Bytes read
 }