Merge pull request #319 from Hexagon12/service-name-fix

Various service name fixes - part 1

src/core/hle/service/am/am.cpp

@@ -19,8 +19,11 @@ namespace AM {
 
 IWindowController::IWindowController() : ServiceFramework("IWindowController") {
     static const FunctionInfo functions[] = {
+        {0, nullptr, "CreateWindow"},
         {1, &IWindowController::GetAppletResourceUserId, "GetAppletResourceUserId"},
         {10, &IWindowController::AcquireForegroundRights, "AcquireForegroundRights"},
+        {11, nullptr, "ReleaseForegroundRights"},
+        {12, nullptr, "RejectToChangeIntoBackground"},
     };
     RegisterHandlers(functions);
 }
@@ -78,8 +81,11 @@ IDebugFunctions::IDebugFunctions() : ServiceFramework("IDebugFunctions") {}
 ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
     : ServiceFramework("ISelfController"), nvflinger(std::move(nvflinger)) {
     static const FunctionInfo functions[] = {
+        {0, nullptr, "Exit"},
         {1, &ISelfController::LockExit, "LockExit"},
         {2, &ISelfController::UnlockExit, "UnlockExit"},
+        {3, nullptr, "EnterFatalSection"},
+        {4, nullptr, "LeaveFatalSection"},
         {9, &ISelfController::GetLibraryAppletLaunchableEvent, "GetLibraryAppletLaunchableEvent"},
         {10, &ISelfController::SetScreenShotPermission, "SetScreenShotPermission"},
         {11, &ISelfController::SetOperationModeChangedNotification,
@@ -88,8 +94,29 @@ ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger
          "SetPerformanceModeChangedNotification"},
         {13, &ISelfController::SetFocusHandlingMode, "SetFocusHandlingMode"},
         {14, &ISelfController::SetRestartMessageEnabled, "SetRestartMessageEnabled"},
+        {15, nullptr, "SetScreenShotAppletIdentityInfo"},
         {16, &ISelfController::SetOutOfFocusSuspendingEnabled, "SetOutOfFocusSuspendingEnabled"},
+        {17, nullptr, "SetControllerFirmwareUpdateSection"},
+        {18, nullptr, "SetRequiresCaptureButtonShortPressedMessage"},
+        {19, nullptr, "SetScreenShotImageOrientation"},
+        {20, nullptr, "SetDesirableKeyboardLayout"},
         {40, &ISelfController::CreateManagedDisplayLayer, "CreateManagedDisplayLayer"},
+        {41, nullptr, "IsSystemBufferSharingEnabled"},
+        {42, nullptr, "GetSystemSharedLayerHandle"},
+        {50, nullptr, "SetHandlesRequestToDisplay"},
+        {51, nullptr, "ApproveToDisplay"},
+        {60, nullptr, "OverrideAutoSleepTimeAndDimmingTime"},
+        {61, nullptr, "SetMediaPlaybackState"},
+        {62, nullptr, "SetIdleTimeDetectionExtension"},
+        {63, nullptr, "GetIdleTimeDetectionExtension"},
+        {64, nullptr, "SetInputDetectionSourceSet"},
+        {65, nullptr, "ReportUserIsActive"},
+        {66, nullptr, "GetCurrentIlluminance"},
+        {67, nullptr, "IsIlluminanceAvailable"},
+        {68, nullptr, "SetAutoSleepDisabled"},
+        {69, nullptr, "IsAutoSleepDisabled"},
+        {70, nullptr, "ReportMultimediaError"},
+        {80, nullptr, "SetWirelessPriorityMode"},
     };
     RegisterHandlers(functions);
 
@@ -206,9 +233,30 @@ ICommonStateGetter::ICommonStateGetter() : ServiceFramework("ICommonStateGetter"
     static const FunctionInfo functions[] = {
         {0, &ICommonStateGetter::GetEventHandle, "GetEventHandle"},
         {1, &ICommonStateGetter::ReceiveMessage, "ReceiveMessage"},
+        {2, nullptr, "GetThisAppletKind"},
+        {3, nullptr, "AllowToEnterSleep"},
+        {4, nullptr, "DisallowToEnterSleep"},
         {5, &ICommonStateGetter::GetOperationMode, "GetOperationMode"},
         {6, &ICommonStateGetter::GetPerformanceMode, "GetPerformanceMode"},
+        {7, nullptr, "GetCradleStatus"},
+        {8, nullptr, "GetBootMode"},
         {9, &ICommonStateGetter::GetCurrentFocusState, "GetCurrentFocusState"},
+        {10, nullptr, "RequestToAcquireSleepLock"},
+        {11, nullptr, "ReleaseSleepLock"},
+        {12, nullptr, "ReleaseSleepLockTransiently"},
+        {13, nullptr, "GetAcquiredSleepLockEvent"},
+        {20, nullptr, "PushToGeneralChannel"},
+        {30, nullptr, "GetHomeButtonReaderLockAccessor"},
+        {31, nullptr, "GetReaderLockAccessorEx"},
+        {40, nullptr, "GetCradleFwVersion"},
+        {50, nullptr, "IsVrModeEnabled"},
+        {51, nullptr, "SetVrModeEnabled"},
+        {52, nullptr, "SwitchLcdBacklight"},
+        {55, nullptr, "IsInControllerFirmwareUpdateSection"},
+        {60, nullptr, "GetDefaultDisplayResolution"},
+        {61, nullptr, "GetDefaultDisplayResolutionChangeEvent"},
+        {62, nullptr, "GetHdcpAuthenticationState"},
+        {63, nullptr, "GetHdcpAuthenticationStateChangeEvent"},
     };
     RegisterHandlers(functions);
 
@@ -278,7 +326,7 @@ public:
             {104, nullptr, "PopInteractiveOutData"},
             {105, nullptr, "GetPopOutDataEvent"},
             {106, nullptr, "GetPopInteractiveOutDataEvent"},
-            {120, nullptr, "NeedsToExitProcess"},
+            {110, nullptr, "NeedsToExitProcess"},
             {120, nullptr, "GetLibraryAppletInfo"},
             {150, nullptr, "RequestForAppletToGetForeground"},
             {160, nullptr, "GetIndirectLayerConsumerHandle"},
@@ -330,6 +378,7 @@ public:
         : ServiceFramework("IStorageAccessor"), buffer(std::move(buffer)) {
         static const FunctionInfo functions[] = {
             {0, &IStorageAccessor::GetSize, "GetSize"},
+            {10, nullptr, "Write"},
             {11, &IStorageAccessor::Read, "Read"},
         };
         RegisterHandlers(functions);
@@ -372,6 +421,7 @@ public:
         : ServiceFramework("IStorage"), buffer(std::move(buffer)) {
         static const FunctionInfo functions[] = {
             {0, &IStorage::Open, "Open"},
+            {1, nullptr, "OpenTransferStorage"},
         };
         RegisterHandlers(functions);
     }
@@ -392,12 +442,42 @@ private:
 IApplicationFunctions::IApplicationFunctions() : ServiceFramework("IApplicationFunctions") {
     static const FunctionInfo functions[] = {
         {1, &IApplicationFunctions::PopLaunchParameter, "PopLaunchParameter"},
+        {10, nullptr, "CreateApplicationAndPushAndRequestToStart"},
+        {11, nullptr, "CreateApplicationAndPushAndRequestToStartForQuest"},
+        {12, nullptr, "CreateApplicationAndRequestToStart"},
+        {13, nullptr, "CreateApplicationAndRequestToStartForQuest"},
         {20, &IApplicationFunctions::EnsureSaveData, "EnsureSaveData"},
         {21, &IApplicationFunctions::GetDesiredLanguage, "GetDesiredLanguage"},
         {22, &IApplicationFunctions::SetTerminateResult, "SetTerminateResult"},
+        {23, nullptr, "GetDisplayVersion"},
+        {24, nullptr, "GetLaunchStorageInfoForDebug"},
+        {25, nullptr, "ExtendSaveData"},
+        {26, nullptr, "GetSaveDataSize"},
+        {30, nullptr, "BeginBlockingHomeButtonShortAndLongPressed"},
+        {31, nullptr, "EndBlockingHomeButtonShortAndLongPressed"},
+        {32, nullptr, "BeginBlockingHomeButton"},
+        {33, nullptr, "EndBlockingHomeButton"},
+        {40, &IApplicationFunctions::NotifyRunning, "NotifyRunning"},
+        {50, nullptr, "GetPseudoDeviceId"},
+        {60, nullptr, "SetMediaPlaybackStateForApplication"},
+        {65, nullptr, "IsGamePlayRecordingSupported"},
         {66, &IApplicationFunctions::InitializeGamePlayRecording, "InitializeGamePlayRecording"},
         {67, &IApplicationFunctions::SetGamePlayRecordingState, "SetGamePlayRecordingState"},
-        {40, &IApplicationFunctions::NotifyRunning, "NotifyRunning"},
+        {68, nullptr, "RequestFlushGamePlayingMovieForDebug"},
+        {70, nullptr, "RequestToShutdown"},
+        {71, nullptr, "RequestToReboot"},
+        {80, nullptr, "ExitAndRequestToShowThanksMessage"},
+        {90, nullptr, "EnableApplicationCrashReport"},
+        {100, nullptr, "InitializeApplicationCopyrightFrameBuffer"},
+        {101, nullptr, "SetApplicationCopyrightImage"},
+        {102, nullptr, "SetApplicationCopyrightVisibility"},
+        {110, nullptr, "QueryApplicationPlayStatistics"},
+        {120, nullptr, "ExecuteProgram"},
+        {121, nullptr, "ClearUserChannel"},
+        {122, nullptr, "UnpopToUserChannel"},
+        {500, nullptr, "StartContinuousRecordingFlushForDebug"},
+        {1000, nullptr, "CreateMovieMaker"},
+        {1001, nullptr, "PrepareForJit"},
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/am/applet_ae.cpp

@@ -21,6 +21,7 @@ public:
             {2, &ILibraryAppletProxy::GetWindowController, "GetWindowController"},
             {3, &ILibraryAppletProxy::GetAudioController, "GetAudioController"},
             {4, &ILibraryAppletProxy::GetDisplayController, "GetDisplayController"},
+            {10, nullptr, "GetProcessWindingController"},
             {11, &ILibraryAppletProxy::GetLibraryAppletCreator, "GetLibraryAppletCreator"},
             {20, &ILibraryAppletProxy::GetApplicationFunctions, "GetApplicationFunctions"},
             {1000, &ILibraryAppletProxy::GetDebugFunctions, "GetDebugFunctions"},

src/core/hle/service/am/applet_oe.cpp

@@ -21,6 +21,7 @@ public:
             {2, &IApplicationProxy::GetWindowController, "GetWindowController"},
             {3, &IApplicationProxy::GetAudioController, "GetAudioController"},
             {4, &IApplicationProxy::GetDisplayController, "GetDisplayController"},
+            {10, nullptr, "GetProcessWindingController"},
             {11, &IApplicationProxy::GetLibraryAppletCreator, "GetLibraryAppletCreator"},
             {20, &IApplicationProxy::GetApplicationFunctions, "GetApplicationFunctions"},
             {1000, &IApplicationProxy::GetDebugFunctions, "GetDebugFunctions"},

src/core/hle/service/aoc/aoc_u.cpp

@@ -19,6 +19,7 @@ AOC_U::AOC_U() : ServiceFramework("aoc:u") {
         {5, nullptr, "GetAddOnContentBaseId"},
         {6, nullptr, "PrepareAddOnContentByApplicationId"},
         {7, nullptr, "PrepareAddOnContent"},
+        {8, nullptr, "GetAddOnContentListChangedEvent"},
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/audio/audin_u.cpp

@@ -14,15 +14,20 @@ class IAudioIn final : public ServiceFramework<IAudioIn> {
 public:
     IAudioIn() : ServiceFramework("IAudioIn") {
         static const FunctionInfo functions[] = {
-            {0x0, nullptr, "GetAudioInState"},
-            {0x1, nullptr, "StartAudioIn"},
-            {0x2, nullptr, "StopAudioIn"},
-            {0x3, nullptr, "AppendAudioInBuffer_1"},
-            {0x4, nullptr, "RegisterBufferEvent"},
-            {0x5, nullptr, "GetReleasedAudioInBuffer_1"},
-            {0x6, nullptr, "ContainsAudioInBuffer"},
-            {0x7, nullptr, "AppendAudioInBuffer_2"},
-            {0x8, nullptr, "GetReleasedAudioInBuffer_2"},
+            {0, nullptr, "GetAudioInState"},
+            {1, nullptr, "StartAudioIn"},
+            {2, nullptr, "StopAudioIn"},
+            {3, nullptr, "AppendAudioInBuffer"},
+            {4, nullptr, "RegisterBufferEvent"},
+            {5, nullptr, "GetReleasedAudioInBuffer"},
+            {6, nullptr, "ContainsAudioInBuffer"},
+            {7, nullptr, "AppendAudioInBufferWithUserEvent"},
+            {8, nullptr, "AppendAudioInBufferAuto"},
+            {9, nullptr, "GetReleasedAudioInBufferAuto"},
+            {10, nullptr, "AppendAudioInBufferWithUserEventAuto"},
+            {11, nullptr, "GetAudioInBufferCount"},
+            {12, nullptr, "SetAudioInDeviceGain"},
+            {13, nullptr, "GetAudioInDeviceGain"},
         };
         RegisterHandlers(functions);
     }
@@ -31,8 +36,10 @@ public:
 
 AudInU::AudInU() : ServiceFramework("audin:u") {
     static const FunctionInfo functions[] = {
-        {0x00000000, nullptr, "ListAudioIns"},
-        {0x00000001, nullptr, "OpenAudioIn"},
+        {0, nullptr, "ListAudioIns"},
+        {1, nullptr, "OpenAudioIn"},
+        {3, nullptr, "OpenAudioInAuto"},
+        {4, nullptr, "ListAudioInsAuto"},
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/audio/audout_u.cpp

@@ -25,15 +25,18 @@ class IAudioOut final : public ServiceFramework<IAudioOut> {
 public:
     IAudioOut() : ServiceFramework("IAudioOut"), audio_out_state(AudioState::Stopped) {
         static const FunctionInfo functions[] = {
-            {0x0, &IAudioOut::GetAudioOutState, "GetAudioOutState"},
-            {0x1, &IAudioOut::StartAudioOut, "StartAudioOut"},
-            {0x2, &IAudioOut::StopAudioOut, "StopAudioOut"},
-            {0x3, &IAudioOut::AppendAudioOutBuffer_1, "AppendAudioOutBuffer_1"},
-            {0x4, &IAudioOut::RegisterBufferEvent, "RegisterBufferEvent"},
-            {0x5, &IAudioOut::GetReleasedAudioOutBuffer_1, "GetReleasedAudioOutBuffer_1"},
-            {0x6, nullptr, "ContainsAudioOutBuffer"},
-            {0x7, nullptr, "AppendAudioOutBuffer_2"},
-            {0x8, nullptr, "GetReleasedAudioOutBuffer_2"},
+            {0, &IAudioOut::GetAudioOutState, "GetAudioOutState"},
+            {1, &IAudioOut::StartAudioOut, "StartAudioOut"},
+            {2, &IAudioOut::StopAudioOut, "StopAudioOut"},
+            {3, &IAudioOut::AppendAudioOutBuffer, "AppendAudioOutBuffer"},
+            {4, &IAudioOut::RegisterBufferEvent, "RegisterBufferEvent"},
+            {5, &IAudioOut::GetReleasedAudioOutBuffer, "GetReleasedAudioOutBuffer"},
+            {6, nullptr, "ContainsAudioOutBuffer"},
+            {7, nullptr, "AppendAudioOutBufferAuto"},
+            {8, nullptr, "GetReleasedAudioOutBufferAuto"},
+            {9, nullptr, "GetAudioOutBufferCount"},
+            {10, nullptr, "GetAudioOutPlayedSampleCount"},
+            {11, nullptr, "FlushAudioOutBuffers"},
         };
         RegisterHandlers(functions);
 
@@ -94,7 +97,7 @@ private:
         rb.PushCopyObjects(buffer_event);
     }
 
-    void AppendAudioOutBuffer_1(Kernel::HLERequestContext& ctx) {
+    void AppendAudioOutBuffer(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_Audio, "(STUBBED) called");
         IPC::RequestParser rp{ctx};
 
@@ -105,7 +108,7 @@ private:
         rb.Push(RESULT_SUCCESS);
     }
 
-    void GetReleasedAudioOutBuffer_1(Kernel::HLERequestContext& ctx) {
+    void GetReleasedAudioOutBuffer(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_Audio, "(STUBBED) called");
 
         // TODO(st4rk): This is how libtransistor currently implements the
@@ -196,8 +199,8 @@ void AudOutU::OpenAudioOut(Kernel::HLERequestContext& ctx) {
 AudOutU::AudOutU() : ServiceFramework("audout:u") {
     static const FunctionInfo functions[] = {{0x00000000, &AudOutU::ListAudioOuts, "ListAudioOuts"},
                                              {0x00000001, &AudOutU::OpenAudioOut, "OpenAudioOut"},
-                                             {0x00000002, nullptr, "Unknown2"},
-                                             {0x00000003, nullptr, "Unknown3"}};
+                                             {0x00000002, nullptr, "ListAudioOutsAuto"},
+                                             {0x00000003, nullptr, "OpenAudioOutAuto"}};
     RegisterHandlers(functions);
 }
 

src/core/hle/service/audio/audrec_u.cpp

@@ -14,13 +14,15 @@ class IFinalOutputRecorder final : public ServiceFramework<IFinalOutputRecorder>
 public:
     IFinalOutputRecorder() : ServiceFramework("IFinalOutputRecorder") {
         static const FunctionInfo functions[] = {
-            {0x0, nullptr, "GetFinalOutputRecorderState"},
-            {0x1, nullptr, "StartFinalOutputRecorder"},
-            {0x2, nullptr, "StopFinalOutputRecorder"},
-            {0x3, nullptr, "AppendFinalOutputRecorderBuffer"},
-            {0x4, nullptr, "RegisterBufferEvent"},
-            {0x5, nullptr, "GetReleasedFinalOutputRecorderBuffer"},
-            {0x6, nullptr, "ContainsFinalOutputRecorderBuffer"},
+            {0, nullptr, "GetFinalOutputRecorderState"},
+            {1, nullptr, "StartFinalOutputRecorder"},
+            {2, nullptr, "StopFinalOutputRecorder"},
+            {3, nullptr, "AppendFinalOutputRecorderBuffer"},
+            {4, nullptr, "RegisterBufferEvent"},
+            {5, nullptr, "GetReleasedFinalOutputRecorderBuffer"},
+            {6, nullptr, "ContainsFinalOutputRecorderBuffer"},
+            {8, nullptr, "AppendFinalOutputRecorderBufferAuto"},
+            {9, nullptr, "GetReleasedFinalOutputRecorderBufferAuto"},
         };
         RegisterHandlers(functions);
     }

src/core/hle/service/audio/audren_u.cpp

@@ -19,16 +19,18 @@ class IAudioRenderer final : public ServiceFramework<IAudioRenderer> {
 public:
     IAudioRenderer() : ServiceFramework("IAudioRenderer") {
         static const FunctionInfo functions[] = {
-            {0x0, nullptr, "GetAudioRendererSampleRate"},
-            {0x1, nullptr, "GetAudioRendererSampleCount"},
-            {0x2, nullptr, "GetAudioRendererMixBufferCount"},
-            {0x3, nullptr, "GetAudioRendererState"},
-            {0x4, &IAudioRenderer::RequestUpdateAudioRenderer, "RequestUpdateAudioRenderer"},
-            {0x5, &IAudioRenderer::StartAudioRenderer, "StartAudioRenderer"},
-            {0x6, &IAudioRenderer::StopAudioRenderer, "StopAudioRenderer"},
-            {0x7, &IAudioRenderer::QuerySystemEvent, "QuerySystemEvent"},
-            {0x8, nullptr, "SetAudioRendererRenderingTimeLimit"},
-            {0x9, nullptr, "GetAudioRendererRenderingTimeLimit"},
+            {0, nullptr, "GetAudioRendererSampleRate"},
+            {1, nullptr, "GetAudioRendererSampleCount"},
+            {2, nullptr, "GetAudioRendererMixBufferCount"},
+            {3, nullptr, "GetAudioRendererState"},
+            {4, &IAudioRenderer::RequestUpdateAudioRenderer, "RequestUpdateAudioRenderer"},
+            {5, &IAudioRenderer::StartAudioRenderer, "StartAudioRenderer"},
+            {6, &IAudioRenderer::StopAudioRenderer, "StopAudioRenderer"},
+            {7, &IAudioRenderer::QuerySystemEvent, "QuerySystemEvent"},
+            {8, nullptr, "SetAudioRendererRenderingTimeLimit"},
+            {9, nullptr, "GetAudioRendererRenderingTimeLimit"},
+            {10, nullptr, "RequestUpdateAudioRendererAuto"},
+            {11, nullptr, "ExecuteAudioRendererRendering"},
         };
         RegisterHandlers(functions);
 
@@ -237,6 +239,8 @@ AudRenU::AudRenU() : ServiceFramework("audren:u") {
         {0, &AudRenU::OpenAudioRenderer, "OpenAudioRenderer"},
         {1, &AudRenU::GetAudioRendererWorkBufferSize, "GetAudioRendererWorkBufferSize"},
         {2, &AudRenU::GetAudioDevice, "GetAudioDevice"},
+        {3, nullptr, "OpenAudioRendererAuto"},
+        {4, nullptr, "GetAudioDeviceServiceWithRevisionInfo"},
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/audio/codecctl.cpp

@@ -22,9 +22,9 @@ CodecCtl::CodecCtl() : ServiceFramework("codecctl") {
         {0x00000007, nullptr, "SetCodecActiveTarget"},
         {0x00000008, nullptr, "Unknown"},
         {0x00000009, nullptr, "BindCodecHeadphoneMicJackInterrupt"},
-        {0x0000000A, nullptr, "IsCodecHeadphoneMicJackInserted"},
-        {0x0000000B, nullptr, "ClearCodecHeadphoneMicJackInterrupt"},
-        {0x0000000C, nullptr, "IsCodecDeviceRequested"},
+        {0x00000010, nullptr, "IsCodecHeadphoneMicJackInserted"},
+        {0x00000011, nullptr, "ClearCodecHeadphoneMicJackInterrupt"},
+        {0x00000012, nullptr, "IsCodecDeviceRequested"},
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/filesystem/fsp_srv.cpp

@@ -23,7 +23,7 @@ public:
         : ServiceFramework("IStorage"), backend(std::move(backend)) {
         static const FunctionInfo functions[] = {
             {0, &IStorage::Read, "Read"}, {1, nullptr, "Write"},   {2, nullptr, "Flush"},
-            {3, nullptr, "SetSize"},      {4, nullptr, "GetSize"},
+            {3, nullptr, "SetSize"},      {4, nullptr, "GetSize"}, {5, nullptr, "OperateRange"},
         };
         RegisterHandlers(functions);
     }
@@ -72,8 +72,9 @@ public:
     explicit IFile(std::unique_ptr<FileSys::StorageBackend>&& backend)
         : ServiceFramework("IFile"), backend(std::move(backend)) {
         static const FunctionInfo functions[] = {
-            {0, &IFile::Read, "Read"},       {1, &IFile::Write, "Write"},     {2, nullptr, "Flush"},
-            {3, &IFile::SetSize, "SetSize"}, {4, &IFile::GetSize, "GetSize"},
+            {0, &IFile::Read, "Read"},       {1, &IFile::Write, "Write"},
+            {2, nullptr, "Flush"},           {3, &IFile::SetSize, "SetSize"},
+            {4, &IFile::GetSize, "GetSize"}, {5, nullptr, "OperateRange"},
         };
         RegisterHandlers(functions);
     }
@@ -227,11 +228,21 @@ public:
         : ServiceFramework("IFileSystem"), backend(std::move(backend)) {
         static const FunctionInfo functions[] = {
             {0, &IFileSystem::CreateFile, "CreateFile"},
+            {1, nullptr, "DeleteFile"},
             {2, &IFileSystem::CreateDirectory, "CreateDirectory"},
+            {3, nullptr, "DeleteDirectory"},
+            {4, nullptr, "DeleteDirectoryRecursively"},
+            {5, nullptr, "RenameFile"},
+            {6, nullptr, "RenameDirectory"},
             {7, &IFileSystem::GetEntryType, "GetEntryType"},
             {8, &IFileSystem::OpenFile, "OpenFile"},
             {9, &IFileSystem::OpenDirectory, "OpenDirectory"},
             {10, &IFileSystem::Commit, "Commit"},
+            {11, nullptr, "GetFreeSpaceSize"},
+            {12, nullptr, "GetTotalSpaceSize"},
+            {13, nullptr, "CleanDirectoryRecursively"},
+            {14, nullptr, "GetFileTimeStampRaw"},
+            {15, nullptr, "QueryEntry"},
         };
         RegisterHandlers(functions);
     }
@@ -356,14 +367,94 @@ private:
 
 FSP_SRV::FSP_SRV() : ServiceFramework("fsp-srv") {
     static const FunctionInfo functions[] = {
+        {0, nullptr, "MountContent"},
         {1, &FSP_SRV::Initialize, "Initialize"},
+        {2, nullptr, "OpenDataFileSystemByCurrentProcess"},
+        {7, nullptr, "OpenFileSystemWithPatch"},
+        {8, nullptr, "OpenFileSystemWithId"},
+        {9, nullptr, "OpenDataFileSystemByApplicationId"},
+        {11, nullptr, "OpenBisFileSystem"},
+        {12, nullptr, "OpenBisStorage"},
+        {13, nullptr, "InvalidateBisCache"},
+        {17, nullptr, "OpenHostFileSystem"},
         {18, &FSP_SRV::MountSdCard, "MountSdCard"},
+        {19, nullptr, "FormatSdCardFileSystem"},
+        {21, nullptr, "DeleteSaveDataFileSystem"},
         {22, &FSP_SRV::CreateSaveData, "CreateSaveData"},
+        {23, nullptr, "CreateSaveDataFileSystemBySystemSaveDataId"},
+        {24, nullptr, "RegisterSaveDataFileSystemAtomicDeletion"},
+        {25, nullptr, "DeleteSaveDataFileSystemBySaveDataSpaceId"},
+        {26, nullptr, "FormatSdCardDryRun"},
+        {27, nullptr, "IsExFatSupported"},
+        {28, nullptr, "DeleteSaveDataFileSystemBySaveDataAttribute"},
+        {30, nullptr, "OpenGameCardStorage"},
+        {31, nullptr, "OpenGameCardFileSystem"},
+        {32, nullptr, "ExtendSaveDataFileSystem"},
+        {33, nullptr, "DeleteCacheStorage"},
+        {34, nullptr, "GetCacheStorageSize"},
         {51, &FSP_SRV::MountSaveData, "MountSaveData"},
+        {52, nullptr, "OpenSaveDataFileSystemBySystemSaveDataId"},
+        {53, nullptr, "OpenReadOnlySaveDataFileSystem"},
+        {57, nullptr, "ReadSaveDataFileSystemExtraDataBySaveDataSpaceId"},
+        {58, nullptr, "ReadSaveDataFileSystemExtraData"},
+        {59, nullptr, "WriteSaveDataFileSystemExtraData"},
+        {60, nullptr, "OpenSaveDataInfoReader"},
+        {61, nullptr, "OpenSaveDataInfoReaderBySaveDataSpaceId"},
+        {62, nullptr, "OpenCacheStorageList"},
+        {64, nullptr, "OpenSaveDataInternalStorageFileSystem"},
+        {65, nullptr, "UpdateSaveDataMacForDebug"},
+        {66, nullptr, "WriteSaveDataFileSystemExtraData2"},
+        {80, nullptr, "OpenSaveDataMetaFile"},
+        {81, nullptr, "OpenSaveDataTransferManager"},
+        {82, nullptr, "OpenSaveDataTransferManagerVersion2"},
+        {100, nullptr, "OpenImageDirectoryFileSystem"},
+        {110, nullptr, "OpenContentStorageFileSystem"},
         {200, &FSP_SRV::OpenDataStorageByCurrentProcess, "OpenDataStorageByCurrentProcess"},
+        {201, nullptr, "OpenDataStorageByProgramId"},
         {202, nullptr, "OpenDataStorageByDataId"},
         {203, &FSP_SRV::OpenRomStorage, "OpenRomStorage"},
+        {400, nullptr, "OpenDeviceOperator"},
+        {500, nullptr, "OpenSdCardDetectionEventNotifier"},
+        {501, nullptr, "OpenGameCardDetectionEventNotifier"},
+        {510, nullptr, "OpenSystemDataUpdateEventNotifier"},
+        {511, nullptr, "NotifySystemDataUpdateEvent"},
+        {600, nullptr, "SetCurrentPosixTime"},
+        {601, nullptr, "QuerySaveDataTotalSize"},
+        {602, nullptr, "VerifySaveDataFileSystem"},
+        {603, nullptr, "CorruptSaveDataFileSystem"},
+        {604, nullptr, "CreatePaddingFile"},
+        {605, nullptr, "DeleteAllPaddingFiles"},
+        {606, nullptr, "GetRightsId"},
+        {607, nullptr, "RegisterExternalKey"},
+        {608, nullptr, "UnregisterAllExternalKey"},
+        {609, nullptr, "GetRightsIdByPath"},
+        {610, nullptr, "GetRightsIdAndKeyGenerationByPath"},
+        {611, nullptr, "SetCurrentPosixTimeWithTimeDifference"},
+        {612, nullptr, "GetFreeSpaceSizeForSaveData"},
+        {613, nullptr, "VerifySaveDataFileSystemBySaveDataSpaceId"},
+        {614, nullptr, "CorruptSaveDataFileSystemBySaveDataSpaceId"},
+        {615, nullptr, "QuerySaveDataInternalStorageTotalSize"},
+        {620, nullptr, "SetSdCardEncryptionSeed"},
+        {630, nullptr, "SetSdCardAccessibility"},
+        {631, nullptr, "IsSdCardAccessible"},
+        {640, nullptr, "IsSignedSystemPartitionOnSdCardValid"},
+        {700, nullptr, "OpenAccessFailureResolver"},
+        {701, nullptr, "GetAccessFailureDetectionEvent"},
+        {702, nullptr, "IsAccessFailureDetected"},
+        {710, nullptr, "ResolveAccessFailure"},
+        {720, nullptr, "AbandonAccessFailure"},
+        {800, nullptr, "GetAndClearFileSystemProxyErrorInfo"},
+        {1000, nullptr, "SetBisRootForHost"},
+        {1001, nullptr, "SetSaveDataSize"},
+        {1002, nullptr, "SetSaveDataRootPath"},
+        {1003, nullptr, "DisableAutoSaveDataCreation"},
+        {1004, nullptr, "SetGlobalAccessLogMode"},
         {1005, &FSP_SRV::GetGlobalAccessLogMode, "GetGlobalAccessLogMode"},
+        {1006, nullptr, "OutputAccessLogToSdCard"},
+        {1007, nullptr, "RegisterUpdatePartition"},
+        {1008, nullptr, "OpenRegisteredUpdatePartition"},
+        {1009, nullptr, "GetAndClearMemoryReportInfo"},
+        {1100, nullptr, "OverrideSaveDataTransferTokenSignVerificationKey"},
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/friend/friend.cpp

@@ -11,7 +11,7 @@
 namespace Service {
 namespace Friend {
 
-void Module::Interface::Unknown(Kernel::HLERequestContext& ctx) {
+void Module::Interface::CreateFriendService(Kernel::HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
     LOG_WARNING(Service_Friend, "(STUBBED) called");

src/core/hle/service/friend/friend.h

@@ -15,7 +15,7 @@ public:
     public:
         Interface(std::shared_ptr<Module> module, const char* name);
 
-        void Unknown(Kernel::HLERequestContext& ctx);
+        void CreateFriendService(Kernel::HLERequestContext& ctx);
 
     protected:
         std::shared_ptr<Module> module;

src/core/hle/service/friend/friend_a.cpp

@@ -10,7 +10,8 @@ namespace Friend {
 Friend_A::Friend_A(std::shared_ptr<Module> module)
     : Module::Interface(std::move(module), "friend:a") {
     static const FunctionInfo functions[] = {
-        {0, &Friend_A::Unknown, "Unknown"},
+        {0, &Friend_A::CreateFriendService, "CreateFriendService"},
+        {1, nullptr, "CreateNotificationService"},
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/friend/friend_u.cpp

@@ -10,7 +10,8 @@ namespace Friend {
 Friend_U::Friend_U(std::shared_ptr<Module> module)
     : Module::Interface(std::move(module), "friend:u") {
     static const FunctionInfo functions[] = {
-        {0, &Friend_U::Unknown, "Unknown"},
+        {0, &Friend_U::CreateFriendService, "CreateFriendService"},
+        {1, nullptr, "CreateNotificationService"},
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/hid/hid.cpp

@@ -198,25 +198,75 @@ public:
             {11, &Hid::ActivateTouchScreen, "ActivateTouchScreen"},
             {21, &Hid::ActivateMouse, "ActivateMouse"},
             {31, &Hid::ActivateKeyboard, "ActivateKeyboard"},
+            {40, nullptr, "AcquireXpadIdEventHandle"},
+            {41, nullptr, "ReleaseXpadIdEventHandle"},
+            {51, nullptr, "ActivateXpad"},
+            {55, nullptr, "GetXpadIds"},
+            {56, nullptr, "ActivateJoyXpad"},
+            {58, nullptr, "GetJoyXpadLifoHandle"},
+            {59, nullptr, "GetJoyXpadIds"},
+            {60, nullptr, "ActivateSixAxisSensor"},
+            {61, nullptr, "DeactivateSixAxisSensor"},
+            {62, nullptr, "GetSixAxisSensorLifoHandle"},
+            {63, nullptr, "ActivateJoySixAxisSensor"},
+            {64, nullptr, "DeactivateJoySixAxisSensor"},
+            {65, nullptr, "GetJoySixAxisSensorLifoHandle"},
             {66, &Hid::StartSixAxisSensor, "StartSixAxisSensor"},
+            {67, nullptr, "StopSixAxisSensor"},
+            {68, nullptr, "IsSixAxisSensorFusionEnabled"},
+            {69, nullptr, "EnableSixAxisSensorFusion"},
+            {70, nullptr, "SetSixAxisSensorFusionParameters"},
+            {71, nullptr, "GetSixAxisSensorFusionParameters"},
+            {72, nullptr, "ResetSixAxisSensorFusionParameters"},
+            {73, nullptr, "SetAccelerometerParameters"},
+            {74, nullptr, "GetAccelerometerParameters"},
+            {75, nullptr, "ResetAccelerometerParameters"},
+            {76, nullptr, "SetAccelerometerPlayMode"},
+            {77, nullptr, "GetAccelerometerPlayMode"},
+            {78, nullptr, "ResetAccelerometerPlayMode"},
             {79, &Hid::SetGyroscopeZeroDriftMode, "SetGyroscopeZeroDriftMode"},
+            {80, nullptr, "GetGyroscopeZeroDriftMode"},
+            {81, nullptr, "ResetGyroscopeZeroDriftMode"},
+            {82, nullptr, "IsSixAxisSensorAtRest"},
+            {91, nullptr, "ActivateGesture"},
             {100, &Hid::SetSupportedNpadStyleSet, "SetSupportedNpadStyleSet"},
             {101, &Hid::GetSupportedNpadStyleSet, "GetSupportedNpadStyleSet"},
             {102, &Hid::SetSupportedNpadIdType, "SetSupportedNpadIdType"},
             {103, &Hid::ActivateNpad, "ActivateNpad"},
+            {104, nullptr, "DeactivateNpad"},
             {106, &Hid::AcquireNpadStyleSetUpdateEventHandle,
              "AcquireNpadStyleSetUpdateEventHandle"},
+            {107, nullptr, "DisconnectNpad"},
+            {108, nullptr, "GetPlayerLedPattern"},
             {120, &Hid::SetNpadJoyHoldType, "SetNpadJoyHoldType"},
             {121, &Hid::GetNpadJoyHoldType, "GetNpadJoyHoldType"},
             {122, &Hid::SetNpadJoyAssignmentModeSingleByDefault,
              "SetNpadJoyAssignmentModeSingleByDefault"},
+            {123, nullptr, "SetNpadJoyAssignmentModeSingleByDefault"},
             {124, &Hid::SetNpadJoyAssignmentModeDual, "SetNpadJoyAssignmentModeDual"},
+            {125, nullptr, "MergeSingleJoyAsDualJoy"},
+            {126, nullptr, "StartLrAssignmentMode"},
+            {127, nullptr, "StopLrAssignmentMode"},
             {128, &Hid::SetNpadHandheldActivationMode, "SetNpadHandheldActivationMode"},
+            {129, nullptr, "GetNpadHandheldActivationMode"},
+            {130, nullptr, "SwapNpadAssignment"},
+            {131, nullptr, "IsUnintendedHomeButtonInputProtectionEnabled"},
+            {132, nullptr, "EnableUnintendedHomeButtonInputProtection"},
             {200, &Hid::GetVibrationDeviceInfo, "GetVibrationDeviceInfo"},
             {201, &Hid::SendVibrationValue, "SendVibrationValue"},
             {202, &Hid::GetActualVibrationValue, "GetActualVibrationValue"},
             {203, &Hid::CreateActiveVibrationDeviceList, "CreateActiveVibrationDeviceList"},
+            {204, nullptr, "PermitVibration"},
+            {205, nullptr, "IsVibrationPermitted"},
             {206, &Hid::SendVibrationValues, "SendVibrationValues"},
+            {300, nullptr, "ActivateConsoleSixAxisSensor"},
+            {301, nullptr, "StartConsoleSixAxisSensor"},
+            {302, nullptr, "StopConsoleSixAxisSensor"},
+            {400, nullptr, "IsUsbFullKeyControllerEnabled"},
+            {401, nullptr, "EnableUsbFullKeyController"},
+            {402, nullptr, "IsUsbFullKeyControllerConnected"},
+            {1000, nullptr, "SetNpadCommunicationMode"},
+            {1001, nullptr, "GetNpadCommunicationMode"},
         };
         RegisterHandlers(functions);
 

src/core/hle/service/ns/pl_u.cpp

@@ -37,7 +37,9 @@ PL_U::PL_U() : ServiceFramework("pl:u") {
         {1, &PL_U::GetLoadState, "GetLoadState"},
         {2, &PL_U::GetSize, "GetSize"},
         {3, &PL_U::GetSharedMemoryAddressOffset, "GetSharedMemoryAddressOffset"},
-        {4, &PL_U::GetSharedMemoryNativeHandle, "GetSharedMemoryNativeHandle"}};
+        {4, &PL_U::GetSharedMemoryNativeHandle, "GetSharedMemoryNativeHandle"},
+        {5, nullptr, "GetSharedFontInOrderOfPriority"},
+    };
     RegisterHandlers(functions);
 
     // Attempt to load shared font data from disk

src/core/hle/service/nvdrv/interface.cpp

@@ -96,7 +96,14 @@ NVDRV::NVDRV(std::shared_ptr<Module> nvdrv, const char* name)
         {2, &NVDRV::Close, "Close"},
         {3, &NVDRV::Initialize, "Initialize"},
         {4, &NVDRV::QueryEvent, "QueryEvent"},
+        {5, nullptr, "MapSharedMem"},
+        {6, nullptr, "GetStatus"},
+        {7, nullptr, "ForceSetClientPID"},
         {8, &NVDRV::SetClientPID, "SetClientPID"},
+        {9, nullptr, "DumpGraphicsMemoryInfo"},
+        {10, nullptr, "InitializeDevtools"},
+        {11, nullptr, "Ioctl2"},
+        {12, nullptr, "Ioctl3"},
         {13, &NVDRV::FinishInitialize, "FinishInitialize"},
     };
     RegisterHandlers(functions);

src/core/hle/service/nvdrv/nvmemp.cpp

@@ -13,17 +13,17 @@ namespace Nvidia {
 
 NVMEMP::NVMEMP() : ServiceFramework("nvmemp") {
     static const FunctionInfo functions[] = {
-        {0, &NVMEMP::Unknown0, "Unknown0"},
-        {1, &NVMEMP::Unknown1, "Unknown1"},
+        {0, &NVMEMP::Cmd0, "Cmd0"},
+        {1, &NVMEMP::Cmd1, "Cmd1"},
     };
     RegisterHandlers(functions);
 }
 
-void NVMEMP::Unknown0(Kernel::HLERequestContext& ctx) {
+void NVMEMP::Cmd0(Kernel::HLERequestContext& ctx) {
     UNIMPLEMENTED();
 }
 
-void NVMEMP::Unknown1(Kernel::HLERequestContext& ctx) {
+void NVMEMP::Cmd1(Kernel::HLERequestContext& ctx) {
     UNIMPLEMENTED();
 }
 

src/core/hle/service/nvdrv/nvmemp.h

@@ -15,8 +15,8 @@ public:
     ~NVMEMP() = default;
 
 private:
-    void Unknown0(Kernel::HLERequestContext& ctx);
-    void Unknown1(Kernel::HLERequestContext& ctx);
+    void Cmd0(Kernel::HLERequestContext& ctx);
+    void Cmd1(Kernel::HLERequestContext& ctx);
 };
 
 } // namespace Nvidia

src/core/hle/service/pctl/pctl_a.cpp

@@ -11,10 +11,106 @@ namespace PCTL {
 
 class IParentalControlService final : public ServiceFramework<IParentalControlService> {
 public:
-    IParentalControlService() : ServiceFramework("IParentalControlService") {}
+    IParentalControlService() : ServiceFramework("IParentalControlService") {
+        static const FunctionInfo functions[] = {
+            {1, nullptr, "Initialize"},
+            {1001, nullptr, "CheckFreeCommunicationPermission"},
+            {1002, nullptr, "ConfirmLaunchApplicationPermission"},
+            {1003, nullptr, "ConfirmResumeApplicationPermission"},
+            {1004, nullptr, "ConfirmSnsPostPermission"},
+            {1005, nullptr, "ConfirmSystemSettingsPermission"},
+            {1006, nullptr, "IsRestrictionTemporaryUnlocked"},
+            {1007, nullptr, "RevertRestrictionTemporaryUnlocked"},
+            {1008, nullptr, "EnterRestrictedSystemSettings"},
+            {1009, nullptr, "LeaveRestrictedSystemSettings"},
+            {1010, nullptr, "IsRestrictedSystemSettingsEntered"},
+            {1011, nullptr, "RevertRestrictedSystemSettingsEntered"},
+            {1012, nullptr, "GetRestrictedFeatures"},
+            {1013, nullptr, "ConfirmStereoVisionPermission"},
+            {1014, nullptr, "ConfirmPlayableApplicationVideoOld"},
+            {1015, nullptr, "ConfirmPlayableApplicationVideo"},
+            {1031, nullptr, "IsRestrictionEnabled"},
+            {1032, nullptr, "GetSafetyLevel"},
+            {1033, nullptr, "SetSafetyLevel"},
+            {1034, nullptr, "GetSafetyLevelSettings"},
+            {1035, nullptr, "GetCurrentSettings"},
+            {1036, nullptr, "SetCustomSafetyLevelSettings"},
+            {1037, nullptr, "GetDefaultRatingOrganization"},
+            {1038, nullptr, "SetDefaultRatingOrganization"},
+            {1039, nullptr, "GetFreeCommunicationApplicationListCount"},
+            {1042, nullptr, "AddToFreeCommunicationApplicationList"},
+            {1043, nullptr, "DeleteSettings"},
+            {1044, nullptr, "GetFreeCommunicationApplicationList"},
+            {1045, nullptr, "UpdateFreeCommunicationApplicationList"},
+            {1046, nullptr, "DisableFeaturesForReset"},
+            {1047, nullptr, "NotifyApplicationDownloadStarted"},
+            {1061, nullptr, "ConfirmStereoVisionRestrictionConfigurable"},
+            {1062, nullptr, "GetStereoVisionRestriction"},
+            {1063, nullptr, "SetStereoVisionRestriction"},
+            {1064, nullptr, "ResetConfirmedStereoVisionPermission"},
+            {1065, nullptr, "IsStereoVisionPermitted"},
+            {1201, nullptr, "UnlockRestrictionTemporarily"},
+            {1202, nullptr, "UnlockSystemSettingsRestriction"},
+            {1203, nullptr, "SetPinCode"},
+            {1204, nullptr, "GenerateInquiryCode"},
+            {1205, nullptr, "CheckMasterKey"},
+            {1206, nullptr, "GetPinCodeLength"},
+            {1207, nullptr, "GetPinCodeChangedEvent"},
+            {1208, nullptr, "GetPinCode"},
+            {1403, nullptr, "IsPairingActive"},
+            {1406, nullptr, "GetSettingsLastUpdated"},
+            {1411, nullptr, "GetPairingAccountInfo"},
+            {1421, nullptr, "GetAccountNickname"},
+            {1424, nullptr, "GetAccountState"},
+            {1432, nullptr, "GetSynchronizationEvent"},
+            {1451, nullptr, "StartPlayTimer"},
+            {1452, nullptr, "StopPlayTimer"},
+            {1453, nullptr, "IsPlayTimerEnabled"},
+            {1454, nullptr, "GetPlayTimerRemainingTime"},
+            {1455, nullptr, "IsRestrictedByPlayTimer"},
+            {1456, nullptr, "GetPlayTimerSettings"},
+            {1457, nullptr, "GetPlayTimerEventToRequestSuspension"},
+            {1458, nullptr, "IsPlayTimerAlarmDisabled"},
+            {1471, nullptr, "NotifyWrongPinCodeInputManyTimes"},
+            {1472, nullptr, "CancelNetworkRequest"},
+            {1473, nullptr, "GetUnlinkedEvent"},
+            {1474, nullptr, "ClearUnlinkedEvent"},
+            {1601, nullptr, "DisableAllFeatures"},
+            {1602, nullptr, "PostEnableAllFeatures"},
+            {1603, nullptr, "IsAllFeaturesDisabled"},
+            {1901, nullptr, "DeleteFromFreeCommunicationApplicationListForDebug"},
+            {1902, nullptr, "ClearFreeCommunicationApplicationListForDebug"},
+            {1903, nullptr, "GetExemptApplicationListCountForDebug"},
+            {1904, nullptr, "GetExemptApplicationListForDebug"},
+            {1905, nullptr, "UpdateExemptApplicationListForDebug"},
+            {1906, nullptr, "AddToExemptApplicationListForDebug"},
+            {1907, nullptr, "DeleteFromExemptApplicationListForDebug"},
+            {1908, nullptr, "ClearExemptApplicationListForDebug"},
+            {1941, nullptr, "DeletePairing"},
+            {1951, nullptr, "SetPlayTimerSettingsForDebug"},
+            {1952, nullptr, "GetPlayTimerSpentTimeForTest"},
+            {1953, nullptr, "SetPlayTimerAlarmDisabledForDebug"},
+            {2001, nullptr, "RequestPairingAsync"},
+            {2002, nullptr, "FinishRequestPairing"},
+            {2003, nullptr, "AuthorizePairingAsync"},
+            {2004, nullptr, "FinishAuthorizePairing"},
+            {2005, nullptr, "RetrievePairingInfoAsync"},
+            {2006, nullptr, "FinishRetrievePairingInfo"},
+            {2007, nullptr, "UnlinkPairingAsync"},
+            {2008, nullptr, "FinishUnlinkPairing"},
+            {2009, nullptr, "GetAccountMiiImageAsync"},
+            {2010, nullptr, "FinishGetAccountMiiImage"},
+            {2011, nullptr, "GetAccountMiiImageContentTypeAsync"},
+            {2012, nullptr, "FinishGetAccountMiiImageContentType"},
+            {2013, nullptr, "SynchronizeParentalControlSettingsAsync"},
+            {2014, nullptr, "FinishSynchronizeParentalControlSettings"},
+            {2015, nullptr, "FinishSynchronizeParentalControlSettingsWithLastUpdated"},
+            {2016, nullptr, "RequestUpdateExemptionListAsync"},
+        };
+        RegisterHandlers(functions);
+    }
 };
-
-void PCTL_A::GetService(Kernel::HLERequestContext& ctx) {
+void PCTL_A::CreateService(Kernel::HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
     rb.PushIpcInterface<IParentalControlService>();
@@ -23,7 +119,8 @@ void PCTL_A::GetService(Kernel::HLERequestContext& ctx) {
 
 PCTL_A::PCTL_A() : ServiceFramework("pctl:a") {
     static const FunctionInfo functions[] = {
-        {0, &PCTL_A::GetService, "GetService"},
+        {0, &PCTL_A::CreateService, "CreateService"},
+        {1, nullptr, "CreateServiceWithoutInitialize"},
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/pctl/pctl_a.h

@@ -15,7 +15,7 @@ public:
     ~PCTL_A() = default;
 
 private:
-    void GetService(Kernel::HLERequestContext& ctx);
+    void CreateService(Kernel::HLERequestContext& ctx);
 };
 
 } // namespace PCTL