Diamond75/Panda3DS
1
0
Fork 0
mirror of https://github.com/wheremyfoodat/Panda3DS.git synced 2025-04-20 20:49:12 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'master' into mii_selector

Browse source
This commit is contained in:
wheremyfoodat 2023-08-10 12:18:43 +03:00
commit f614bcb005
26 changed files with 310 additions and 17 deletions
Download patch file Download diff file Expand all files Collapse all files

17
src/core/services/act.cpp
View file

@ -4,7 +4,8 @@
namespace ACTCommands {
enum : u32 {
Initialize = 0x00010084,
GenerateUUID = 0x000D0040
GetAccountDataBlock = 0x000600C2,
GenerateUUID = 0x000D0040,
};
}
@ -14,6 +15,7 @@ void ACTService::handleSyncRequest(u32 messagePointer) {
const u32 command = mem.read32(messagePointer);
switch (command) {
case ACTCommands::GenerateUUID: generateUUID(messagePointer); break;
case ACTCommands::GetAccountDataBlock: getAccountDataBlock(messagePointer); break;
case ACTCommands::Initialize: initialize(messagePointer); break;
default: Helpers::panic("ACT service requested. Command: %08X\n", command);
}
@ -32,4 +34,17 @@ void ACTService::generateUUID(u32 messagePointer) {
// TODO: The header is probably wrong
mem.write32(messagePointer, IPC::responseHeader(0xD, 1, 0));
mem.write32(messagePointer + 4, Result::Success);
}
void ACTService::getAccountDataBlock(u32 messagePointer) {
log("ACT::GetAccountDataBlock (stubbed)\n");
const u32 size = mem.read32(messagePointer + 8);
const u32 blkID = mem.read32(messagePointer + 12);
const u32 outputPointer = mem.read32(messagePointer + 20);
// TODO: This header is probably also wrong
// Also we need to populate the data block here. Half of it is undocumented though >_<
mem.write32(messagePointer, IPC::responseHeader(0x6, 1, 0));
mem.write32(messagePointer + 4, Result::Success);
}

4
src/core/services/apt.cpp
View file

@ -299,7 +299,7 @@ void APTService::getApplicationCpuTimeLimit(u32 messagePointer) {
void APTService::setScreencapPostPermission(u32 messagePointer) {
u32 perm = mem.read32(messagePointer + 4);
log("APT::SetScreencapPostPermission (perm = %d)\n");
log("APT::SetScreencapPostPermission (perm = %d)\n", perm);
mem.write32(messagePointer, IPC::responseHeader(0x55, 1, 0));
// Apparently only 1-3 are valid values, but I see 0 used in some games like Pokemon Rumble
@ -339,4 +339,4 @@ void APTService::getWirelessRebootInfo(u32 messagePointer) {
for (u32 i = 0; i < size; i++) {
mem.write8(messagePointer + 0x104 + i, 0); // Temporarily stub this until we add SetWirelessRebootInfo
}
}
}

8
src/core/services/boss.cpp
View file

@ -11,6 +11,7 @@ namespace BOSSCommands {
GetTaskIdList = 0x000E0000,
GetNsDataIdList = 0x00100102,
ReceiveProperty = 0x00160082,
CancelTask = 0x001E0042,
GetTaskInfo = 0x00250082,
RegisterStorageEntry = 0x002F0140,
GetStorageEntryInfo = 0x00300000
@ -24,6 +25,7 @@ void BOSSService::reset() {
void BOSSService::handleSyncRequest(u32 messagePointer) {
const u32 command = mem.read32(messagePointer);
switch (command) {
case BOSSCommands::CancelTask: cancelTask(messagePointer); break;
case BOSSCommands::GetNsDataIdList: getNsDataIdList(messagePointer); break;
case BOSSCommands::GetOptoutFlag: getOptoutFlag(messagePointer); break;
case BOSSCommands::GetStorageEntryInfo: getStorageEntryInfo(messagePointer); break;
@ -93,6 +95,12 @@ void BOSSService::receiveProperty(u32 messagePointer) {
mem.write32(messagePointer + 8, 0); // Read size
}
void BOSSService::cancelTask(u32 messagePointer) {
log("BOSS::CancelTask (stubbed)\n");
mem.write32(messagePointer, IPC::responseHeader(0x1E, 1, 2));
mem.write32(messagePointer + 4, Result::Success);
}
void BOSSService::unregisterTask(u32 messagePointer) {
log("BOSS::UnregisterTask (stubbed)\n");
mem.write32(messagePointer, IPC::responseHeader(0x0C, 1, 2));

47
src/core/services/cfg.cpp
View file

@ -5,6 +5,8 @@
#include <array>
#include <bit>
#include <string>
#include <unordered_map>
namespace CFGCommands {
enum : u32 {
@ -12,7 +14,8 @@ namespace CFGCommands {
SecureInfoGetRegion = 0x00020000,
GenHashConsoleUnique = 0x00030040,
GetRegionCanadaUSA = 0x00040000,
GetSystemModel = 0x00050000
GetSystemModel = 0x00050000,
GetCountryCodeID = 0x000A0040,
};
}
@ -22,6 +25,7 @@ void CFGService::handleSyncRequest(u32 messagePointer) {
const u32 command = mem.read32(messagePointer);
switch (command) {
case CFGCommands::GetConfigInfoBlk2: [[likely]] getConfigInfoBlk2(messagePointer); break;
case CFGCommands::GetCountryCodeID: getCountryCodeID(messagePointer); break;
case CFGCommands::GetRegionCanadaUSA: getRegionCanadaUSA(messagePointer); break;
case CFGCommands::GetSystemModel: getSystemModel(messagePointer); break;
case CFGCommands::GenHashConsoleUnique: genUniqueConsoleHash(messagePointer); break;
@ -115,6 +119,8 @@ void CFGService::getConfigInfoBlk2(u32 messagePointer) {
for (u32 i = 0; i < size; i += 4) {
mem.write32(output + i, 0);
}
} else if (size == 4 && blockID == 0x170000) { // Miiverse access key
mem.write32(output, 0);
} else {
Helpers::panic("Unhandled GetConfigInfoBlk2 configuration. Size = %d, block = %X", size, blockID);
}
@ -152,4 +158,43 @@ void CFGService::getRegionCanadaUSA(u32 messagePointer) {
mem.write32(messagePointer, IPC::responseHeader(0x4, 2, 0));
mem.write32(messagePointer + 4, Result::Success);
mem.write8(messagePointer + 8, ret);
}
constexpr u16 C(const char name[3]) { return name[0] | (name[1] << 8); }
static std::unordered_map<u16, u16> countryCodeToTableIDMap = {
{C("JP"), 1}, {C("AI"), 8}, {C("AG"), 9}, {C("AR"), 10}, {C("AW"), 11}, {C("BS"), 12}, {C("BB"), 13}, {C("BZ"), 14}, {C("BO"), 15},
{C("BR"), 16}, {C("VG"), 17}, {C("CA"), 18}, {C("KY"), 19}, {C("CL"), 20}, {C("CO"), 21}, {C("CR"), 22}, {C("DM"), 23}, {C("DO"), 24},
{C("EC"), 25}, {C("SV"), 26}, {C("GF"), 27}, {C("GD"), 28}, {C("GP"), 29}, {C("GT"), 30}, {C("GY"), 31}, {C("HT"), 32}, {C("HN"), 33},
{C("JM"), 34}, {C("MQ"), 35}, {C("MX"), 36}, {C("MS"), 37}, {C("AN"), 38}, {C("NI"), 39}, {C("PA"), 40}, {C("PY"), 41}, {C("PE"), 42},
{C("KN"), 43}, {C("LC"), 44}, {C("VC"), 45}, {C("SR"), 46}, {C("TT"), 47}, {C("TC"), 48}, {C("US"), 49}, {C("UY"), 50}, {C("VI"), 51},
{C("VE"), 52}, {C("AL"), 64}, {C("AU"), 65}, {C("AT"), 66}, {C("BE"), 67}, {C("BA"), 68}, {C("BW"), 69}, {C("BG"), 70}, {C("HR"), 71},
{C("CY"), 72}, {C("CZ"), 73}, {C("DK"), 74}, {C("EE"), 75}, {C("FI"), 76}, {C("FR"), 77}, {C("DE"), 78}, {C("GR"), 79}, {C("HU"), 80},
{C("IS"), 81}, {C("IE"), 82}, {C("IT"), 83}, {C("LV"), 84}, {C("LS"), 85}, {C("LI"), 86}, {C("LT"), 87}, {C("LU"), 88}, {C("MK"), 89},
{C("MT"), 90}, {C("ME"), 91}, {C("MZ"), 92}, {C("NA"), 93}, {C("NL"), 94}, {C("NZ"), 95}, {C("NO"), 96}, {C("PL"), 97}, {C("PT"), 98},
{C("RO"), 99}, {C("RU"), 100}, {C("RS"), 101}, {C("SK"), 102}, {C("SI"), 103}, {C("ZA"), 104}, {C("ES"), 105}, {C("SZ"), 106}, {C("SE"), 107},
{C("CH"), 108}, {C("TR"), 109}, {C("GB"), 110}, {C("ZM"), 111}, {C("ZW"), 112}, {C("AZ"), 113}, {C("MR"), 114}, {C("ML"), 115}, {C("NE"), 116},
{C("TD"), 117}, {C("SD"), 118}, {C("ER"), 119}, {C("DJ"), 120}, {C("SO"), 121}, {C("AD"), 122}, {C("GI"), 123}, {C("GG"), 124}, {C("IM"), 125},
{C("JE"), 126}, {C("MC"), 127}, {C("TW"), 128}, {C("KR"), 136}, {C("HK"), 144}, {C("MO"), 145}, {C("ID"), 152}, {C("SG"), 153}, {C("TH"), 154},
{C("PH"), 155}, {C("MY"), 156}, {C("CN"), 160}, {C("AE"), 168}, {C("IN"), 169}, {C("EG"), 170}, {C("OM"), 171}, {C("QA"), 172}, {C("KW"), 173},
{C("SA"), 174}, {C("SY"), 175}, {C("BH"), 176}, {C("JO"), 177}, {C("SM"), 184}, {C("VA"), 185}, {C("BM"), 186},
};
void CFGService::getCountryCodeID(u32 messagePointer) {
// Read the character code as a u16 instead of as ASCII, and use it to index the unordered_map above and get the result
const u16 characterCode = mem.read16(messagePointer + 4);
log("CFG::GetCountryCodeID (code = %04X)\n", characterCode);
mem.write32(messagePointer, IPC::responseHeader(0x0A, 2, 0));
// If the character code is valid, return its table ID and a success code
if (auto search = countryCodeToTableIDMap.find(characterCode); search != countryCodeToTableIDMap.end()) {
mem.write32(messagePointer + 4, Result::Success);
mem.write16(messagePointer + 8, search->second);
}
else {
Helpers::warn("CFG::GetCountryCodeID: Invalid country code %X", characterCode);
mem.write32(messagePointer + 4, Result::CFG::NotFound);
mem.write16(messagePointer + 8, 0xFF);
}
}

42
src/core/services/http.cpp Normal file
View file

@ -0,0 +1,42 @@
#include "services/http.hpp"
#include "ipc.hpp"
#include "result/result.hpp"
namespace HTTPCommands {
enum : u32 {
Initialize = 0x00010044,
};
}
void HTTPService::reset() { initialized = false; }
void HTTPService::handleSyncRequest(u32 messagePointer) {
const u32 command = mem.read32(messagePointer);
switch (command) {
case HTTPCommands::Initialize: initialize(messagePointer); break;
default: Helpers::panic("HTTP service requested. Command: %08X\n", command);
}
}
void HTTPService::initialize(u32 messagePointer) {
const u32 postBufferSize = mem.read32(messagePointer + 4);
const u32 postMemoryBlockHandle = mem.read32(messagePointer + 20);
log("HTTP::Initialize (POST buffer size = %X, POST buffer memory block handle = %X)\n", postBufferSize, postMemoryBlockHandle);
mem.write32(messagePointer, IPC::responseHeader(0x01, 1, 0));
if (initialized) {
Helpers::warn("HTTP: Tried to initialize service while already initialized");
// TODO: Error code here
}
// 3DBrew: The provided POST buffer must be page-aligned (0x1000).
if (postBufferSize & 0xfff) {
Helpers::warn("HTTP: POST buffer size is not page-aligned");
}
initialized = true;
// We currently don't emulate HTTP properly. TODO: Prepare POST buffer here
mem.write32(messagePointer + 4, Result::Success);
}

7
src/core/services/service_manager.cpp
View file

@ -7,8 +7,8 @@
ServiceManager::ServiceManager(std::span<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),
dlp_srvr(mem), dsp(mem, kernel), hid(mem, kernel), ir_user(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) {}
dlp_srvr(mem), dsp(mem, kernel), hid(mem, kernel), http(mem), ir_user(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) {}
static constexpr int MAX_NOTIFICATION_COUNT = 16;
@ -25,6 +25,7 @@ void ServiceManager::reset() {
dlp_srvr.reset();
dsp.reset();
hid.reset();
http.reset();
ir_user.reset();
frd.reset();
fs.reset();
@ -98,6 +99,7 @@ static std::map<std::string, Handle> serviceMap = {
{ "dlp:SRVR", KernelHandles::DLP_SRVR },
{ "dsp::DSP", KernelHandles::DSP },
{ "hid:USER", KernelHandles::HID },
{ "http:C", KernelHandles::HTTP },
{ "ir:USER", KernelHandles::IR_USER },
{ "frd:u", KernelHandles::FRD },
{ "fs:USER", KernelHandles::FS },
@ -182,6 +184,7 @@ void ServiceManager::sendCommandToService(u32 messagePointer, Handle handle) {
case KernelHandles::CFG: cfg.handleSyncRequest(messagePointer); break;
case KernelHandles::DLP_SRVR: dlp_srvr.handleSyncRequest(messagePointer); break;
case KernelHandles::HID: hid.handleSyncRequest(messagePointer); break;
case KernelHandles::HTTP: http.handleSyncRequest(messagePointer); break;
case KernelHandles::IR_USER: ir_user.handleSyncRequest(messagePointer); break;
case KernelHandles::FRD: frd.handleSyncRequest(messagePointer); break;
case KernelHandles::LCD: gsp_lcd.handleSyncRequest(messagePointer); break;