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

Merge pull request #164 from wheremyfoodat/yoshee

Browse source 
HLE improvements for Chibi-Robo et al
This commit is contained in:
wheremyfoodat 2023-08-09 04:11:56 +03:00 • committed by GitHub
commit f139c8e810
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
13 changed files with 149 additions and 7 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
CMakeLists.txt
View file

@ -134,7 +134,7 @@ set(SERVICE_SOURCE_FILES src/core/services/service_manager.cpp src/core/services
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/dlp_srvr.cpp
src/core/services/ir_user.cpp
src/core/services/ir_user.cpp src/core/services/http.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 src/core/PICA/dynapica/shader_rec.cpp
@ -174,7 +174,7 @@ set(HEADER_FILES include/emulator.hpp include/helpers.hpp include/termcolor.hpp
include/crypto/aes_engine.hpp include/metaprogramming.hpp include/PICA/pica_vertex.hpp
include/config.hpp include/services/ir_user.hpp include/http_server.hpp include/cheats.hpp
include/action_replay.hpp include/renderer_sw/renderer_sw.hpp include/compiler_builtins.hpp
include/fs/romfs.hpp include/fs/ivfc.hpp include/discord_rpc.hpp
include/fs/romfs.hpp include/fs/ivfc.hpp include/discord_rpc.hpp include/services/http.hpp include/result/result_cfg.hpp
)
set(THIRD_PARTY_SOURCE_FILES third_party/imgui/imgui.cpp

4
include/kernel/handles.hpp
View file

@ -20,7 +20,8 @@ namespace KernelHandles {
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)
HID, // HID service (Handles input-related things including gyro. Does NOT handle New3DS controls or CirclePadPro)
HTTP, // HTTP service (Handles HTTP requests)
IR_USER, // One of 3 infrared communication services
FRD, // Friend service (Miiverse friend service)
FS, // Filesystem service
@ -69,6 +70,7 @@ namespace KernelHandles {
case DSP: return "DSP";
case DLP_SRVR: return "DLP::SRVR";
case HID: return "HID";
case HTTP: return "HTTP";
case IR_USER: return "IR:USER";
case FRD: return "FRD";
case FS: return "FS";

1
include/logger.hpp
View file

@ -43,6 +43,7 @@ namespace Log {
static Logger<false> frdLogger;
static Logger<false> fsLogger;
static Logger<false> hidLogger;
static Logger<false> httpLogger;
static Logger<false> irUserLogger;
static Logger<false> gspGPULogger;
static Logger<false> gspLCDLogger;

1
include/result/result.hpp
View file

@ -1,5 +1,6 @@
#pragma once
#include "result_cfg.hpp"
#include "result_common.hpp"
#include "result_kernel.hpp"
#include "result_os.hpp"

8
include/result/result_cfg.hpp Normal file
View file

@ -0,0 +1,8 @@
#pragma once
#include "result_common.hpp"
DEFINE_HORIZON_RESULT_MODULE(Result::CFG, Config);
namespace Result::CFG {
DEFINE_HORIZON_RESULT(NotFound, 1018, WrongArgument, Permanent);
};

1
include/services/act.hpp
View file

@ -13,6 +13,7 @@ class ACTService {
// Service commands
void initialize(u32 messagePointer);
void generateUUID(u32 messagePointer);
void getAccountDataBlock(u32 messagePointer);
public:
ACTService(Memory& mem) : mem(mem) {}

1
include/services/cfg.hpp
View file

@ -16,6 +16,7 @@ class CFGService {
// Service functions
void getConfigInfoBlk2(u32 messagePointer);
void getCountryCodeID(u32 messagePointer);
void getRegionCanadaUSA(u32 messagePointer);
void getSystemModel(u32 messagePointer);
void genUniqueConsoleHash(u32 messagePointer);

21
include/services/http.hpp Normal file
View file

@ -0,0 +1,21 @@
#pragma once
#include "helpers.hpp"
#include "kernel_types.hpp"
#include "logger.hpp"
#include "memory.hpp"
class HTTPService {
Handle handle = KernelHandles::HTTP;
Memory& mem;
MAKE_LOG_FUNCTION(log, httpLogger)
bool initialized = false;
// Service commands
void initialize(u32 messagePointer);
public:
HTTPService(Memory& mem) : mem(mem) {}
void reset();
void handleSyncRequest(u32 messagePointer);
};

2
include/services/service_manager.hpp
View file

@ -21,6 +21,7 @@
#include "services/gsp_gpu.hpp"
#include "services/gsp_lcd.hpp"
#include "services/hid.hpp"
#include "services/http.hpp"
#include "services/ir_user.hpp"
#include "services/ldr_ro.hpp"
#include "services/mic.hpp"
@ -53,6 +54,7 @@ class ServiceManager {
DlpSrvrService dlp_srvr;
DSPService dsp;
HIDService hid;
HTTPService http;
IRUserService ir_user;
FRDService frd;
FSService fs;

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);
}

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;