preserve-emulation/ppsspp
1
0 Fork 0
mirror of https://github.com/hrydgard/ppsspp.git synced 2026-10-22 02:39:05 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
mapped-volume-keys
ppsspp/Core/HLE/HLETables.cpp
T
Henrik RydgårdandClaude Opus 5.5 83df04686c sceNet: Register sceNetApctl_lib, for the VSH's network connection screen 
pspnet_apctl.prx exports the internal handler, scan and BSS functions to
the VSH under sceNetApctl_lib (as listed by its 6.61 export table). We had
them, but only under sceNetApctl, so the XMB's netconf plugin got an
unresolved import and the browser and online manuals stopped at 8002013A
before their Network Connection screen.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-21 19:00:01 +02:00

446 lines
24 KiB
C++
Raw Permalink Blame History

// Copyright (c) 2012- PPSSPP Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0 or later versions.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official git repository and contact information can be found at
// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
#include "Core/HLE/HLE.h"
#include "Core/HLE/HLETables.h"
#include "Core/HLE/FunctionWrappers.h"
#include "sceAtrac.h"
#include "sceAudio.h"
#include "sceAudiocodec.h"
#include "sceAudioRouting.h"
#include "sceCcc.h"
#include "sceChnnlsv.h"
#include "sceCtrl.h"
#include "sceChkreg.h"
#include "sceDeflt.h"
#include "sceDisplay.h"
#include "sceDmac.h"
#include "sceFont.h"
#include "sceGameUpdate.h"
#include "sceGe.h"
#include "sceHeap.h"
#include "sceHprm.h"
#include "sceHttp.h"
#include "sceImpose.h"
#include "sceIo.h"
#include "sceJpeg.h"
#include "sceKernel.h"
#include "sceKernelEventFlag.h"
#include "sceKernelHeap.h"
#include "sceKernelMemory.h"
#include "sceKernelInterrupt.h"
#include "sceKernelModule.h"
#include "sceKernelSemaphore.h"
#include "sceKernelThread.h"
#include "sceKernelTime.h"
#include "sceMd5.h"
#include "sceMp4.h"
#include "sceAac.h"
#include "sceMp3.h"
#include "sceNet.h"
#include "sceNetAdhoc.h"
#include "sceNetAdhocMatching.h"
#include "sceNp.h"
#include "sceMpeg.h"
#include "sceMpegbase.h"
#include "sceOpenPSID.h"
#include "sceResmgr.h"
#include "sceP3da.h"
#include "sceParseHttp.h"
#include "sceParseUri.h"
#include "scePauth.h"
#include "scePower.h"
#include "scePspNpDrm_user.h"
#include "scePsmf.h"
#include "sceReg.h"
#include "sceRtc.h"
#include "sceSas.h"
#include "sceSircs.h"
#include "sceSsl.h"
#include "sceUmd.h"
#include "sceUsb.h"
#include "sceUsbAcc.h"
#include "sceUsbCam.h"
#include "sceUsbGps.h"
#include "sceUsbMic.h"
#include "sceUtility.h"
#include "sceVaudio.h"
#include "sceVshBridge.h"
#include "sceMt19937.h"
#include "sceSha256.h"
#include "sceAdler.h"
#include "sceSfmt19937.h"
#include "sceG729.h"
#include "KUBridge.h"
#include "PopsBoot.h"
#include "sceAmctrl.h"
#include "sceNetInet.h"
#include "sceNetResolver.h"
// #include "sceNp2.h"
#include "sceNet_lib.h"
#include "sceVideocodec.h"
#include "sceSysreg.h"
static const HLEFunction FakeSysCalls[] = {
{NID_THREADRETURN, __KernelReturnFromThread, "__KernelReturnFromThread", 'x', ""},
{NID_CALLBACKRETURN, __KernelReturnFromMipsCall, "__KernelReturnFromMipsCall", 'x', ""},
{NID_INTERRUPTRETURN, __KernelReturnFromInterrupt, "__KernelReturnFromInterrupt", 'x', ""},
{NID_EXTENDRETURN, __KernelReturnFromExtendStack, "__KernelReturnFromExtendStack", 'x', ""},
{NID_MODULERETURN, __KernelReturnFromModuleFunc, "__KernelReturnFromModuleFunc", 'x', ""},
{NID_IDLE, __KernelIdle, "_sceKernelIdle", 'x', ""},
{NID_GPUREPLAY, &WrapI_V<__KernelGPUReplay>, "__KernelGPUReplay", 'x', ""},
{NID_HLECALLRETURN, HLEReturnFromMipsCall, "HLEReturnFromMipsCall", 'x', ""},
};
static const HLEFunction UtilsForUser[] = {
{0X91E4F6A7, &WrapU_V<sceKernelLibcClock>, "sceKernelLibcClock", 'x', "" },
{0X27CC57F0, &WrapU_U<sceKernelLibcTime>, "sceKernelLibcTime", 'x', "x" },
{0X71EC4271, &WrapU_UU<sceKernelLibcGettimeofday>, "sceKernelLibcGettimeofday", 'x', "xx" },
{0XBFA98062, &WrapI_UI<sceKernelDcacheInvalidateRange>, "sceKernelDcacheInvalidateRange", 'i', "xi" },
{0XC8186A58, &WrapI_UIU<sceKernelUtilsMd5Digest>, "sceKernelUtilsMd5Digest", 'i', "xix"},
{0X9E5C5086, &WrapI_U<sceKernelUtilsMd5BlockInit>, "sceKernelUtilsMd5BlockInit", 'i', "x" },
{0X61E1E525, &WrapI_UUI<sceKernelUtilsMd5BlockUpdate>, "sceKernelUtilsMd5BlockUpdate", 'i', "xxi"},
{0XB8D24E78, &WrapI_UU<sceKernelUtilsMd5BlockResult>, "sceKernelUtilsMd5BlockResult", 'i', "xx" },
{0X840259F1, &WrapI_UIU<sceKernelUtilsSha1Digest>, "sceKernelUtilsSha1Digest", 'i', "xix"},
{0XF8FCD5BA, &WrapI_U<sceKernelUtilsSha1BlockInit>, "sceKernelUtilsSha1BlockInit", 'i', "x" },
{0X346F6DA8, &WrapI_UUI<sceKernelUtilsSha1BlockUpdate>, "sceKernelUtilsSha1BlockUpdate", 'i', "xxi"},
{0X585F1C09, &WrapI_UU<sceKernelUtilsSha1BlockResult>, "sceKernelUtilsSha1BlockResult", 'i', "xx" },
{0XE860E75E, &WrapU_UU<sceKernelUtilsMt19937Init>, "sceKernelUtilsMt19937Init", 'x', "xx" },
{0X06FB8A63, &WrapU_U<sceKernelUtilsMt19937UInt>, "sceKernelUtilsMt19937UInt", 'x', "x" },
{0X37FB5C42, &WrapU_V<sceKernelGetGPI>, "sceKernelGetGPI", 'x', "" },
{0X6AD345D7, &WrapV_U<sceKernelSetGPO>, "sceKernelSetGPO", 'v', "x" },
{0X79D1C3FA, &WrapI_V<sceKernelDcacheWritebackAll>, "sceKernelDcacheWritebackAll", 'i', "" },
{0XB435DEC5, &WrapI_V<sceKernelDcacheWritebackInvalidateAll>, "sceKernelDcacheWritebackInvalidateAll", 'i', "" },
{0X3EE30821, &WrapI_UI<sceKernelDcacheWritebackRange>, "sceKernelDcacheWritebackRange", 'i', "xi" },
{0X34B9FA9E, &WrapI_UI<sceKernelDcacheWritebackInvalidateRange>, "sceKernelDcacheWritebackInvalidateRange", 'i', "xi" },
{0XC2DF770E, &WrapI_UI<sceKernelIcacheInvalidateRange>, "sceKernelIcacheInvalidateRange", 'i', "xi" },
{0X80001C4C, nullptr, "sceKernelDcacheProbe", '?', "" },
{0X16641D70, nullptr, "sceKernelDcacheReadTag", '?', "" },
{0X4FD31C9D, nullptr, "sceKernelIcacheProbe", '?', "" },
{0XFB05FAD0, nullptr, "sceKernelIcacheReadTag", '?', "" },
{0X920F104A, &WrapU_V<sceKernelIcacheInvalidateAll>, "sceKernelIcacheInvalidateAll", 'x', "" }
};
static const HLEFunction LoadCoreForKernel[] = {
{0XACE23476, nullptr, "sceKernelCheckPspConfig", '?', "" },
{0X7BE1421C, nullptr, "sceKernelCheckExecFile", '?', "" },
{0XBF983EF2, nullptr, "sceKernelProbeExecutableObject", '?', "" },
{0X7068E6BA, nullptr, "sceKernelLoadExecutableObject", '?', "" },
{0XB4D6FECC, nullptr, "sceKernelApplyElfRelSection", '?', "" },
{0X54AB2675, nullptr, "sceKernelApplyPspRelSection", '?', "" },
{0X2952F5AC, nullptr, "sceKernelDcacheWBinvAll", '?', "" },
{0xD8779AC6, &WrapU_V<sceKernelIcacheClearAll>, "sceKernelIcacheClearAll", 'x', "", HLE_KERNEL_SYSCALL },
{0X99A695F0, nullptr, "sceKernelRegisterLibrary", '?', "" },
{0X5873A31F, nullptr, "sceKernelRegisterLibraryForUser", '?', "" },
{0X0B464512, nullptr, "sceKernelReleaseLibrary", '?', "" },
{0X9BAF90F6, nullptr, "sceKernelCanReleaseLibrary", '?', "" },
{0X0E760DBA, nullptr, "sceKernelLinkLibraryEntries", '?', "" },
{0X0DE1F600, nullptr, "sceKernelLinkLibraryEntriesForUser", '?', "" },
{0XDA1B09AA, nullptr, "sceKernelUnLinkLibraryEntries", '?', "" },
{0XC99DD47A, &WrapU_V<sceKernelQueryLoadCoreCB>, "sceKernelQueryLoadCoreCB", 'x', "", HLE_KERNEL_SYSCALL },
{0X616FCCCD, nullptr, "sceKernelSetBootCallbackLevel", '?', "" },
{0XF32A2940, nullptr, "sceKernelModuleFromUID", '?', "" },
{0XCD0F3BAC, nullptr, "sceKernelCreateModule", '?', "" },
{0X6B2371C2, nullptr, "sceKernelDeleteModule", '?', "" },
{0X7320D964, nullptr, "sceKernelModuleAssign", '?', "" },
{0X44B292AB, nullptr, "sceKernelAllocModule", '?', "" },
{0XBD61D4D5, nullptr, "sceKernelFreeModule", '?', "" },
{0XAE7C6E76, nullptr, "sceKernelRegisterModule", '?', "" },
{0X74CF001A, nullptr, "sceKernelReleaseModule", '?', "" },
{0XFB8AE27D, nullptr, "sceKernelFindModuleByAddress", '?', "" },
{0XCCE4A157, &WrapU_U<sceKernelFindModuleByUID>, "sceKernelFindModuleByUID", 'x', "x" , HLE_KERNEL_SYSCALL },
{0X82CE54ED, nullptr, "sceKernelModuleCount", '?', "" },
{0XC0584F0C, nullptr, "sceKernelGetModuleList", '?', "" },
{0XCF8A41B1, &WrapU_C<sceKernelFindModuleByName>, "sceKernelFindModuleByName", 'x', "s", HLE_KERNEL_SYSCALL },
{0XB95FA50D, nullptr, "LoadCoreForKernel_B95FA50D", '?', "" },
{0x696594C8, &WrapU_V<sceKernelQueryLoadCoreCB>, "sceKernelQueryLoadCoreCB660", 'x', "", HLE_KERNEL_SYSCALL },
};
// sceKernelSm1ReferOperations() returns a pointer to a driver-registered "SM1 operations"
// table (set up via the sibling sceKernelSm1RegisterOperations(), also unimplemented here),
// or NULL if nothing has registered one.
static u32 sceKernelSm1ReferOperations() {
return hleLogDebug(Log::sceKernel, 0);
}
// The kernel's debug printf. On hardware it formats the string and hands it to whatever
// sceKernelRegisterKprintfHandler() installed, which on a retail PSP means the serial port -
// so nothing a player ever sees, and games that call it are just leaving debug output in.
// We format it and put it in the log, which is the useful thing to do with it.
// Declared void in the SDK headers, so the return value doesn't matter, but 0 is what the
// firmware leaves in v0.
static u32 Kprintf(MIPSState *mips, u32 fmtAddr) {
std::string formatted;
if (!HLEFormatPrintf(mips, fmtAddr, 1, &formatted)) {
return hleLogError(Log::Printf, 0, "bad format string or args");
}
// Each log line is already a line, so don't double space.
if (!formatted.empty() && formatted.back() == '\n') {
formatted.pop_back();
}
return hleLogInfo(Log::Printf, 0, "\"%s\"", formatted.c_str());
}
static const HLEFunction KDebugForKernel[] = {
{0XE7A3874D, nullptr, "sceKernelRegisterAssertHandler", '?', "" },
{0X2FF4E9F9, nullptr, "sceKernelAssert", '?', "" },
{0X9B868276, nullptr, "sceKernelGetDebugPutchar", '?', "" },
{0XE146606D, nullptr, "sceKernelRegisterDebugPutchar", '?', "" },
{0X7CEB2C09, &WrapU_V<sceKernelRegisterKprintfHandler>, "sceKernelRegisterKprintfHandler", 'x', "", HLE_KERNEL_SYSCALL },
{0X84F370BC, &WrapU_U<Kprintf>, "Kprintf", 'x', "x", HLE_KERNEL_SYSCALL },
{0X5CE9838B, nullptr, "sceKernelDebugWrite", '?', "" },
{0X66253C4E, nullptr, "sceKernelRegisterDebugWrite", '?', "" },
{0XDBB5597F, nullptr, "sceKernelDebugRead", '?', "" },
{0XE6554FDA, nullptr, "sceKernelRegisterDebugRead", '?', "" },
{0XB9C643C9, nullptr, "sceKernelDebugEcho", '?', "" },
{0X7D1C74F0, nullptr, "sceKernelDebugEchoSet", '?', "" },
{0X24C32559, nullptr, "sceKernelDipsw", '?', "" },
{0XD636B827, nullptr, "sceKernelRemoveByDebugSection", '?', "" },
{0X5282DD5E, nullptr, "sceKernelDipswSet", '?', "" },
{0X9F8703E4, nullptr, "sceKernelDipswCpTime", '?', "" },
{0X333DCEC7, nullptr, "sceKernelSm1RegisterOperations", '?', "" },
{0XE892D9A1, &WrapU_V<sceKernelSm1ReferOperations>, "sceKernelSm1ReferOperations", 'x', "" },
{0XA126F497, nullptr, "KDebugForKernel_A126F497", '?', "" },
{0XB7251823, nullptr, "sceKernelAcceptMbogoSig", '?', "" },
};
static const HLEFunction pspeDebug[] = {
{0XDEADBEAF, nullptr, "pspeDebugWrite", '?', "" },
};
static const HLEModule moduleList[] = {
{"FakeSysCalls", ARRAY_SIZE(FakeSysCalls), FakeSysCalls},
{"UtilsForUser", ARRAY_SIZE(UtilsForUser), UtilsForUser},
{"KDebugForKernel", ARRAY_SIZE(KDebugForKernel), KDebugForKernel},
{"sceSAScore"},
{"SceBase64_Library"},
{"sceCert_Loader"},
{"SceFont_Library"},
{"sceNetApctl"},
{"sceSIRCS_IrDA_Driver"},
{"Pspnet_Scan"},
{"Pspnet_Show_MacAddr"},
{"pspeDebug", ARRAY_SIZE(pspeDebug), pspeDebug},
};
static const int numModules = ARRAY_SIZE(moduleList);
// Sony renumbered the kernel NIDs at these releases. We implement 6.60's; a module from an older
// firmware imports by its generation's NID, which GetHLENidAlias() maps to the first column. 0 where none
// is needed (unchanged, or not known).
//
// Each generation's NIDs come from the call sites in popsman.prx compared with the next newer version's,
// checked against the code of the module exporting them, and for sysreg against the registers each
// function touches (where popsman.prx was rewritten, 5.55 and 4.05, the call sites alone get some wrong).
static const struct {
const char *module;
u32 nids[5]; // 6.60-6.61, 6.30-6.39, 6.00-6.20, 5.01-5.55, 3.95-4.05
} hleKernelNids[] = {
{ "InitForKernel", { 0x9D33A110, 0xEE67E450, 0x977A0F90, 0, 0 } }, // InitForKernel_9D33A110
{ "LoadExecForKernel", { 0xC3474C2A, 0xFCD765C9, 0x29413885, 0x9C9BB2D8, 0x63D88393 } }, // sceKernelExitVSHKernel
{ "ModuleMgrForKernel", { 0x939E4270, 0xFFB9B760, 0xE3CCC6EA, 0xC5A281C5, 0x24C5ABC2 } }, // sceKernelLoadModuleForKernel
{ "ModuleMgrForKernel", { 0x3FF74DF1, 0xE6BF3960, 0xDF8FFFAB, 0xBB8C8FDF, 0x63A3CAFB } }, // sceKernelStartModule
{ "sceClockgen_driver", { 0xDAB6E612, 0xA02BB1D3, 0xACC30ECE, 0, 0 } },
{ "sceCodec_driver", { 0x376399B6, 0xB2EF6B19, 0x794EE731, 0, 0 } },
{ "sceCtrl_driver", { 0x6C86AF22, 0xDEFAD580, 0x7A6436DE, 0, 0 } },
{ "sceDisplay_driver", { 0x03F16FD4, 0x3DABE438, 0xAAC50D73, 0, 0 } },
{ "sceDisplay_driver", { 0xE38CA615, 0x3E4B1B28, 0x0F82D90A, 0, 0 } },
{ "sceDisplay_driver", { 0xE97E9718, 0x8930B3A9, 0xF4B7B531, 0, 0 } },
{ "sceDve_driver", { 0x48005974, 0xAA085C2A, 0xA1401BA2, 0, 0 } },
{ "sceGe_driver", { 0xD8633888, 0x2444EC4D, 0xD4D665C9, 0x1F226BA9, 0x1DDA69CE } }, // sceGeEdramSetSize
{ "sceGe_driver", { 0x4B9554EB, 0xFEEC36F7, 0x23E9F5FA, 0, 0 } },
{ "sceGe_driver", { 0x5D28A52B, 0x670F15ED, 0xF489E74B, 0, 0 } },
{ "sceGe_driver", { 0xAFE6C9EF, 0xD8A53104, 0x7E2381D2, 0, 0 } },
{ "sceHprm_driver", { 0xB2BEADB8, 0xADE4B1F4, 0x62CDFB12, 0, 0 } },
{ "sceImpose_driver", { 0xB497314D, 0x3FE74F52, 0x8F1AC24D, 0, 0 } }, // sceImpose_driver_B497314D
{ "sceImpose_driver", { 0x0F067E16, 0x44F17A7A, 0x55864BD7, 0x0BBCA0BF, 0xCD1291FD } }, // sceImposeChanges
{ "sceImpose_driver", { 0x5557F4E2, 0xEBC850AC, 0x4D849B71, 0xA516434B, 0x869EB4A8 } }, // sceImposeGetBatteryIconStatus
{ "sceImpose_driver", { 0xDC3BECFF, 0x4C4DF719, 0xC94AC8E2, 0x4B02F047, 0x6F502C0A } }, // sceImposeGetParam
{ "sceImpose_driver", { 0x133DB99A, 0x3BD9E51B, 0x5314204F, 0, 0 } },
{ "sceImpose_driver", { 0x28B97035, 0x027F21C6, 0x25011AAB, 0, 0 } },
{ "scePadSvc_driver", { 0x05C9C803, 0x773BA62B, 0x79B60777, 0, 0 } },
{ "scePadSvc_driver", { 0x0B3E6FD3, 0x2F9A534A, 0x3B0567D6, 0, 0 } },
{ "scePadSvc_driver", { 0x7CAB5A3D, 0x830FC570, 0x1971BAE0, 0, 0 } },
{ "scePower_driver", { 0x469989AD, 0, 0xEBD177D6, 0, 0xEBD177D6 } }, // scePowerSetClockFrequency630
{ "sceRtc_driver", { 0x4E267E02, 0xFF530D9F, 0x2F20DAF0, 0, 0 } },
{ "sceRtc_driver", { 0xE7B3ABF4, 0x99037763, 0x43F38ED8, 0, 0 } },
{ "sceSyscon_driver", { 0x48448373, 0x741110C5, 0xB757C11D, 0, 0 } },
{ "sceSyscon_driver", { 0x9BC5E33B, 0xC4931159, 0xF7E9487A, 0, 0 } },
{ "sceSysreg_driver", { 0x41B0337B, 0x9E80B4E2, 0x47966D28, 0x48869494, 0xC4B60AB3 } }, // sceSysreg_driver_41B0337B
{ "sceSysreg_driver", { 0x4634C9DC, 0xD1999F94, 0x5D3DD0B3, 0x410C74F7, 0xE08034E0 } }, // sceSysreg_driver_4634C9DC
{ "sceSysreg_driver", { 0x4B4CCE80, 0x9984A972, 0x94914740, 0xE46A0890, 0x21797DCF } }, // sceSysreg_driver_4B4CCE80
{ "sceSysreg_driver", { 0x8B1DD83A, 0x789597AB, 0xE7849809, 0xC7FC7669, 0x643169E5 } }, // sceSysreg_driver_8B1DD83A
{ "sceSysreg_driver", { 0xB1751B06, 0x8E9E76AE, 0xB733A263, 0x823FFD7A, 0x67583EF1 } }, // sceSysreg_driver_B1751B06
{ "sceSysreg_driver", { 0xC36775AD, 0x3A98CABB, 0x9EBB3C43, 0x923509A1, 0x15574362 } }, // sceSysreg_driver_C36775AD
{ "sceSysreg_driver", { 0x0AE8E549, 0x86FFE348, 0x119647A7, 0x663D5471, 0xD80E8AAF } }, // sceSysregAvcResetEnable660
{ "sceSysreg_driver", { 0x38527743, 0xD74D9041, 0x2B3BE2C8, 0x08E0EE7E, 0xB60FBA15 } }, // sceSysregMeBusClockEnable660
{ "sceSysreg_driver", { 0x48F1C4AD, 0xE2606FCB, 0x2D858336, 0x5F190A4E, 0x8E6586AD } }, // sceSysregMeResetDisable660
{ "sceSysreg_driver", { 0x457FEBA9, 0xB70793D7, 0x97EA6913, 0x20C9E2C4, 0xA36C4E9E } }, // sceSysregMeResetEnable660
{ "sceSysreg_driver", { 0x0143E8A8, 0x45596E3F, 0x4643F826, 0x461B8077, 0xD83733C9 } }, // sceSysregSemaTryLock660
{ "sceSysreg_driver", { 0xDB97C70E, 0x0CFD5A8A, 0x314A489C, 0x0E6301D0, 0xE65B0490 } }, // sceSysregSemaUnlock660
{ "SysMemForKernel", { 0xB4F00CB5, 0xF0E0AB7A, 0xB9796F69, 0x2CFF6F90, 0x12720EDA } }, // sceKernelGetCompiledSdkVersion
{ "SysMemForKernel", { 0x07C586A1, 0x458A70B5, 0x864EBFD7, 0, 0 } }, // sceKernelGetModel
{ "SysMemForKernel", { 0xC90B0992, 0x3DE3C6DF, 0xF5780DAA, 0xD7E24299, 0x523E300A } }, // sceKernelGetUIDcontrolBlock
{ "SysMemForKernel", { 0x8AE776AF, 0x2CFE3B22, 0, 0, 0 } }, // sceKernelMemset
{ "SysMemForKernel", { 0x310802A9, 0x25A760F0, 0x02AEA33F, 0, 0 } }, // SysMemForKernel_310802A9
{ "SysMemForKernel", { 0xF12A62F7, 0x52B54B93, 0xFEB5C72B, 0x950BCB31, 0x5136926D } },
{ "SysMemForKernel", { 0xFDC97D28, 0xF2FEAFD5, 0xA4AC3934, 0, 0 } },
};
u32 GetHLENidAlias(std::string_view moduleName, u32 nid) {
for (const auto &row : hleKernelNids) {
for (int i = 1; i < (int)ARRAY_SIZE(row.nids); i++) {
if (row.nids[i] == nid && moduleName == row.module) {
return row.nids[0];
}
}
}
return 0;
}
void RegisterAllModules() {
Register_Kernel_Library();
Register_ThreadManForUser();
Register_ThreadManForKernel();
Register_LoadExecForUser();
Register_UtilsForKernel();
Register_SysMemUserForUser();
Register_InterruptManager();
Register_IoFileMgrForUser();
Register_ModuleMgrForUser();
Register_ModuleMgrForKernel();
Register_StdioForUser();
Register_sceHprm();
Register_sceCcc();
Register_sceCtrl();
Register_sceDisplay();
Register_sceAudio();
Register_sceSasCore();
Register_sceFont();
Register_sceNet();
Register_sceNetResolver();
Register_sceNetInet();
Register_sceNetApctl();
Register_sceNetAdhoc();
Register_sceNetAdhocMatching();
Register_sceNetAdhocDiscover();
Register_sceNetAdhocctl();
Register_sceRtc();
Register_sceWlanDrv();
Register_sceMpeg();
Register_sceMp3();
Register_sceHttp();
Register_scePower();
Register_sceImpose();
Register_sceSuspendForUser();
Register_sceGe_user();
Register_sceUmdUser();
Register_sceDmac();
Register_sceUtility();
Register_sceAtrac3plus();
Register_scePsmf();
Register_scePsmfPlayer();
Register_sceOpenPSID();
Register_sceParseUri();
Register_sceSsl();
Register_sceParseHttp();
Register_sceVaudio();
Register_sceUsb();
Register_sceChnnlsv();
Register_sceNpDrm();
Register_sceP3da();
Register_sceGameUpdate();
Register_sceDeflt();
Register_sceMp4();
Register_sceAac();
Register_scePauth();
Register_sceNp();
Register_sceNpCommerce2();
Register_sceNpService();
Register_sceNpAuth();
Register_sceMd5();
Register_sceJpeg();
Register_sceAudiocodec();
Register_sceHeap();
for (int i = 0; i < numModules; i++) {
RegisterHLEModule(moduleList[i].name, moduleList[i].numFunctions, moduleList[i].funcTable);
}
// IMPORTANT: New modules have to be added at the end, or they will break savestates.
Register_StdioForKernel();
RegisterHLEModule("LoadCoreForKernel", ARRAY_SIZE(LoadCoreForKernel), LoadCoreForKernel);
Register_IoFileMgrForKernel();
Register_LoadExecForKernel();
Register_SysMemForKernel();
Register_sceMt19937();
Register_SysclibForKernel();
Register_sceCtrl_driver();
Register_sceDisplay_driver();
Register_sceMpegbase();
Register_sceUsbGps();
Register_sceLibFttt();
Register_sceSha256();
Register_sceAdler();
Register_sceSfmt19937();
Register_sceAudioRouting();
Register_sceUsbCam();
Register_sceG729();
Register_sceNetUpnp();
Register_sceNetIfhandle();
Register_KUBridge();
Register_sceUsbAcc();
Register_sceUsbMic();
Register_sceOpenPSID_driver();
Register_semaphore();
Register_sceDdrdb();
Register_mp4msv();
Register_InterruptManagerForKernel();
Register_sceSircs();
Register_sceNet_lib();
Register_sceReg();
Register_sceRtc_driver();
Register_scePower_driver();
Register_sceImpose_driver();
Register_sceHprm_driver();
Register_sceChkreg();
Register_sceVshBridge();
Register_sceResmgr();
Register_sceVideocodec();
// add new modules here.
Register_SystemCtrlForKernel();
Register_sceGe_driver();
Register_sceMePower_driver();
Register_SystemCtrlForUser();
Register_ExceptionManagerForKernel();
Register_sceSysreg_driver();
Register_sceSysEventForKernel();
Register_sceAmctrl_driver();
Register_InitForKernel();
Register_PopsBootCalls();
Register_sceVaudio_driver();
Register_sceNetApctl_lib();
// Not ready to enable this due to apparent softlocks in Patapon 3.
// Register_sceNpMatching2();
}
Reference in new issue View Git Blame Copy Permalink