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

Merge remote-tracking branch 'upstream/master' into CRO

Browse source
This commit is contained in:
Nomi 2023-09-10 22:23:27 +02:00
commit 08e092a28d
26 changed files with 859 additions and 15 deletions
Download patch file Download diff file Expand all files Collapse all files

11
src/core/services/amiibo_device.cpp Normal file
View file

@ -0,0 +1,11 @@
#include "services/amiibo_device.hpp"
void AmiiboDevice::reset() {
encrypted = false;
loaded = false;
}
// Load amiibo information from our raw 540 byte array
void AmiiboDevice::loadFromRaw() {
}

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

@ -21,7 +21,7 @@ namespace CFGCommands {
void CFGService::reset() {}
void CFGService::handleSyncRequest(u32 messagePointer) {
void CFGService::handleSyncRequest(u32 messagePointer, CFGService::Type type) {
const u32 command = mem.read32(messagePointer);
switch (command) {
case CFGCommands::GetConfigInfoBlk2: [[likely]] getConfigInfoBlk2(messagePointer); break;
@ -121,6 +121,8 @@ void CFGService::getConfigInfoBlk2(u32 messagePointer) {
}
} else if (size == 4 && blockID == 0x170000) { // Miiverse access key
mem.write32(output, 0);
} else if (size == 8 && blockID == 0x00090000) {
mem.write64(output, 0); // Some sort of key used with nwm::UDS::InitializeWithVersion
} else {
Helpers::panic("Unhandled GetConfigInfoBlk2 configuration. Size = %d, block = %X", size, blockID);
}

104
src/core/services/csnd.cpp Normal file
View file

@ -0,0 +1,104 @@
#include "services/csnd.hpp"
#include "ipc.hpp"
#include "kernel.hpp"
#include "result/result.hpp"
namespace CSNDCommands {
enum : u32 {
Initialize = 0x00010140,
ExecuteCommands = 0x00030040,
AcquireSoundChannels = 0x00050000,
};
}
void CSNDService::reset() {
csndMutex = std::nullopt;
initialized = false;
sharedMemory = nullptr;
sharedMemSize = 0;
}
void CSNDService::handleSyncRequest(u32 messagePointer) {
const u32 command = mem.read32(messagePointer);
switch (command) {
case CSNDCommands::AcquireSoundChannels: acquireSoundChannels(messagePointer); break;
case CSNDCommands::ExecuteCommands: executeCommands(messagePointer); break;
case CSNDCommands::Initialize: initialize(messagePointer); break;
default:
Helpers::warn("Unimplemented CSND service requested. Command: %08X\n", command);
mem.write32(messagePointer + 4, Result::Success);
break;
}
}
void CSNDService::acquireSoundChannels(u32 messagePointer) {
log("CSND::AcquireSoundChannels\n");
// The CSND service talks to the DSP using the DSP FIFO to negotiate what CSND channels are allocated to the DSP, and this seems to be channels 0-7 (usually). The rest are dedicated to CSND services.
// https://www.3dbrew.org/wiki/CSND_Services
constexpr u32 csndChannelMask = 0xFFFFFF00;
mem.write32(messagePointer, IPC::responseHeader(0x5, 2, 0));
mem.write32(messagePointer + 4, Result::Success);
mem.write32(messagePointer + 8, csndChannelMask);
}
void CSNDService::initialize(u32 messagePointer) {
u32 blockSize = mem.read32(messagePointer + 4);
const u32 offset0 = mem.read32(messagePointer + 8);
const u32 offset1 = mem.read32(messagePointer + 12);
const u32 offset2 = mem.read32(messagePointer + 16);
const u32 offset3 = mem.read32(messagePointer + 20);
log("CSND::Initialize (Block size = %08X, offset0 = %X, offset1 = %X, offset2 = %X, offset3 = %X)\n", blockSize, offset0, offset1, offset2, offset3);
// Align block size to 4KB. CSND shared memory block is currently stubbed to be 0x3000 == 12KB, so panic if this is more than requested
blockSize = (blockSize + 0xFFF) & ~0xFFF;
if (blockSize != 12_KB) {
Helpers::panic("Unhandled size for CSND shared memory block");
}
if (initialized) {
printf("CSND initialized twice\n");
}
if (!csndMutex.has_value()) {
csndMutex = kernel.makeMutex(false);
}
initialized = true;
sharedMemSize = blockSize;
mem.write32(messagePointer, IPC::responseHeader(0x1, 1, 3));
mem.write32(messagePointer + 4, Result::Success);
mem.write32(messagePointer + 8, 0x4000000);
mem.write32(messagePointer + 12, csndMutex.value());
mem.write32(messagePointer + 16, KernelHandles::CSNDSharedMemHandle);
}
void CSNDService::executeCommands(u32 messagePointer) {
const u32 offset = mem.read32(messagePointer + 4);
log("CSND::ExecuteCommands (command offset = %X)\n", offset);
mem.write32(messagePointer, IPC::responseHeader(0x5, 2, 0));
if (!sharedMemory) {
Helpers::warn("CSND::Execute commands without shared memory");
mem.write32(messagePointer + 4, Result::FailurePlaceholder);
return;
}
mem.write32(messagePointer + 4, Result::Success);
// This is initially zero when this command data is written by the user process, once the CSND module finishes processing the command this is set
// to 0x1. This flag is only set to value 1 for the first command(once processing for the entire command chain is finished) at the offset
// specified in the service command, not all type0 commands in the chain.
constexpr u32 commandListDoneOffset = 0x4;
// Make sure to not access OoB of the shared memory block when marking command list processing as finished
if (offset + commandListDoneOffset < sharedMemSize) {
sharedMemory[offset + commandListDoneOffset] = 1;
}
}

16
src/core/services/ndm.cpp
View file

@ -3,6 +3,8 @@
namespace NDMCommands {
enum : u32 {
EnterExclusiveState = 0x00010042,
ExitExclusiveState = 0x00020002,
OverrideDefaultDaemons = 0x00140040,
SuspendDaemons = 0x00060040,
ResumeDaemons = 0x00070040,
@ -17,6 +19,8 @@ void NDMService::reset() {}
void NDMService::handleSyncRequest(u32 messagePointer) {
const u32 command = mem.read32(messagePointer);
switch (command) {
case NDMCommands::EnterExclusiveState: enterExclusiveState(messagePointer); break;
case NDMCommands::ExitExclusiveState: exitExclusiveState(messagePointer); break;
case NDMCommands::ClearHalfAwakeMacFilter: clearHalfAwakeMacFilter(messagePointer); break;
case NDMCommands::OverrideDefaultDaemons: overrideDefaultDaemons(messagePointer); break;
case NDMCommands::ResumeDaemons: resumeDaemons(messagePointer); break;
@ -27,6 +31,18 @@ void NDMService::handleSyncRequest(u32 messagePointer) {
}
}
void NDMService::enterExclusiveState(u32 messagePointer) {
log("NDM::EnterExclusiveState (stubbed)\n");
mem.write32(messagePointer, IPC::responseHeader(0x1, 1, 0));
mem.write32(messagePointer + 4, Result::Success);
}
void NDMService::exitExclusiveState(u32 messagePointer) {
log("NDM::ExitExclusiveState (stubbed)\n");
mem.write32(messagePointer, IPC::responseHeader(0x2, 1, 0));
mem.write32(messagePointer + 4, Result::Success);
}
void NDMService::overrideDefaultDaemons(u32 messagePointer) {
log("NDM::OverrideDefaultDaemons (stubbed)\n");
mem.write32(messagePointer, IPC::responseHeader(0x14, 1, 0));

106
src/core/services/nfc.cpp
View file

@ -1,4 +1,5 @@
#include "services/nfc.hpp"
#include "io_file.hpp"
#include "ipc.hpp"
#include "kernel.hpp"
@ -9,15 +10,20 @@ namespace NFCCommands {
StartCommunication = 0x00030000,
StopCommunication = 0x00040000,
StartTagScanning = 0x00050040,
StopTagScanning = 0x00060000,
GetTagInRangeEvent = 0x000B0000,
GetTagOutOfRangeEvent = 0x000C0000,
GetTagState = 0x000D0000,
CommunicationGetStatus = 0x000F0000,
GetTagInfo = 0x00110000,
CommunicationGetResult = 0x00120000,
LoadAmiiboPartially = 0x001A0000,
GetModelInfo = 0x001B0000,
};
}
void NFCService::reset() {
device.reset();
tagInRangeEvent = std::nullopt;
tagOutOfRangeEvent = std::nullopt;
@ -29,19 +35,60 @@ void NFCService::reset() {
void NFCService::handleSyncRequest(u32 messagePointer) {
const u32 command = mem.read32(messagePointer);
switch (command) {
case NFCCommands::CommunicationGetResult: communicationGetResult(messagePointer); break;
case NFCCommands::CommunicationGetStatus: communicationGetStatus(messagePointer); break;
case NFCCommands::Initialize: initialize(messagePointer); break;
case NFCCommands::GetModelInfo: getModelInfo(messagePointer); break;
case NFCCommands::GetTagInfo: getTagInfo(messagePointer); break;
case NFCCommands::GetTagInRangeEvent: getTagInRangeEvent(messagePointer); break;
case NFCCommands::GetTagOutOfRangeEvent: getTagOutOfRangeEvent(messagePointer); break;
case NFCCommands::GetTagState: getTagState(messagePointer); break;
case NFCCommands::LoadAmiiboPartially: loadAmiiboPartially(messagePointer); break;
case NFCCommands::Shutdown: shutdown(messagePointer); break;
case NFCCommands::StartCommunication: startCommunication(messagePointer); break;
case NFCCommands::StartTagScanning: startTagScanning(messagePointer); break;
case NFCCommands::StopCommunication: stopCommunication(messagePointer); break;
case NFCCommands::StopTagScanning: stopTagScanning(messagePointer); break;
default: Helpers::panic("NFC service requested. Command: %08X\n", command);
}
}
bool NFCService::loadAmiibo(const std::filesystem::path& path) {
if (!initialized || tagStatus != TagStatus::Scanning) {
Helpers::warn("It's not the correct time to load an amiibo! Make sure to load amiibi when the game is searching for one!");
return false;
}
IOFile file(path, "rb");
if (!file.isOpen()) {
printf("Failed to open Amiibo file");
file.close();
return false;
}
auto [success, bytesRead] = file.readBytes(&device.raw, AmiiboDevice::tagSize);
if (!success || bytesRead != AmiiboDevice::tagSize) {
printf("Failed to read entire tag from Amiibo file: File might not be a proper amiibo file\n");
file.close();
return false;
}
device.loadFromRaw();
if (tagOutOfRangeEvent.has_value()) {
kernel.clearEvent(tagOutOfRangeEvent.value());
}
if (tagInRangeEvent.has_value()) {
kernel.signalEvent(tagInRangeEvent.value());
}
file.close();
return true;
}
void NFCService::initialize(u32 messagePointer) {
const u8 type = mem.read8(messagePointer + 4);
log("NFC::Initialize (type = %d)\n", type);
@ -100,7 +147,7 @@ void NFCService::getTagOutOfRangeEvent(u32 messagePointer) {
}
void NFCService::getTagState(u32 messagePointer) {
log("NFC::GetTagState");
log("NFC::GetTagState\n");
mem.write32(messagePointer, IPC::responseHeader(0xD, 2, 0));
mem.write32(messagePointer + 4, Result::Success);
@ -108,7 +155,7 @@ void NFCService::getTagState(u32 messagePointer) {
}
void NFCService::communicationGetStatus(u32 messagePointer) {
log("NFC::CommunicationGetStatus");
log("NFC::CommunicationGetStatus\n");
if (!initialized) {
Helpers::warn("NFC::CommunicationGetStatus: Old 3DS NFC Adapter not initialized\n");
@ -119,6 +166,21 @@ void NFCService::communicationGetStatus(u32 messagePointer) {
mem.write8(messagePointer + 8, static_cast<u32>(adapterStatus));
}
void NFCService::communicationGetResult(u32 messagePointer) {
log("NFC::CommunicationGetResult\n");
if (!initialized) {
Helpers::warn("NFC::CommunicationGetResult: Old 3DS NFC Adapter not initialized\n");
}
mem.write32(messagePointer, IPC::responseHeader(0x12, 2, 0));
mem.write32(messagePointer + 4, Result::Success);
// On N3DS: This always writes 0 here
// On O3DS with the NFC adapter: Returns a result code for NFC communication
mem.write32(messagePointer + 8, 0);
}
void NFCService::startCommunication(u32 messagePointer) {
log("NFC::StartCommunication\n");
// adapterStatus = Old3DSAdapterStatus::Active;
@ -130,12 +192,28 @@ void NFCService::startCommunication(u32 messagePointer) {
void NFCService::startTagScanning(u32 messagePointer) {
log("NFC::StartTagScanning\n");
if (!initialized) {
Helpers::warn("Scanning for NFC tags before NFC service is initialized");
}
tagStatus = TagStatus::Scanning;
mem.write32(messagePointer, IPC::responseHeader(0x5, 1, 0));
mem.write32(messagePointer + 4, Result::Success);
}
void NFCService::stopTagScanning(u32 messagePointer) {
log("NFC::StopTagScanning\n");
if (!initialized) {
Helpers::warn("Stopping scanning for NFC tags before NFC service is initialized");
}
tagStatus = TagStatus::Initialized;
mem.write32(messagePointer, IPC::responseHeader(0x6, 1, 0));
mem.write32(messagePointer + 4, Result::Success);
}
void NFCService::stopCommunication(u32 messagePointer) {
log("NFC::StopCommunication\n");
adapterStatus = Old3DSAdapterStatus::InitializationComplete;
@ -143,4 +221,28 @@ void NFCService::stopCommunication(u32 messagePointer) {
mem.write32(messagePointer, IPC::responseHeader(0x4, 1, 0));
mem.write32(messagePointer + 4, Result::Success);
}
void NFCService::getTagInfo(u32 messagePointer) {
log("NFC::GetTagInfo\n");
Helpers::warn("Unimplemented NFC::GetTagInfo");
mem.write32(messagePointer, IPC::responseHeader(0x11, 12, 0));
mem.write32(messagePointer + 4, Result::Success);
}
void NFCService::loadAmiiboPartially(u32 messagePointer) {
log("NFC::LoadAmiiboPartially\n");
Helpers::warn("Unimplemented NFC::LoadAmiiboPartially");
mem.write32(messagePointer, IPC::responseHeader(0x1A, 1, 0));
mem.write32(messagePointer + 4, Result::Success);
}
void NFCService::getModelInfo(u32 messagePointer) {
log("NFC::GetModelInfo\n");
Helpers::warn("Unimplemented NFC::GetModelInfo");
mem.write32(messagePointer, IPC::responseHeader(0x1B, 14, 0));
mem.write32(messagePointer + 4, Result::Success);
}

43
src/core/services/nwm_uds.cpp Normal file
View file

@ -0,0 +1,43 @@
#include "ipc.hpp"
#include "kernel.hpp"
#include "result/result.hpp"
#include "services/nwm_uds.hpp"
namespace NWMCommands {
enum : u32 {
InitializeWithVersion = 0x001B0302,
};
}
void NwmUdsService::reset() {
eventHandle = std::nullopt;
initialized = false;
}
void NwmUdsService::handleSyncRequest(u32 messagePointer) {
const u32 command = mem.read32(messagePointer);
switch (command) {
case NWMCommands::InitializeWithVersion: initializeWithVersion(messagePointer); break;
default: Helpers::panic("LCD service requested. Command: %08X\n", command);
}
}
void NwmUdsService::initializeWithVersion(u32 messagePointer) {
Helpers::warn("Initializing NWM::UDS (Local multiplayer, unimplemented)\n");
log("NWM::UDS::InitializeWithVersion\n");
if (!eventHandle.has_value()) {
eventHandle = kernel.makeEvent(ResetType::OneShot);
}
if (initialized) {
printf("NWM::UDS initialized twice\n");
}
initialized = true;
mem.write32(messagePointer + 4, Result::Success);
mem.write32(messagePointer + 8, 0);
mem.write32(messagePointer + 12, eventHandle.value());
}

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

@ -7,9 +7,9 @@
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, config),
gsp_gpu(mem, gpu, kernel, currentPID), gsp_lcd(mem), ldr(mem, kernel), 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) {}
csnd(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), nwm_uds(mem, kernel), ptm(mem, config), soc(mem), ssl(mem), y2r(mem, kernel) {}
static constexpr int MAX_NOTIFICATION_COUNT = 16;
@ -23,6 +23,7 @@ void ServiceManager::reset() {
cam.reset();
cecd.reset();
cfg.reset();
csnd.reset();
dlp_srvr.reset();
dsp.reset();
hid.reset();
@ -104,6 +105,7 @@ static std::map<std::string, Handle> serviceMap = {
{ "cecd:u", KernelHandles::CECD },
{ "cfg:u", KernelHandles::CFG_U },
{ "cfg:i", KernelHandles::CFG_I },
{ "csnd:SND", KernelHandles::CSND },
{ "dlp:SRVR", KernelHandles::DLP_SRVR },
{ "dsp::DSP", KernelHandles::DSP },
{ "hid:USER", KernelHandles::HID },
@ -119,12 +121,13 @@ static std::map<std::string, Handle> serviceMap = {
{ "ndm:u", KernelHandles::NDM },
{ "news:u", KernelHandles::NEWS_U },
{ "nfc:u", KernelHandles::NFC },
{ "nwm::UDS", KernelHandles::NWM_UDS },
{ "nim:aoc", KernelHandles::NIM },
{ "ptm:u", KernelHandles::PTM }, // TODO: ptm:u and ptm:sysm have very different command sets
{ "ptm:sysm", KernelHandles::PTM },
{ "soc:U", KernelHandles::SOC },
{ "ssl:C", KernelHandles::SSL },
{ "y2r:u", KernelHandles::Y2R }
{ "y2r:u", KernelHandles::Y2R },
};
// clang-format on
@ -201,7 +204,9 @@ void ServiceManager::sendCommandToService(u32 messagePointer, Handle handle) {
case KernelHandles::BOSS: boss.handleSyncRequest(messagePointer); break;
case KernelHandles::CAM: cam.handleSyncRequest(messagePointer); break;
case KernelHandles::CECD: cecd.handleSyncRequest(messagePointer); break;
case KernelHandles::CFG_U: cfg.handleSyncRequest(messagePointer); break;
case KernelHandles::CFG_U: cfg.handleSyncRequest(messagePointer, CFGService::Type::U); break;
case KernelHandles::CFG_I: cfg.handleSyncRequest(messagePointer, CFGService::Type::I); break;
case KernelHandles::CSND: csnd.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;
@ -215,6 +220,7 @@ void ServiceManager::sendCommandToService(u32 messagePointer, Handle handle) {
case KernelHandles::NIM: nim.handleSyncRequest(messagePointer); break;
case KernelHandles::NDM: ndm.handleSyncRequest(messagePointer); break;
case KernelHandles::NEWS_U: news_u.handleSyncRequest(messagePointer); break;
case KernelHandles::NWM_UDS: nwm_uds.handleSyncRequest(messagePointer); break;
case KernelHandles::PTM: ptm.handleSyncRequest(messagePointer); break;
case KernelHandles::SOC: soc.handleSyncRequest(messagePointer); break;
case KernelHandles::SSL: ssl.handleSyncRequest(messagePointer); break;