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 pull request #158 from wheremyfoodat/mii_selector

Browse source 
Initial work on HLE applets
This commit is contained in:
wheremyfoodat 2023-08-24 01:54:21 +03:00 • committed by GitHub
commit 3908900bca
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
13 changed files with 283 additions and 6 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -9,10 +9,15 @@ namespace APTCommands {
GetLockHandle = 0x00010040,
Initialize = 0x00020080,
Enable = 0x00030040,
GetAppletInfo = 0x00060040,
IsRegistered = 0x00090040,
InquireNotification = 0x000B0040,
SendParameter = 0x000C0104,
ReceiveParameter = 0x000D0080,
GlanceParameter = 0x000E0080,
PreloadLibraryApplet = 0x00160040,
PrepareToStartLibraryApplet = 0x00180040,
StartLibraryApplet = 0x001E0084,
ReplySleepQuery = 0x003E0080,
NotifyToWait = 0x00430040,
GetSharedFont = 0x00440000,
@ -60,6 +65,8 @@ void APTService::reset() {
lockHandle = std::nullopt;
notificationEvent = std::nullopt;
resumeEvent = std::nullopt;
appletManager.reset();
}
void APTService::handleSyncRequest(u32 messagePointer) {
@ -69,22 +76,26 @@ void APTService::handleSyncRequest(u32 messagePointer) {
case APTCommands::CheckNew3DS: checkNew3DS(messagePointer); break;
case APTCommands::CheckNew3DSApp: checkNew3DSApp(messagePointer); break;
case APTCommands::Enable: enable(messagePointer); break;
case APTCommands::GetAppletInfo: getAppletInfo(messagePointer); break;
case APTCommands::GetSharedFont: getSharedFont(messagePointer); break;
case APTCommands::Initialize: initialize(messagePointer); break;
case APTCommands::InquireNotification: [[likely]] inquireNotification(messagePointer); break;
case APTCommands::IsRegistered: isRegistered(messagePointer); break;
case APTCommands::GetApplicationCpuTimeLimit: getApplicationCpuTimeLimit(messagePointer); break;
case APTCommands::GetLockHandle: getLockHandle(messagePointer); break;
case APTCommands::GetWirelessRebootInfo: getWirelessRebootInfo(messagePointer); break;
case APTCommands::GlanceParameter: glanceParameter(messagePointer); break;
case APTCommands::NotifyToWait: notifyToWait(messagePointer); break;
case APTCommands::PreloadLibraryApplet: preloadLibraryApplet(messagePointer); break;
case APTCommands::PrepareToStartLibraryApplet: prepareToStartLibraryApplet(messagePointer); break;
case APTCommands::ReceiveParameter: [[likely]] receiveParameter(messagePointer); break;
case APTCommands::ReplySleepQuery: replySleepQuery(messagePointer); break;
case APTCommands::SetApplicationCpuTimeLimit: setApplicationCpuTimeLimit(messagePointer); break;
case APTCommands::SendParameter: sendParameter(messagePointer); break;
case APTCommands::SetScreencapPostPermission: setScreencapPostPermission(messagePointer); break;
case APTCommands::TheSmashBrosFunction: theSmashBrosFunction(messagePointer); break;
default:
Helpers::panicDev("APT service requested. Command: %08X\n", command);
Helpers::panic("APT service requested. Command: %08X\n", command);
mem.write32(messagePointer + 4, Result::Success);
break;
}
@ -116,9 +127,38 @@ void APTService::appletUtility(u32 messagePointer) {
}
}
void APTService::getAppletInfo(u32 messagePointer) {
const u32 appID = mem.read32(messagePointer + 4);
Helpers::warn("APT::GetAppletInfo (appID = %X)\n", appID);
mem.write32(messagePointer, IPC::responseHeader(0x06, 7, 0));
mem.write32(messagePointer + 4, Result::Success);
mem.write8(messagePointer + 20, 1); // 1 = registered
mem.write8(messagePointer + 24, 1); // 1 = loaded
// TODO: The rest of this
}
void APTService::isRegistered(u32 messagePointer) {
const u32 appID = mem.read32(messagePointer + 4);
Helpers::warn("APT::IsRegistered (appID = %X)", appID);
mem.write32(messagePointer, IPC::responseHeader(0x09, 2, 0));
mem.write32(messagePointer + 4, Result::Success);
mem.write8(messagePointer + 8, 1); // Return that the app is always registered. This might break with home menu?
}
void APTService::preloadLibraryApplet(u32 messagePointer) {
const u32 appID = mem.read32(messagePointer + 4);
log("APT::PreloadLibraryApplet (app ID = %d) (stubbed)\n", appID);
log("APT::PreloadLibraryApplet (app ID = %X) (stubbed)\n", appID);
mem.write32(messagePointer, IPC::responseHeader(0x16, 1, 0));
mem.write32(messagePointer + 4, Result::Success);
}
void APTService::prepareToStartLibraryApplet(u32 messagePointer) {
const u32 appID = mem.read32(messagePointer + 4);
log("APT::PrepareToStartLibraryApplet (app ID = %X) (stubbed)\n", appID);
mem.write32(messagePointer, IPC::responseHeader(0x16, 1, 0));
mem.write32(messagePointer + 4, Result::Success);
@ -193,6 +233,35 @@ void APTService::notifyToWait(u32 messagePointer) {
mem.write32(messagePointer + 4, Result::Success);
}
void APTService::sendParameter(u32 messagePointer) {
const u32 sourceAppID = mem.read32(messagePointer + 4);
const u32 destAppID = mem.read32(messagePointer + 8);
const u32 cmd = mem.read32(messagePointer + 12);
const u32 paramSize = mem.read32(messagePointer + 16);
const u32 parameterHandle = mem.read32(messagePointer + 24); // What dis?
const u32 parameterPointer = mem.read32(messagePointer + 32);
log("APT::SendParameter (source app = %X, dest app = %X, cmd = %X, size = %X) (Stubbed)", sourceAppID, destAppID, cmd, paramSize);
mem.write32(messagePointer, IPC::responseHeader(0x0C, 1, 0));
mem.write32(messagePointer + 4, Result::Success);
if (sourceAppID != Applets::AppletIDs::Application) {
Helpers::warn("APT::SendParameter: Unimplemented source applet ID");
}
Applets::AppletBase* destApplet = appletManager.getApplet(destAppID);
if (destApplet == nullptr) {
Helpers::warn("APT::SendParameter: Unimplemented dest applet ID");
} else {
auto result = destApplet->receiveParameter();
}
if (resumeEvent.has_value()) {
kernel.signalEvent(resumeEvent.value());
}
}
void APTService::receiveParameter(u32 messagePointer) {
const u32 app = mem.read32(messagePointer + 4);
const u32 size = mem.read32(messagePointer + 8);

23
src/core/services/gsp_gpu.cpp
View file

@ -15,6 +15,8 @@ namespace ServiceCommands {
FlushDataCache = 0x00080082,
SetLCDForceBlack = 0x000B0040,
TriggerCmdReqQueue = 0x000C0000,
ImportDisplayCaptureInfo = 0x00180000,
SaveVramSysArea = 0x00190000,
SetInternalPriorities = 0x001E0080,
StoreDataCache = 0x001F0082
};
@ -42,15 +44,17 @@ void GPUService::reset() {
void GPUService::handleSyncRequest(u32 messagePointer) {
const u32 command = mem.read32(messagePointer);
switch (command) {
case ServiceCommands::TriggerCmdReqQueue: [[likely]] triggerCmdReqQueue(messagePointer); break;
case ServiceCommands::AcquireRight: acquireRight(messagePointer); break;
case ServiceCommands::FlushDataCache: flushDataCache(messagePointer); break;
case ServiceCommands::ImportDisplayCaptureInfo: importDisplayCaptureInfo(messagePointer); break;
case ServiceCommands::RegisterInterruptRelayQueue: registerInterruptRelayQueue(messagePointer); break;
case ServiceCommands::SaveVramSysArea: saveVramSysArea(messagePointer); break;
case ServiceCommands::SetAxiConfigQoSMode: setAxiConfigQoSMode(messagePointer); break;
case ServiceCommands::SetBufferSwap: setBufferSwap(messagePointer); break;
case ServiceCommands::SetInternalPriorities: setInternalPriorities(messagePointer); break;
case ServiceCommands::SetLCDForceBlack: setLCDForceBlack(messagePointer); break;
case ServiceCommands::StoreDataCache: storeDataCache(messagePointer); break;
case ServiceCommands::TriggerCmdReqQueue: [[likely]] triggerCmdReqQueue(messagePointer); break;
case ServiceCommands::WriteHwRegs: writeHwRegs(messagePointer); break;
case ServiceCommands::WriteHwRegsWithMask: writeHwRegsWithMask(messagePointer); break;
default: Helpers::panic("GPU service requested. Command: %08X\n", command);
@ -456,3 +460,20 @@ void GPUService::triggerTextureCopy(u32* cmd) {
// NSMB2 relies on this
requestInterrupt(GPUInterrupt::PPF);
}
// Used when transitioning from the app to an OS applet, such as software keyboard, mii maker, mii selector, etc
// Stubbed until we decide to support LLE applets
void GPUService::saveVramSysArea(u32 messagePointer) {
Helpers::warn("GSP::GPU::SaveVramSysArea (stubbed)");
mem.write32(messagePointer, IPC::responseHeader(0x19, 1, 0));
mem.write32(messagePointer + 4, Result::Success);
}
// Used in similar fashion to the SaveVramSysArea function
void GPUService::importDisplayCaptureInfo(u32 messagePointer) {
Helpers::warn("GSP::GPU::ImportDisplayCaptureInfo (stubbed)");
mem.write32(messagePointer, IPC::responseHeader(0x18, 9, 0));
mem.write32(messagePointer + 4, Result::Success);
}