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

hle: Add proper type for result code

Browse source 
This should clean up all HLE errorcode in the codebase.

I didn't removed Rust::Result as this should be a cleanup for another
iteration.
This commit is contained in:
Mary 2023-06-16 19:42:02 +02:00
parent c6f5d19983
commit 122b1b2727
73 changed files with 540 additions and 419 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/core/services/ac.cpp
View file

@ -7,12 +7,6 @@ namespace ACCommands {
};
}
namespace Result {
enum : u32 {
Success = 0,
};
}
void ACService::reset() {}
void ACService::handleSyncRequest(u32 messagePointer) {

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

@ -7,12 +7,6 @@ namespace ACTCommands {
};
}
namespace Result {
enum : u32 {
Success = 0,
};
}
void ACTService::reset() {}
void ACTService::handleSyncRequest(u32 messagePointer) {

6
src/core/services/am.cpp
View file

@ -8,12 +8,6 @@ namespace AMCommands {
};
}
namespace Result {
enum : u32 {
Success = 0,
};
}
void AMService::reset() {}
void AMService::handleSyncRequest(u32 messagePointer) {

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

@ -25,12 +25,6 @@ namespace APTCommands {
};
}
namespace Result {
enum : u32 {
Success = 0,
};
}
// https://www.3dbrew.org/wiki/NS_and_APT_Services#Command
namespace APTTransitions {
enum : u32 {
@ -154,7 +148,7 @@ void APTService::inquireNotification(u32 messagePointer) {
mem.write32(messagePointer, IPC::responseHeader(0xB, 2, 0));
mem.write32(messagePointer + 4, Result::Success);
mem.write32(messagePointer + 8, static_cast<u32>(NotificationType::None));
mem.write32(messagePointer + 8, static_cast<u32>(NotificationType::None));
}
void APTService::getLockHandle(u32 messagePointer) {

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

@ -14,12 +14,6 @@ namespace BOSSCommands {
};
}
namespace Result {
enum : u32 {
Success = 0,
};
}
void BOSSService::reset() {
optoutFlag = 0;
}

6
src/core/services/cam.cpp
View file

@ -8,12 +8,6 @@ namespace CAMCommands {
};
}
namespace Result {
enum : u32 {
Success = 0,
};
}
void CAMService::reset() {}
void CAMService::handleSyncRequest(u32 messagePointer) {

6
src/core/services/cecd.cpp
View file

@ -8,12 +8,6 @@ namespace CECDCommands {
};
}
namespace Result {
enum : u32 {
Success = 0,
};
}
void CECDService::reset() {
infoEvent = std::nullopt;
}

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

@ -16,12 +16,6 @@ namespace CFGCommands {
};
}
namespace Result {
enum : u32 {
Success = 0,
};
}
void CFGService::reset() {}
void CFGService::handleSyncRequest(u32 messagePointer) {
@ -89,7 +83,7 @@ void CFGService::getConfigInfoBlk2(u32 messagePointer) {
} else if (size == 4 && blockID == 0xD0000) { // Agreed EULA version (first 2 bytes) and latest EULA version (next 2 bytes)
log("Read EULA info\n");
mem.write16(output, 0x0202); // Agreed EULA version = 2.2 (Random number. TODO: Check)
mem.write16(output + 2, 0x0202); // Latest EULA version = 2.2
mem.write16(output + 2, 0x0202); // Latest EULA version = 2.2
} else if (size == 0x800 && blockID == 0xB0001) { // UTF-16 name for our country in every language at 0x80 byte intervals
constexpr size_t languageCount = 16;
constexpr size_t nameSize = 0x80; // Max size of each name in bytes
@ -105,7 +99,7 @@ void CFGService::getConfigInfoBlk2(u32 messagePointer) {
std::u16string name = u"Pandington"; // Note: This + the null terminator needs to fit in 0x80 bytes
for (int i = 0; i < languageCount; i++) {
u32 pointer = output + i * nameSize;
u32 pointer = output + i * nameSize;
writeStringU16(pointer, name);
}
} else if (size == 4 && blockID == 0xB0003) { // Coordinates (latidude and longtitude) as s16

6
src/core/services/dlp_srvr.cpp
View file

@ -7,12 +7,6 @@ namespace DlpSrvrCommands {
};
}
namespace Result {
enum : u32 {
Success = 0,
};
}
void DlpSrvrService::reset() {}
void DlpSrvrService::handleSyncRequest(u32 messagePointer) {

3
src/core/services/dsp.cpp
View file

@ -25,7 +25,6 @@ namespace DSPCommands {
namespace Result {
enum : u32 {
Success = 0,
HeadphonesNotInserted = 0,
HeadphonesInserted = 1
};
@ -215,7 +214,7 @@ void DSPService::registerInterruptEvents(u32 messagePointer) {
const u32 channel = mem.read32(messagePointer + 8);
const u32 eventHandle = mem.read32(messagePointer + 16);
log("DSP::RegisterInterruptEvents (interrupt = %d, channel = %d, event = %d)\n", interrupt, channel, eventHandle);
// The event handle being 0 means we're removing an event
if (eventHandle == 0) {
DSPEvent& e = getEventRef(interrupt, channel); // Get event

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

@ -17,12 +17,6 @@ namespace FRDCommands {
};
}
namespace Result {
enum : u32 {
Success = 0,
};
}
void FRDService::reset() {}
void FRDService::handleSyncRequest(u32 messagePointer) {
@ -91,7 +85,7 @@ void FRDService::getMyProfile(u32 messagePointer) {
mem.write32(messagePointer + 4, Result::Success);
// TODO: Should maybe make these user-configurable. Not super important though
mem.write8(messagePointer + 8, static_cast<u8>(Regions::USA)); // Region
mem.write8(messagePointer + 8, static_cast<u8>(Regions::USA)); // Region
mem.write8(messagePointer + 9, static_cast<u8>(CountryCodes::US)); // Country
mem.write8(messagePointer + 10, 2); // Area (this should be Washington)
mem.write8(messagePointer + 11, static_cast<u8>(LanguageCodes::English)); // Language

86
src/core/services/fs.cpp
View file

@ -32,14 +32,6 @@ namespace FSCommands {
};
}
namespace ResultCode {
enum : u32 {
Success = 0,
FileNotFound = 0xC8804464, // TODO: Verify this
Failure = 0xFFFFFFFF,
};
}
void FSService::reset() {
priority = 0;
}
@ -96,15 +88,15 @@ std::optional<Handle> FSService::openFileHandle(ArchiveBase* archive, const FSPa
auto& file = kernel.getObjects()[handle];
file.data = new FileSession(archive, path, archivePath, opened.value());
return handle;
} else {
return std::nullopt;
}
}
Rust::Result<Handle, FSResult> FSService::openDirectoryHandle(ArchiveBase* archive, const FSPath& path) {
Rust::Result<DirectorySession, FSResult> opened = archive->openDirectory(path);
Rust::Result<Handle, Result::HorizonResult> FSService::openDirectoryHandle(ArchiveBase* archive, const FSPath& path) {
Rust::Result<DirectorySession, Result::HorizonResult> opened = archive->openDirectory(path);
if (opened.isOk()) { // If opened doesn't have a value, we failed to open the directory
auto handle = kernel.makeObject(KernelObjectType::Directory);
auto& object = kernel.getObjects()[handle];
@ -116,15 +108,15 @@ Rust::Result<Handle, FSResult> FSService::openDirectoryHandle(ArchiveBase* archi
}
}
Rust::Result<Handle, FSResult> FSService::openArchiveHandle(u32 archiveID, const FSPath& path) {
Rust::Result<Handle, Result::HorizonResult> FSService::openArchiveHandle(u32 archiveID, const FSPath& path) {
ArchiveBase* archive = getArchiveFromID(archiveID, path);
if (archive == nullptr) [[unlikely]] {
Helpers::panic("OpenArchive: Tried to open unknown archive %d.", archiveID);
return Err(FSResult::NotFormatted);
return Err(Result::FS::NotFormatted);
}
Rust::Result<ArchiveBase*, FSResult> res = archive->openArchive(path);
Rust::Result<ArchiveBase*, Result::HorizonResult> res = archive->openArchive(path);
if (res.isOk()) {
auto handle = kernel.makeObject(KernelObjectType::Archive);
auto& archiveObject = kernel.getObjects()[handle];
@ -175,7 +167,7 @@ void FSService::handleSyncRequest(u32 messagePointer) {
void FSService::initialize(u32 messagePointer) {
log("FS::Initialize\n");
mem.write32(messagePointer, IPC::responseHeader(0x801, 1, 0));
mem.write32(messagePointer + 4, ResultCode::Success);
mem.write32(messagePointer + 4, Result::Success);
}
// TODO: Figure out how this is different from Initialize
@ -184,7 +176,7 @@ void FSService::initializeWithSdkVersion(u32 messagePointer) {
log("FS::InitializeWithSDKVersion(version = %d)\n", version);
mem.write32(messagePointer, IPC::responseHeader(0x861, 1, 0));
mem.write32(messagePointer + 4, ResultCode::Success);
mem.write32(messagePointer + 4, Result::Success);
}
void FSService::closeArchive(u32 messagePointer) {
@ -196,10 +188,10 @@ void FSService::closeArchive(u32 messagePointer) {
if (object == nullptr) {
log("FSService::CloseArchive: Tried to close invalid archive %X\n", handle);
mem.write32(messagePointer + 4, ResultCode::Failure);
mem.write32(messagePointer + 4, Result::FailurePlaceholder);
} else {
object->getData<ArchiveSession>()->isOpen = false;
mem.write32(messagePointer + 4, ResultCode::Success);
mem.write32(messagePointer + 4, Result::Success);
}
}
@ -211,15 +203,15 @@ void FSService::openArchive(u32 messagePointer) {
auto archivePath = readPath(archivePathType, archivePathPointer, archivePathSize);
log("FS::OpenArchive(archive ID = %d, archive path type = %d)\n", archiveID, archivePathType);
Rust::Result<Handle, FSResult> res = openArchiveHandle(archiveID, archivePath);
Rust::Result<Handle, Result::HorizonResult> res = openArchiveHandle(archiveID, archivePath);
mem.write32(messagePointer, IPC::responseHeader(0x80C, 3, 0));
if (res.isOk()) {
mem.write32(messagePointer + 4, ResultCode::Success);
mem.write32(messagePointer + 4, Result::Success);
mem.write64(messagePointer + 8, res.unwrap());
} else {
log("FS::OpenArchive: Failed to open archive with id = %d. Error %08X\n", archiveID, (u32)res.unwrapErr());
mem.write32(messagePointer + 4, static_cast<u32>(res.unwrapErr()));
mem.write32(messagePointer + 4, res.unwrapErr());
mem.write64(messagePointer + 8, 0);
}
}
@ -237,7 +229,7 @@ void FSService::openFile(u32 messagePointer) {
auto archiveObject = kernel.getObject(archiveHandle, KernelObjectType::Archive);
if (archiveObject == nullptr) [[unlikely]] {
log("FS::OpenFile: Invalid archive handle %d\n", archiveHandle);
mem.write32(messagePointer + 4, ResultCode::Failure);
mem.write32(messagePointer + 4, Result::FailurePlaceholder);
return;
}
@ -251,9 +243,9 @@ void FSService::openFile(u32 messagePointer) {
mem.write32(messagePointer, IPC::responseHeader(0x802, 1, 2));
if (!handle.has_value()) {
printf("OpenFile failed\n");
mem.write32(messagePointer + 4, ResultCode::FileNotFound);
mem.write32(messagePointer + 4, Result::FS::FileNotFound);
} else {
mem.write32(messagePointer + 4, ResultCode::Success);
mem.write32(messagePointer + 4, Result::Success);
mem.write32(messagePointer + 8, 0x10); // "Move handle descriptor"
mem.write32(messagePointer + 12, handle.value());
}
@ -270,13 +262,13 @@ void FSService::createDirectory(u32 messagePointer) {
KernelObject* archiveObject = kernel.getObject(archiveHandle, KernelObjectType::Archive);
if (archiveObject == nullptr) [[unlikely]] {
log("FS::CreateDirectory: Invalid archive handle %d\n", archiveHandle);
mem.write32(messagePointer + 4, ResultCode::Failure);
mem.write32(messagePointer + 4, Result::FailurePlaceholder);
return;
}
ArchiveBase* archive = archiveObject->getData<ArchiveSession>()->archive;
const auto dirPath = readPath(pathType, pathPointer, pathSize);
const FSResult res = archive->createDirectory(dirPath);
const Result::HorizonResult res = archive->createDirectory(dirPath);
mem.write32(messagePointer, IPC::responseHeader(0x809, 1, 0));
mem.write32(messagePointer + 4, static_cast<u32>(res));
@ -292,7 +284,7 @@ void FSService::openDirectory(u32 messagePointer) {
KernelObject* archiveObject = kernel.getObject(archiveHandle, KernelObjectType::Archive);
if (archiveObject == nullptr) [[unlikely]] {
log("FS::OpenDirectory: Invalid archive handle %d\n", archiveHandle);
mem.write32(messagePointer + 4, ResultCode::Failure);
mem.write32(messagePointer + 4, Result::FailurePlaceholder);
return;
}
@ -302,7 +294,7 @@ void FSService::openDirectory(u32 messagePointer) {
mem.write32(messagePointer, IPC::responseHeader(0x80B, 1, 2));
if (dir.isOk()) {
mem.write32(messagePointer + 4, ResultCode::Success);
mem.write32(messagePointer + 4, Result::Success);
mem.write32(messagePointer + 12, dir.unwrap());
} else {
printf("FS::OpenDirectory failed\n");
@ -324,14 +316,14 @@ void FSService::openFileDirectly(u32 messagePointer) {
auto archivePath = readPath(archivePathType, archivePathPointer, archivePathSize);
ArchiveBase* archive = getArchiveFromID(archiveID, archivePath);
if (archive == nullptr) [[unlikely]] {
Helpers::panic("OpenFileDirectly: Tried to open unknown archive %d.", archiveID);
}
auto filePath = readPath(filePathType, filePathPointer, filePathSize);
const FilePerms perms(openFlags);
Rust::Result<ArchiveBase*, FSResult> res = archive->openArchive(archivePath);
Rust::Result<ArchiveBase*, Result::HorizonResult> res = archive->openArchive(archivePath);
if (res.isErr()) [[unlikely]] {
Helpers::panic("OpenFileDirectly: Failed to open archive with given path");
}
@ -342,7 +334,7 @@ void FSService::openFileDirectly(u32 messagePointer) {
if (!handle.has_value()) {
Helpers::panic("OpenFileDirectly: Failed to open file with given path");
} else {
mem.write32(messagePointer + 4, ResultCode::Success);
mem.write32(messagePointer + 4, Result::Success);
mem.write32(messagePointer + 12, handle.value());
}
}
@ -360,16 +352,16 @@ void FSService::createFile(u32 messagePointer) {
auto archiveObject = kernel.getObject(archiveHandle, KernelObjectType::Archive);
if (archiveObject == nullptr) [[unlikely]] {
log("FS::OpenFile: Invalid archive handle %d\n", archiveHandle);
mem.write32(messagePointer + 4, ResultCode::Failure);
mem.write32(messagePointer + 4, Result::FailurePlaceholder);
return;
}
ArchiveBase* archive = archiveObject->getData<ArchiveSession>()->archive;
auto filePath = readPath(filePathType, filePathPointer, filePathSize);
FSResult res = archive->createFile(filePath, size);
Result::HorizonResult res = archive->createFile(filePath, size);
mem.write32(messagePointer, IPC::responseHeader(0x808, 1, 0));
mem.write32(messagePointer + 4, static_cast<u32>(res));
mem.write32(messagePointer + 4, res);
}
void FSService::deleteFile(u32 messagePointer) {
@ -382,14 +374,14 @@ void FSService::deleteFile(u32 messagePointer) {
auto archiveObject = kernel.getObject(archiveHandle, KernelObjectType::Archive);
if (archiveObject == nullptr) [[unlikely]] {
log("FS::DeleteFile: Invalid archive handle %d\n", archiveHandle);
mem.write32(messagePointer + 4, ResultCode::Failure);
mem.write32(messagePointer + 4, Result::FailurePlaceholder);
return;
}
ArchiveBase* archive = archiveObject->getData<ArchiveSession>()->archive;
auto filePath = readPath(filePathType, filePathPointer, filePathSize);
FSResult res = archive->deleteFile(filePath);
Result::HorizonResult res = archive->deleteFile(filePath);
mem.write32(messagePointer, IPC::responseHeader(0x804, 1, 0));
mem.write32(messagePointer + 4, static_cast<u32>(res));
}
@ -409,12 +401,12 @@ void FSService::getFormatInfo(u32 messagePointer) {
}
mem.write32(messagePointer, IPC::responseHeader(0x845, 5, 0));
Rust::Result<ArchiveBase::FormatInfo, FSResult> res = archive->getFormatInfo(path);
Rust::Result<ArchiveBase::FormatInfo, Result::HorizonResult> res = archive->getFormatInfo(path);
// If the FormatInfo was returned, write them to the output buffer. Otherwise, write an error code.
if (res.isOk()) {
ArchiveBase::FormatInfo info = res.unwrap();
mem.write32(messagePointer + 4, ResultCode::Success);
mem.write32(messagePointer + 4, Result::Success);
mem.write32(messagePointer + 8, info.size);
mem.write32(messagePointer + 12, info.numOfDirectories);
mem.write32(messagePointer + 16, info.numOfFiles);
@ -458,7 +450,7 @@ void FSService::formatSaveData(u32 messagePointer) {
saveData.format(path, info);
mem.write32(messagePointer, IPC::responseHeader(0x84C, 1, 0));
mem.write32(messagePointer + 4, ResultCode::Success);
mem.write32(messagePointer + 4, Result::Success);
}
void FSService::formatThisUserSaveData(u32 messagePointer) {
@ -478,7 +470,7 @@ void FSService::formatThisUserSaveData(u32 messagePointer) {
.duplicateData = duplicateData
};
FSPath emptyPath;
mem.write32(messagePointer, IPC::responseHeader(0x080F, 1, 0));
saveData.format(emptyPath, info);
}
@ -497,13 +489,13 @@ void FSService::controlArchive(u32 messagePointer) {
mem.write32(messagePointer, IPC::responseHeader(0x80D, 1, 0));
if (archiveObject == nullptr) [[unlikely]] {
log("FS::ControlArchive: Invalid archive handle %d\n", archiveHandle);
mem.write32(messagePointer + 4, ResultCode::Failure);
mem.write32(messagePointer + 4, Result::FailurePlaceholder);
return;
}
switch (action) {
case 0: // Commit save data changes. Shouldn't need us to do anything
mem.write32(messagePointer + 4, ResultCode::Success);
mem.write32(messagePointer + 4, Result::Success);
break;
default:
Helpers::panic("Unimplemented action for ControlArchive (action = %X)\n", action);
@ -519,7 +511,7 @@ void FSService::getFreeBytes(u32 messagePointer) {
mem.write32(messagePointer, IPC::responseHeader(0x812, 3, 0));
if (session == nullptr) [[unlikely]] {
log("FS::GetFreeBytes: Invalid archive handle %d\n", archiveHandle);
mem.write32(messagePointer + 4, ResultCode::Failure);
mem.write32(messagePointer + 4, Result::FailurePlaceholder);
return;
}
@ -531,7 +523,7 @@ void FSService::getPriority(u32 messagePointer) {
log("FS::GetPriority\n");
mem.write32(messagePointer, IPC::responseHeader(0x863, 2, 0));
mem.write32(messagePointer + 4, ResultCode::Success);
mem.write32(messagePointer + 4, Result::Success);
mem.write32(messagePointer + 8, priority);
}
@ -540,13 +532,13 @@ void FSService::setPriority(u32 messagePointer) {
log("FS::SetPriority (priority = %d)\n", value);
mem.write32(messagePointer, IPC::responseHeader(0x862, 1, 0));
mem.write32(messagePointer + 4, ResultCode::Success);
mem.write32(messagePointer + 4, Result::Success);
priority = value;
}
void FSService::isSdmcDetected(u32 messagePointer) {
log("FS::IsSdmcDetected\n");
mem.write32(messagePointer, IPC::responseHeader(0x817, 2, 0));
mem.write32(messagePointer + 4, ResultCode::Success);
mem.write32(messagePointer + 4, Result::Success);
mem.write32(messagePointer + 8, 0); // Whether SD is detected. For now we emulate a 3DS without an SD.
}

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

@ -30,13 +30,6 @@ namespace GXCommands {
};
}
namespace Result {
enum : u32 {
Success = 0,
SuccessRegisterIRQ = 0x2A07 // TODO: Is this a reference to the Ricoh 2A07 used in PAL NES systems?
};
}
void GPUService::reset() {
privilegedProcess = 0xFFFFFFFF; // Set the privileged process to an invalid handle
interruptEvent = std::nullopt;
@ -100,7 +93,7 @@ void GPUService::registerInterruptRelayQueue(u32 messagePointer) {
}
mem.write32(messagePointer, IPC::responseHeader(0x13, 2, 2));
mem.write32(messagePointer + 4, Result::SuccessRegisterIRQ); // First init returns a unique result
mem.write32(messagePointer + 4, Result::GSP::SuccessRegisterIRQ); // First init returns a unique result
mem.write32(messagePointer + 8, 0); // TODO: GSP module thread index
mem.write32(messagePointer + 12, 0); // Translation descriptor
mem.write32(messagePointer + 16, KernelHandles::GSPSharedMemHandle);
@ -120,7 +113,7 @@ void GPUService::requestInterrupt(GPUInterrupt type) {
u8& interruptCount = sharedMem[1];
u8 flagIndex = (index + interruptCount) % 0x34;
interruptCount++;
sharedMem[2] = 0; // Set error code to 0
sharedMem[0xC + flagIndex] = static_cast<u8>(type); // Write interrupt type to queue
@ -187,7 +180,7 @@ void GPUService::writeHwRegsWithMask(u32 messagePointer) {
u32 dataPointer = mem.read32(messagePointer + 16); // Data pointer
u32 maskPointer = mem.read32(messagePointer + 24); // Mask pointer
log("GSP::GPU::writeHwRegsWithMask (GPU address = %08X, size = %X, data address = %08X, mask address = %08X)\n",
log("GSP::GPU::writeHwRegsWithMask (GPU address = %08X, size = %X, data address = %08X, mask address = %08X)\n",
ioAddr, size, dataPointer, maskPointer);
// Check for alignment
@ -202,7 +195,7 @@ void GPUService::writeHwRegsWithMask(u32 messagePointer) {
if (ioAddr >= 0x420000) {
Helpers::panic("GSP::GPU::writeHwRegs offset too big");
}
ioAddr += 0x1EB00000;
for (u32 i = 0; i < size; i += 4) {
const u32 current = gpu.readReg(ioAddr);
@ -301,13 +294,13 @@ void GPUService::processCommandBuffer() {
commandsLeft--;
}
}
}
}
// Fill 2 GPU framebuffers, buf0 and buf1, using a specific word value
void GPUService::memoryFill(u32* cmd) {
u32 control = cmd[7];
// buf0 parameters
u32 start0 = cmd[1]; // Start address for the fill. If 0, don't fill anything
u32 value0 = cmd[2]; // Value to fill the framebuffer with

6
src/core/services/gsp_lcd.cpp
View file

@ -6,12 +6,6 @@ namespace LCDCommands {
};
}
namespace Result {
enum : u32 {
Success = 0,
};
}
void LCDService::reset() {}
void LCDService::handleSyncRequest(u32 messagePointer) {

9
src/core/services/hid.cpp
View file

@ -13,13 +13,6 @@ namespace HIDCommands {
};
}
namespace Result {
enum : u32 {
Success = 0,
Failure = 0xFFFFFFFF
};
}
void HIDService::reset() {
sharedMem = nullptr;
accelerometerEnabled = false;
@ -155,7 +148,7 @@ void HIDService::updateInputs(u64 currentTick) {
writeSharedMem<u16>(touchEntryOffset, touchScreenX);
writeSharedMem<u16>(touchEntryOffset + 2, touchScreenY);
writeSharedMem<u8>(touchEntryOffset + 4, touchScreenPressed ? 1 : 0);
// Next, update accelerometer state
if (nextAccelerometerIndex == 0) {
writeSharedMem<u64>(0x110, readSharedMem<u64>(0x108)); // Copy previous tick count

6
src/core/services/ldr_ro.cpp
View file

@ -8,12 +8,6 @@ namespace LDRCommands {
};
}
namespace Result {
enum : u32 {
Success = 0,
};
}
void LDRService::reset() {}
void LDRService::handleSyncRequest(u32 messagePointer) {

6
src/core/services/mic.cpp
View file

@ -13,12 +13,6 @@ namespace MICCommands {
};
}
namespace Result {
enum : u32 {
Success = 0,
};
}
void MICService::reset() {
micEnabled = false;
shouldClamp = false;

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

@ -11,12 +11,6 @@ namespace NDMCommands {
};
}
namespace Result {
enum : u32 {
Success = 0,
};
}
void NDMService::reset() {}
void NDMService::handleSyncRequest(u32 messagePointer) {

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

@ -10,12 +10,6 @@ namespace NFCCommands {
};
}
namespace Result {
enum : u32 {
Success = 0,
};
}
void NFCService::reset() {
tagInRangeEvent = std::nullopt;
tagOutOfRangeEvent = std::nullopt;

6
src/core/services/nim.cpp
View file

@ -7,12 +7,6 @@ namespace NIMCommands {
};
}
namespace Result {
enum : u32 {
Success = 0,
};
}
void NIMService::reset() {}
void NIMService::handleSyncRequest(u32 messagePointer) {

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

@ -3,18 +3,12 @@
namespace PTMCommands {
enum : u32 {
GetStepHistory = 0x000B00C2,
GetStepHistory = 0x000B00C2,
GetTotalStepCount = 0x000C0000,
ConfigureNew3DSCPU = 0x08180040
};
}
namespace Result {
enum : u32 {
Success = 0,
};
}
void PTMService::reset() {}
void PTMService::handleSyncRequest(u32 messagePointer) {

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

@ -58,12 +58,6 @@ namespace Commands {
};
}
namespace Result {
enum : u32 {
Success = 0
};
}
// Handle an IPC message issued using the SendSyncRequest SVC
// The parameters are stored in thread-local storage in this format: https://www.3dbrew.org/wiki/IPC#Message_Structure
// messagePointer: The base pointer for the IPC message

6
src/core/services/y2r.cpp
View file

@ -29,12 +29,6 @@ namespace Y2RCommands {
};
}
namespace Result {
enum : u32 {
Success = 0,
};
}
void Y2RService::reset() {
transferEndInterruptEnabled = false;
transferEndEvent = std::nullopt;