OpenPunk/citra
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Use IPC:MakeHeader instead of hardcoded raw values for IPC command tables. (#6453)

Browse Source 
* Use IPC:MakeHeader instead of hardcoded values for IPC command tables.

* Use u32 instead of unsigned int in MakeHeader function

Co-authored-by: SachinVin <26602104+SachinVin@users.noreply.github.com>

* Fix clang format

---------

Co-authored-by: SachinVin <26602104+SachinVin@users.noreply.github.com>
This commit is contained in:
PabloMK7
2023-04-28 07:31:03 +02:00
committed by GitHub
parent 9bd8c9290b
commit 63bc0b59bb
74 changed files with 1983 additions and 1896 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/core/hle/ipc.h
View File

@@ -56,8 +56,7 @@ union Header {
* @note While @p normal_params_size is equivalent to the number of normal parameters, * @note While @p normal_params_size is equivalent to the number of normal parameters,
* @p translate_params_size includes the size occupied by the translate parameters headers. * @p translate_params_size includes the size occupied by the translate parameters headers.
*/ */
inline u32 MakeHeader(u16 command_id, unsigned int normal_params_size, inline constexpr u32 MakeHeader(u16 command_id, u32 normal_params_size, u32 translate_params_size) {
unsigned int translate_params_size) {
Header header{}; Header header{};
header.command_id.Assign(command_id); header.command_id.Assign(command_id);
header.normal_params_size.Assign(normal_params_size); header.normal_params_size.Assign(normal_params_size);

42
src/core/hle/service/ac/ac_i.cpp
View File

@@ -9,26 +9,28 @@ namespace Service::AC {
AC_I::AC_I(std::shared_ptr<Module> ac) : Module::Interface(std::move(ac), "ac:i", 10) { AC_I::AC_I(std::shared_ptr<Module> ac) : Module::Interface(std::move(ac), "ac:i", 10) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x00010000, &AC_I::CreateDefaultConfig, "CreateDefaultConfig"}, // clang-format off
{0x00040006, &AC_I::ConnectAsync, "ConnectAsync"}, {IPC::MakeHeader(0x0001, 0, 0), &AC_I::CreateDefaultConfig, "CreateDefaultConfig"},
{0x00050002, &AC_I::GetConnectResult, "GetConnectResult"}, {IPC::MakeHeader(0x0004, 0, 6), &AC_I::ConnectAsync, "ConnectAsync"},
{0x00070002, nullptr, "CancelConnectAsync"}, {IPC::MakeHeader(0x0005, 0, 2), &AC_I::GetConnectResult, "GetConnectResult"},
{0x00080004, &AC_I::CloseAsync, "CloseAsync"}, {IPC::MakeHeader(0x0007, 0, 2), nullptr, "CancelConnectAsync"},
{0x00090002, &AC_I::GetCloseResult, "GetCloseResult"}, {IPC::MakeHeader(0x0008, 0, 4), &AC_I::CloseAsync, "CloseAsync"},
{0x000A0000, nullptr, "GetLastErrorCode"}, {IPC::MakeHeader(0x0009, 0, 2), &AC_I::GetCloseResult, "GetCloseResult"},
{0x000C0000, nullptr, "GetStatus"}, {IPC::MakeHeader(0x000A, 0, 0), nullptr, "GetLastErrorCode"},
{0x000D0000, &AC_I::GetWifiStatus, "GetWifiStatus"}, {IPC::MakeHeader(0x000C, 0, 0), nullptr, "GetStatus"},
{0x000E0042, nullptr, "GetCurrentAPInfo"}, {IPC::MakeHeader(0x000D, 0, 0), &AC_I::GetWifiStatus, "GetWifiStatus"},
{0x00100042, nullptr, "GetCurrentNZoneInfo"}, {IPC::MakeHeader(0x000E, 1, 2), nullptr, "GetCurrentAPInfo"},
{0x00110042, nullptr, "GetNZoneApNumService"}, {IPC::MakeHeader(0x0010, 1, 2), nullptr, "GetCurrentNZoneInfo"},
{0x001D0042, nullptr, "ScanAPs"}, {IPC::MakeHeader(0x0011, 1, 2), nullptr, "GetNZoneApNumService"},
{0x00240042, nullptr, "AddDenyApType"}, {IPC::MakeHeader(0x001D, 1, 2), nullptr, "ScanAPs"},
{0x00270002, &AC_I::GetInfraPriority, "GetInfraPriority"}, {IPC::MakeHeader(0x0024, 1, 2), nullptr, "AddDenyApType"},
{0x002D0082, &AC_I::SetRequestEulaVersion, "SetRequestEulaVersion"}, {IPC::MakeHeader(0x0027, 0, 2), &AC_I::GetInfraPriority, "GetInfraPriority"},
{0x00300004, &AC_I::RegisterDisconnectEvent, "RegisterDisconnectEvent"}, {IPC::MakeHeader(0x002D, 2, 2), &AC_I::SetRequestEulaVersion, "SetRequestEulaVersion"},
{0x003C0042, nullptr, "GetAPSSIDList"}, {IPC::MakeHeader(0x0030, 0, 4), &AC_I::RegisterDisconnectEvent, "RegisterDisconnectEvent"},
{0x003E0042, &AC_I::IsConnected, "IsConnected"}, {IPC::MakeHeader(0x003C, 1, 2), nullptr, "GetAPSSIDList"},
{0x00400042, &AC_I::SetClientVersion, "SetClientVersion"}, {IPC::MakeHeader(0x003E, 1, 2), &AC_I::IsConnected, "IsConnected"},
{IPC::MakeHeader(0x0040, 1, 2), &AC_I::SetClientVersion, "SetClientVersion"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

42
src/core/hle/service/ac/ac_u.cpp
View File

@@ -9,26 +9,28 @@ namespace Service::AC {
AC_U::AC_U(std::shared_ptr<Module> ac) : Module::Interface(std::move(ac), "ac:u", 10) { AC_U::AC_U(std::shared_ptr<Module> ac) : Module::Interface(std::move(ac), "ac:u", 10) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x00010000, &AC_U::CreateDefaultConfig, "CreateDefaultConfig"}, // clang-format off
{0x00040006, &AC_U::ConnectAsync, "ConnectAsync"}, {IPC::MakeHeader(0x0001, 0, 0), &AC_U::CreateDefaultConfig, "CreateDefaultConfig"},
{0x00050002, &AC_U::GetConnectResult, "GetConnectResult"}, {IPC::MakeHeader(0x0004, 0, 6), &AC_U::ConnectAsync, "ConnectAsync"},
{0x00070002, nullptr, "CancelConnectAsync"}, {IPC::MakeHeader(0x0005, 0, 2), &AC_U::GetConnectResult, "GetConnectResult"},
{0x00080004, &AC_U::CloseAsync, "CloseAsync"}, {IPC::MakeHeader(0x0007, 0, 2), nullptr, "CancelConnectAsync"},
{0x00090002, &AC_U::GetCloseResult, "GetCloseResult"}, {IPC::MakeHeader(0x0008, 0, 4), &AC_U::CloseAsync, "CloseAsync"},
{0x000A0000, nullptr, "GetLastErrorCode"}, {IPC::MakeHeader(0x0009, 0, 2), &AC_U::GetCloseResult, "GetCloseResult"},
{0x000C0000, nullptr, "GetStatus"}, {IPC::MakeHeader(0x000A, 0, 0), nullptr, "GetLastErrorCode"},
{0x000D0000, &AC_U::GetWifiStatus, "GetWifiStatus"}, {IPC::MakeHeader(0x000C, 0, 0), nullptr, "GetStatus"},
{0x000E0042, nullptr, "GetCurrentAPInfo"}, {IPC::MakeHeader(0x000D, 0, 0), &AC_U::GetWifiStatus, "GetWifiStatus"},
{0x00100042, nullptr, "GetCurrentNZoneInfo"}, {IPC::MakeHeader(0x000E, 1, 2), nullptr, "GetCurrentAPInfo"},
{0x00110042, nullptr, "GetNZoneApNumService"}, {IPC::MakeHeader(0x0010, 1, 2), nullptr, "GetCurrentNZoneInfo"},
{0x001D0042, nullptr, "ScanAPs"}, {IPC::MakeHeader(0x0011, 1, 2), nullptr, "GetNZoneApNumService"},
{0x00240042, nullptr, "AddDenyApType"}, {IPC::MakeHeader(0x001D, 1, 2), nullptr, "ScanAPs"},
{0x00270002, &AC_U::GetInfraPriority, "GetInfraPriority"}, {IPC::MakeHeader(0x0024, 1, 2), nullptr, "AddDenyApType"},
{0x002D0082, &AC_U::SetRequestEulaVersion, "SetRequestEulaVersion"}, {IPC::MakeHeader(0x0027, 0, 2), &AC_U::GetInfraPriority, "GetInfraPriority"},
{0x00300004, &AC_U::RegisterDisconnectEvent, "RegisterDisconnectEvent"}, {IPC::MakeHeader(0x002D, 2, 2), &AC_U::SetRequestEulaVersion, "SetRequestEulaVersion"},
{0x003C0042, nullptr, "GetAPSSIDList"}, {IPC::MakeHeader(0x0030, 0, 4), &AC_U::RegisterDisconnectEvent, "RegisterDisconnectEvent"},
{0x003E0042, &AC_U::IsConnected, "IsConnected"}, {IPC::MakeHeader(0x003C, 1, 2), nullptr, "GetAPSSIDList"},
{0x00400042, &AC_U::SetClientVersion, "SetClientVersion"}, {IPC::MakeHeader(0x003E, 1, 2), &AC_U::IsConnected, "IsConnected"},
{IPC::MakeHeader(0x0040, 1, 2), &AC_U::SetClientVersion, "SetClientVersion"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

20
src/core/hle/service/act/act_a.cpp
View File

@@ -10,16 +10,18 @@ namespace Service::ACT {
ACT_A::ACT_A(std::shared_ptr<Module> act) : Module::Interface(std::move(act), "act:a") { ACT_A::ACT_A(std::shared_ptr<Module> act) : Module::Interface(std::move(act), "act:a") {
const FunctionInfo functions[] = { const FunctionInfo functions[] = {
// act:u shared commands // act:u shared commands
{0x00010084, nullptr, "Initialize"}, // clang-format off
{0x00020040, nullptr, "GetErrorCode"}, {IPC::MakeHeader(0x0001, 2, 4), nullptr, "Initialize"},
{0x000600C2, nullptr, "GetAccountDataBlock"}, {IPC::MakeHeader(0x0002, 1, 0), nullptr, "GetErrorCode"},
{0x000B0042, nullptr, "AcquireEulaList"}, {IPC::MakeHeader(0x0006, 3, 2), nullptr, "GetAccountDataBlock"},
{0x000D0040, nullptr, "GenerateUuid"}, {IPC::MakeHeader(0x000B, 1, 2), nullptr, "AcquireEulaList"},
{IPC::MakeHeader(0x000D, 1, 0), nullptr, "GenerateUuid"},
// act:a // act:a
{0x041300C2, nullptr, "UpdateMiiImage"}, {IPC::MakeHeader(0x0413, 3, 2), nullptr, "UpdateMiiImage"},
{0x041B0142, nullptr, "AgreeEula"}, {IPC::MakeHeader(0x041B, 5, 2), nullptr, "AgreeEula"},
{0x04210042, nullptr, "UploadMii"}, {IPC::MakeHeader(0x0421, 1, 2), nullptr, "UploadMii"},
{0x04230082, nullptr, "ValidateMailAddress"}, {IPC::MakeHeader(0x0423, 2, 2), nullptr, "ValidateMailAddress"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

10
src/core/hle/service/act/act_u.cpp
View File

@@ -10,11 +10,11 @@ namespace Service::ACT {
ACT_U::ACT_U(std::shared_ptr<Module> act) : Module::Interface(std::move(act), "act:u") { ACT_U::ACT_U(std::shared_ptr<Module> act) : Module::Interface(std::move(act), "act:u") {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
// clang-format off // clang-format off
{0x00010084, nullptr, "Initialize"}, {IPC::MakeHeader(0x0001, 2, 4), nullptr, "Initialize"},
{0x00020040, nullptr, "GetErrorCode"}, {IPC::MakeHeader(0x0002, 1, 0), nullptr, "GetErrorCode"},
{0x000600C2, nullptr, "GetAccountDataBlock"}, {IPC::MakeHeader(0x0006, 3, 2), nullptr, "GetAccountDataBlock"},
{0x000B0042, nullptr, "AcquireEulaList"}, {IPC::MakeHeader(0x000B, 1, 2), nullptr, "AcquireEulaList"},
{0x000D0040, nullptr, "GenerateUuid"}, {IPC::MakeHeader(0x000D, 1, 0), nullptr, "GenerateUuid"},
// clang-format on // clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);

28
src/core/hle/service/am/am_app.cpp
View File

@@ -9,19 +9,21 @@ namespace Service::AM {
AM_APP::AM_APP(std::shared_ptr<Module> am) : Module::Interface(std::move(am), "am:app", 5) { AM_APP::AM_APP(std::shared_ptr<Module> am) : Module::Interface(std::move(am), "am:app", 5) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x100100C0, &AM_APP::GetDLCContentInfoCount, "GetDLCContentInfoCount"}, // clang-format off
{0x10020104, &AM_APP::FindDLCContentInfos, "FindDLCContentInfos"}, {IPC::MakeHeader(0x1001, 3, 0), &AM_APP::GetDLCContentInfoCount, "GetDLCContentInfoCount"},
{0x10030142, &AM_APP::ListDLCContentInfos, "ListDLCContentInfos"}, {IPC::MakeHeader(0x1002, 4, 4), &AM_APP::FindDLCContentInfos, "FindDLCContentInfos"},
{0x10040102, &AM_APP::DeleteContents, "DeleteContents"}, {IPC::MakeHeader(0x1003, 5, 2), &AM_APP::ListDLCContentInfos, "ListDLCContentInfos"},
{0x10050084, &AM_APP::GetDLCTitleInfos, "GetDLCTitleInfos"}, {IPC::MakeHeader(0x1004, 4, 2), &AM_APP::DeleteContents, "DeleteContents"},
{0x10060080, nullptr, "GetNumDataTitleTickets"}, {IPC::MakeHeader(0x1005, 2, 4), &AM_APP::GetDLCTitleInfos, "GetDLCTitleInfos"},
{0x10070102, &AM_APP::ListDataTitleTicketInfos, "ListDataTitleTicketInfos"}, {IPC::MakeHeader(0x1006, 2, 0), nullptr, "GetNumDataTitleTickets"},
{0x100801C2, nullptr, "GetItemRights"}, {IPC::MakeHeader(0x1007, 4, 2), &AM_APP::ListDataTitleTicketInfos, "ListDataTitleTicketInfos"},
{0x100900C0, nullptr, "IsDataTitleInUse"}, {IPC::MakeHeader(0x1008, 7, 2), nullptr, "GetItemRights"},
{0x100A0000, nullptr, "IsExternalTitleDatabaseInitialized"}, {IPC::MakeHeader(0x1009, 3, 0), nullptr, "IsDataTitleInUse"},
{0x100B00C0, nullptr, "GetNumExistingContentInfos"}, {IPC::MakeHeader(0x100A, 0, 0), nullptr, "IsExternalTitleDatabaseInitialized"},
{0x100C0142, nullptr, "ListExistingContentInfos"}, {IPC::MakeHeader(0x100B, 3, 0), nullptr, "GetNumExistingContentInfos"},
{0x100D0084, &AM_APP::GetPatchTitleInfos, "GetPatchTitleInfos"}, {IPC::MakeHeader(0x100C, 5, 2), nullptr, "ListExistingContentInfos"},
{IPC::MakeHeader(0x100D, 2, 4), &AM_APP::GetPatchTitleInfos, "GetPatchTitleInfos"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

222
src/core/hle/service/am/am_net.cpp
View File

@@ -9,116 +9,118 @@ namespace Service::AM {
AM_NET::AM_NET(std::shared_ptr<Module> am) : Module::Interface(std::move(am), "am:net", 5) { AM_NET::AM_NET(std::shared_ptr<Module> am) : Module::Interface(std::move(am), "am:net", 5) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x00010040, &AM_NET::GetNumPrograms, "GetNumPrograms"}, // clang-format off
{0x00020082, &AM_NET::GetProgramList, "GetProgramList"}, {IPC::MakeHeader(0x0001, 1, 0), &AM_NET::GetNumPrograms, "GetNumPrograms"},
{0x00030084, &AM_NET::GetProgramInfos, "GetProgramInfos"}, {IPC::MakeHeader(0x0002, 2, 2), &AM_NET::GetProgramList, "GetProgramList"},
{0x000400C0, &AM_NET::DeleteUserProgram, "DeleteUserProgram"}, {IPC::MakeHeader(0x0003, 2, 4), &AM_NET::GetProgramInfos, "GetProgramInfos"},
{0x000500C0, &AM_NET::GetProductCode, "GetProductCode"}, {IPC::MakeHeader(0x0004, 3, 0), &AM_NET::DeleteUserProgram, "DeleteUserProgram"},
{0x000600C0, nullptr, "GetStorageId"}, {IPC::MakeHeader(0x0005, 3, 0), &AM_NET::GetProductCode, "GetProductCode"},
{0x00070080, &AM_NET::DeleteTicket, "DeleteTicket"}, {IPC::MakeHeader(0x0006, 3, 0), nullptr, "GetStorageId"},
{0x00080000, &AM_NET::GetNumTickets, "GetNumTickets"}, {IPC::MakeHeader(0x0007, 2, 0), &AM_NET::DeleteTicket, "DeleteTicket"},
{0x00090082, &AM_NET::GetTicketList, "GetTicketList"}, {IPC::MakeHeader(0x0008, 0, 0), &AM_NET::GetNumTickets, "GetNumTickets"},
{0x000A0000, nullptr, "GetDeviceID"}, {IPC::MakeHeader(0x0009, 2, 2), &AM_NET::GetTicketList, "GetTicketList"},
{0x000B0040, nullptr, "GetNumImportTitleContexts"}, {IPC::MakeHeader(0x000A, 0, 0), nullptr, "GetDeviceID"},
{0x000C0082, nullptr, "GetImportTitleContextList"}, {IPC::MakeHeader(0x000B, 1, 0), nullptr, "GetNumImportTitleContexts"},
{0x000D0084, nullptr, "GetImportTitleContexts"}, {IPC::MakeHeader(0x000C, 2, 2), nullptr, "GetImportTitleContextList"},
{0x000E00C0, nullptr, "DeleteImportTitleContext"}, {IPC::MakeHeader(0x000D, 2, 4), nullptr, "GetImportTitleContexts"},
{0x000F00C0, nullptr, "GetNumImportContentContexts"}, {IPC::MakeHeader(0x000E, 3, 0), nullptr, "DeleteImportTitleContext"},
{0x00100102, nullptr, "GetImportContentContextList"}, {IPC::MakeHeader(0x000F, 3, 0), nullptr, "GetNumImportContentContexts"},
{0x00110104, nullptr, "GetImportContentContexts"}, {IPC::MakeHeader(0x0010, 4, 2), nullptr, "GetImportContentContextList"},
{0x00120102, nullptr, "DeleteImportContentContexts"}, {IPC::MakeHeader(0x0011, 4, 4), nullptr, "GetImportContentContexts"},
{0x00130040, nullptr, "NeedsCleanup"}, {IPC::MakeHeader(0x0012, 4, 2), nullptr, "DeleteImportContentContexts"},
{0x00140040, nullptr, "DoCleanup"}, {IPC::MakeHeader(0x0013, 1, 0), nullptr, "NeedsCleanup"},
{0x00150040, nullptr, "DeleteAllImportContexts"}, {IPC::MakeHeader(0x0014, 1, 0), nullptr, "DoCleanup"},
{0x00160000, nullptr, "DeleteAllTemporaryPrograms"}, {IPC::MakeHeader(0x0015, 1, 0), nullptr, "DeleteAllImportContexts"},
{0x00170044, nullptr, "ImportTwlBackupLegacy"}, {IPC::MakeHeader(0x0016, 0, 0), nullptr, "DeleteAllTemporaryPrograms"},
{0x00180080, nullptr, "InitializeTitleDatabase"}, {IPC::MakeHeader(0x0017, 1, 4), nullptr, "ImportTwlBackupLegacy"},
{0x00190040, nullptr, "QueryAvailableTitleDatabase"}, {IPC::MakeHeader(0x0018, 2, 0), nullptr, "InitializeTitleDatabase"},
{0x001A00C0, nullptr, "CalcTwlBackupSize"}, {IPC::MakeHeader(0x0019, 1, 0), nullptr, "QueryAvailableTitleDatabase"},
{0x001B0144, nullptr, "ExportTwlBackup"}, {IPC::MakeHeader(0x001A, 3, 0), nullptr, "CalcTwlBackupSize"},
{0x001C0084, nullptr, "ImportTwlBackup"}, {IPC::MakeHeader(0x001B, 5, 4), nullptr, "ExportTwlBackup"},
{0x001D0000, nullptr, "DeleteAllTwlUserPrograms"}, {IPC::MakeHeader(0x001C, 2, 4), nullptr, "ImportTwlBackup"},
{0x001E00C8, nullptr, "ReadTwlBackupInfo"}, {IPC::MakeHeader(0x001D, 0, 0), nullptr, "DeleteAllTwlUserPrograms"},
{0x001F0040, nullptr, "DeleteAllExpiredUserPrograms"}, {IPC::MakeHeader(0x001E, 3, 8), nullptr, "ReadTwlBackupInfo"},
{0x00200000, nullptr, "GetTwlArchiveResourceInfo"}, {IPC::MakeHeader(0x001F, 1, 0), nullptr, "DeleteAllExpiredUserPrograms"},
{0x00210042, nullptr, "GetPersonalizedTicketInfoList"}, {IPC::MakeHeader(0x0020, 0, 0), nullptr, "GetTwlArchiveResourceInfo"},
{0x00220080, nullptr, "DeleteAllImportContextsFiltered"}, {IPC::MakeHeader(0x0021, 1, 2), nullptr, "GetPersonalizedTicketInfoList"},
{0x00230080, nullptr, "GetNumImportTitleContextsFiltered"}, {IPC::MakeHeader(0x0022, 2, 0), nullptr, "DeleteAllImportContextsFiltered"},
{0x002400C2, nullptr, "GetImportTitleContextListFiltered"}, {IPC::MakeHeader(0x0023, 2, 0), nullptr, "GetNumImportTitleContextsFiltered"},
{0x002500C0, nullptr, "CheckContentRights"}, {IPC::MakeHeader(0x0024, 3, 2), nullptr, "GetImportTitleContextListFiltered"},
{0x00260044, nullptr, "GetTicketLimitInfos"}, {IPC::MakeHeader(0x0025, 3, 0), nullptr, "CheckContentRights"},
{0x00270044, nullptr, "GetDemoLaunchInfos"}, {IPC::MakeHeader(0x0026, 1, 4), nullptr, "GetTicketLimitInfos"},
{0x00280108, nullptr, "ReadTwlBackupInfoEx"}, {IPC::MakeHeader(0x0027, 1, 4), nullptr, "GetDemoLaunchInfos"},
{0x00290082, nullptr, "DeleteUserProgramsAtomically"}, {IPC::MakeHeader(0x0028, 4, 8), nullptr, "ReadTwlBackupInfoEx"},
{0x002A00C0, nullptr, "GetNumExistingContentInfosSystem"}, {IPC::MakeHeader(0x0029, 2, 2), nullptr, "DeleteUserProgramsAtomically"},
{0x002B0142, nullptr, "ListExistingContentInfosSystem"}, {IPC::MakeHeader(0x002A, 3, 0), nullptr, "GetNumExistingContentInfosSystem"},
{0x002C0084, nullptr, "GetProgramInfosIgnorePlatform"}, {IPC::MakeHeader(0x002B, 5, 2), nullptr, "ListExistingContentInfosSystem"},
{0x002D00C0, nullptr, "CheckContentRightsIgnorePlatform"}, {IPC::MakeHeader(0x002C, 2, 4), nullptr, "GetProgramInfosIgnorePlatform"},
{0x04010080, nullptr, "UpdateFirmwareTo"}, {IPC::MakeHeader(0x002D, 3, 0), nullptr, "CheckContentRightsIgnorePlatform"},
{0x04020040, &AM_NET::BeginImportProgram, "BeginImportProgram"}, {IPC::MakeHeader(0x0401, 2, 0), nullptr, "UpdateFirmwareTo"},
{0x04030000, nullptr, "BeginImportProgramTemporarily"}, {IPC::MakeHeader(0x0402, 1, 0), &AM_NET::BeginImportProgram, "BeginImportProgram"},
{0x04040002, nullptr, "CancelImportProgram"}, {IPC::MakeHeader(0x0403, 0, 0), nullptr, "BeginImportProgramTemporarily"},
{0x04050002, &AM_NET::EndImportProgram, "EndImportProgram"}, {IPC::MakeHeader(0x0404, 0, 2), nullptr, "CancelImportProgram"},
{0x04060002, nullptr, "EndImportProgramWithoutCommit"}, {IPC::MakeHeader(0x0405, 0, 2), &AM_NET::EndImportProgram, "EndImportProgram"},
{0x040700C2, nullptr, "CommitImportPrograms"}, {IPC::MakeHeader(0x0406, 0, 2), nullptr, "EndImportProgramWithoutCommit"},
{0x04080042, &AM_NET::GetProgramInfoFromCia, "GetProgramInfoFromCia"}, {IPC::MakeHeader(0x0407, 3, 2), nullptr, "CommitImportPrograms"},
{0x04090004, &AM_NET::GetSystemMenuDataFromCia, "GetSystemMenuDataFromCia"}, {IPC::MakeHeader(0x0408, 1, 2), &AM_NET::GetProgramInfoFromCia, "GetProgramInfoFromCia"},
{0x040A0002, &AM_NET::GetDependencyListFromCia, "GetDependencyListFromCia"}, {IPC::MakeHeader(0x0409, 0, 4), &AM_NET::GetSystemMenuDataFromCia, "GetSystemMenuDataFromCia"},
{0x040B0002, &AM_NET::GetTransferSizeFromCia, "GetTransferSizeFromCia"}, {IPC::MakeHeader(0x040A, 0, 2), &AM_NET::GetDependencyListFromCia, "GetDependencyListFromCia"},
{0x040C0002, &AM_NET::GetCoreVersionFromCia, "GetCoreVersionFromCia"}, {IPC::MakeHeader(0x040B, 0, 2), &AM_NET::GetTransferSizeFromCia, "GetTransferSizeFromCia"},
{0x040D0042, &AM_NET::GetRequiredSizeFromCia, "GetRequiredSizeFromCia"}, {IPC::MakeHeader(0x040C, 0, 2), &AM_NET::GetCoreVersionFromCia, "GetCoreVersionFromCia"},
{0x040E00C2, nullptr, "CommitImportProgramsAndUpdateFirmwareAuto"}, {IPC::MakeHeader(0x040D, 1, 2), &AM_NET::GetRequiredSizeFromCia, "GetRequiredSizeFromCia"},
{0x040F0000, nullptr, "UpdateFirmwareAuto"}, {IPC::MakeHeader(0x040E, 3, 2), nullptr, "CommitImportProgramsAndUpdateFirmwareAuto"},
{0x041000C0, &AM_NET::DeleteProgram, "DeleteProgram"}, {IPC::MakeHeader(0x040F, 0, 0), nullptr, "UpdateFirmwareAuto"},
{0x04110044, nullptr, "GetTwlProgramListForReboot"}, {IPC::MakeHeader(0x0410, 3, 0), &AM_NET::DeleteProgram, "DeleteProgram"},
{0x04120000, nullptr, "GetSystemUpdaterMutex"}, {IPC::MakeHeader(0x0411, 1, 4), nullptr, "GetTwlProgramListForReboot"},
{0x04130002, &AM_NET::GetMetaSizeFromCia, "GetMetaSizeFromCia"}, {IPC::MakeHeader(0x0412, 0, 0), nullptr, "GetSystemUpdaterMutex"},
{0x04140044, &AM_NET::GetMetaDataFromCia, "GetMetaDataFromCia"}, {IPC::MakeHeader(0x0413, 0, 2), &AM_NET::GetMetaSizeFromCia, "GetMetaSizeFromCia"},
{0x04150080, nullptr, "CheckDemoLaunchRights"}, {IPC::MakeHeader(0x0414, 1, 4), &AM_NET::GetMetaDataFromCia, "GetMetaDataFromCia"},
{0x041600C0, nullptr, "GetInternalTitleLocationInfo"}, {IPC::MakeHeader(0x0415, 2, 0), nullptr, "CheckDemoLaunchRights"},
{0x041700C0, nullptr, "PerpetuateAgbSaveData"}, {IPC::MakeHeader(0x0416, 3, 0), nullptr, "GetInternalTitleLocationInfo"},
{0x04180040, nullptr, "BeginImportProgramForOverWrite"}, {IPC::MakeHeader(0x0417, 3, 0), nullptr, "PerpetuateAgbSaveData"},
{0x04190000, nullptr, "BeginImportSystemProgram"}, {IPC::MakeHeader(0x0418, 1, 0), nullptr, "BeginImportProgramForOverWrite"},
{0x08010000, nullptr, "BeginImportTicket"}, {IPC::MakeHeader(0x0419, 0, 0), nullptr, "BeginImportSystemProgram"},
{0x08020002, nullptr, "CancelImportTicket"}, {IPC::MakeHeader(0x0801, 0, 0), nullptr, "BeginImportTicket"},
{0x08030002, nullptr, "EndImportTicket"}, {IPC::MakeHeader(0x0802, 0, 2), nullptr, "CancelImportTicket"},
{0x08040100, nullptr, "BeginImportTitle"}, {IPC::MakeHeader(0x0803, 0, 2), nullptr, "EndImportTicket"},
{0x08050000, nullptr, "StopImportTitle"}, {IPC::MakeHeader(0x0804, 4, 0), nullptr, "BeginImportTitle"},
{0x080600C0, nullptr, "ResumeImportTitle"}, {IPC::MakeHeader(0x0805, 0, 0), nullptr, "StopImportTitle"},
{0x08070000, nullptr, "CancelImportTitle"}, {IPC::MakeHeader(0x0806, 3, 0), nullptr, "ResumeImportTitle"},
{0x08080000, nullptr, "EndImportTitle"}, {IPC::MakeHeader(0x0807, 0, 0), nullptr, "CancelImportTitle"},
{0x080900C2, nullptr, "CommitImportTitles"}, {IPC::MakeHeader(0x0808, 0, 0), nullptr, "EndImportTitle"},
{0x080A0000, nullptr, "BeginImportTmd"}, {IPC::MakeHeader(0x0809, 3, 2), nullptr, "CommitImportTitles"},
{0x080B0002, nullptr, "CancelImportTmd"}, {IPC::MakeHeader(0x080A, 0, 0), nullptr, "BeginImportTmd"},
{0x080C0042, nullptr, "EndImportTmd"}, {IPC::MakeHeader(0x080B, 0, 2), nullptr, "CancelImportTmd"},
{0x080D0042, nullptr, "CreateImportContentContexts"}, {IPC::MakeHeader(0x080C, 1, 2), nullptr, "EndImportTmd"},
{0x080E0040, nullptr, "BeginImportContent"}, {IPC::MakeHeader(0x080D, 1, 2), nullptr, "CreateImportContentContexts"},
{0x080F0002, nullptr, "StopImportContent"}, {IPC::MakeHeader(0x080E, 1, 0), nullptr, "BeginImportContent"},
{0x08100040, nullptr, "ResumeImportContent"}, {IPC::MakeHeader(0x080F, 0, 2), nullptr, "StopImportContent"},
{0x08110002, nullptr, "CancelImportContent"}, {IPC::MakeHeader(0x0810, 1, 0), nullptr, "ResumeImportContent"},
{0x08120002, nullptr, "EndImportContent"}, {IPC::MakeHeader(0x0811, 0, 2), nullptr, "CancelImportContent"},
{0x08130000, nullptr, "GetNumCurrentImportContentContexts"}, {IPC::MakeHeader(0x0812, 0, 2), nullptr, "EndImportContent"},
{0x08140042, nullptr, "GetCurrentImportContentContextList"}, {IPC::MakeHeader(0x0813, 0, 0), nullptr, "GetNumCurrentImportContentContexts"},
{0x08150044, nullptr, "GetCurrentImportContentContexts"}, {IPC::MakeHeader(0x0814, 1, 2), nullptr, "GetCurrentImportContentContextList"},
{0x08160146, nullptr, "Sign"}, {IPC::MakeHeader(0x0815, 1, 4), nullptr, "GetCurrentImportContentContexts"},
{0x08170146, nullptr, "Verify"}, {IPC::MakeHeader(0x0816, 5, 6), nullptr, "Sign"},
{0x08180042, nullptr, "GetDeviceCert"}, {IPC::MakeHeader(0x0817, 5, 6), nullptr, "Verify"},
{0x08190108, nullptr, "ImportCertificates"}, {IPC::MakeHeader(0x0818, 1, 2), nullptr, "GetDeviceCert"},
{0x081A0042, nullptr, "ImportCertificate"}, {IPC::MakeHeader(0x0819, 4, 8), nullptr, "ImportCertificates"},
{0x081B00C2, nullptr, "CommitImportTitlesAndUpdateFirmwareAuto"}, {IPC::MakeHeader(0x081A, 1, 2), nullptr, "ImportCertificate"},
{0x081C0100, nullptr, "DeleteTicketId"}, {IPC::MakeHeader(0x081B, 3, 2), nullptr, "CommitImportTitlesAndUpdateFirmwareAuto"},
{0x081D0080, nullptr, "GetNumTicketIds"}, {IPC::MakeHeader(0x081C, 4, 0), nullptr, "DeleteTicketId"},
{0x081E0102, nullptr, "GetTicketIdList"}, {IPC::MakeHeader(0x081D, 2, 0), nullptr, "GetNumTicketIds"},
{0x081F0080, nullptr, "GetNumTicketsOfProgram"}, {IPC::MakeHeader(0x081E, 4, 2), nullptr, "GetTicketIdList"},
{0x08200102, nullptr, "ListTicketInfos"}, {IPC::MakeHeader(0x081F, 2, 0), nullptr, "GetNumTicketsOfProgram"},
{0x08210142, nullptr, "GetRightsOnlyTicketData"}, {IPC::MakeHeader(0x0820, 4, 2), nullptr, "ListTicketInfos"},
{0x08220000, nullptr, "GetNumCurrentContentInfos"}, {IPC::MakeHeader(0x0821, 5, 2), nullptr, "GetRightsOnlyTicketData"},
{0x08230044, nullptr, "FindCurrentContentInfos"}, {IPC::MakeHeader(0x0822, 0, 0), nullptr, "GetNumCurrentContentInfos"},
{0x08240082, nullptr, "ListCurrentContentInfos"}, {IPC::MakeHeader(0x0823, 1, 4), nullptr, "FindCurrentContentInfos"},
{0x08250102, nullptr, "CalculateContextRequiredSize"}, {IPC::MakeHeader(0x0824, 2, 2), nullptr, "ListCurrentContentInfos"},
{0x08260042, nullptr, "UpdateImportContentContexts"}, {IPC::MakeHeader(0x0825, 4, 2), nullptr, "CalculateContextRequiredSize"},
{0x08270000, nullptr, "DeleteAllDemoLaunchInfos"}, {IPC::MakeHeader(0x0826, 1, 2), nullptr, "UpdateImportContentContexts"},
{0x082800C0, nullptr, "BeginImportTitleForOverWrite"}, {IPC::MakeHeader(0x0827, 0, 0), nullptr, "DeleteAllDemoLaunchInfos"},
{IPC::MakeHeader(0x0828, 3, 0), nullptr, "BeginImportTitleForOverWrite"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

118
src/core/hle/service/am/am_sys.cpp
View File

@@ -9,64 +9,66 @@ namespace Service::AM {
AM_SYS::AM_SYS(std::shared_ptr<Module> am) : Module::Interface(std::move(am), "am:sys", 5) { AM_SYS::AM_SYS(std::shared_ptr<Module> am) : Module::Interface(std::move(am), "am:sys", 5) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x00010040, &AM_SYS::GetNumPrograms, "GetNumPrograms"}, // clang-format off
{0x00020082, &AM_SYS::GetProgramList, "GetProgramList"}, {IPC::MakeHeader(0x0001, 1, 0), &AM_SYS::GetNumPrograms, "GetNumPrograms"},
{0x00030084, &AM_SYS::GetProgramInfos, "GetProgramInfos"}, {IPC::MakeHeader(0x0002, 2, 2), &AM_SYS::GetProgramList, "GetProgramList"},
{0x000400C0, &AM_SYS::DeleteUserProgram, "DeleteUserProgram"}, {IPC::MakeHeader(0x0003, 2, 4), &AM_SYS::GetProgramInfos, "GetProgramInfos"},
{0x000500C0, &AM_SYS::GetProductCode, "GetProductCode"}, {IPC::MakeHeader(0x0004, 3, 0), &AM_SYS::DeleteUserProgram, "DeleteUserProgram"},
{0x000600C0, nullptr, "GetStorageId"}, {IPC::MakeHeader(0x0005, 3, 0), &AM_SYS::GetProductCode, "GetProductCode"},
{0x00070080, &AM_SYS::DeleteTicket, "DeleteTicket"}, {IPC::MakeHeader(0x0006, 3, 0), nullptr, "GetStorageId"},
{0x00080000, &AM_SYS::GetNumTickets, "GetNumTickets"}, {IPC::MakeHeader(0x0007, 2, 0), &AM_SYS::DeleteTicket, "DeleteTicket"},
{0x00090082, &AM_SYS::GetTicketList, "GetTicketList"}, {IPC::MakeHeader(0x0008, 0, 0), &AM_SYS::GetNumTickets, "GetNumTickets"},
{0x000A0000, nullptr, "GetDeviceID"}, {IPC::MakeHeader(0x0009, 2, 2), &AM_SYS::GetTicketList, "GetTicketList"},
{0x000B0040, nullptr, "GetNumImportTitleContexts"}, {IPC::MakeHeader(0x000A, 0, 0), nullptr, "GetDeviceID"},
{0x000C0082, nullptr, "GetImportTitleContextList"}, {IPC::MakeHeader(0x000B, 1, 0), nullptr, "GetNumImportTitleContexts"},
{0x000D0084, nullptr, "GetImportTitleContexts"}, {IPC::MakeHeader(0x000C, 2, 2), nullptr, "GetImportTitleContextList"},
{0x000E00C0, nullptr, "DeleteImportTitleContext"}, {IPC::MakeHeader(0x000D, 2, 4), nullptr, "GetImportTitleContexts"},
{0x000F00C0, nullptr, "GetNumImportContentContexts"}, {IPC::MakeHeader(0x000E, 3, 0), nullptr, "DeleteImportTitleContext"},
{0x00100102, nullptr, "GetImportContentContextList"}, {IPC::MakeHeader(0x000F, 3, 0), nullptr, "GetNumImportContentContexts"},
{0x00110104, nullptr, "GetImportContentContexts"}, {IPC::MakeHeader(0x0010, 4, 2), nullptr, "GetImportContentContextList"},
{0x00120102, nullptr, "DeleteImportContentContexts"}, {IPC::MakeHeader(0x0011, 4, 4), nullptr, "GetImportContentContexts"},
{0x00130040, nullptr, "NeedsCleanup"}, {IPC::MakeHeader(0x0012, 4, 2), nullptr, "DeleteImportContentContexts"},
{0x00140040, nullptr, "DoCleanup"}, {IPC::MakeHeader(0x0013, 1, 0), nullptr, "NeedsCleanup"},
{0x00150040, nullptr, "DeleteAllImportContexts"}, {IPC::MakeHeader(0x0014, 1, 0), nullptr, "DoCleanup"},
{0x00160000, nullptr, "DeleteAllTemporaryPrograms"}, {IPC::MakeHeader(0x0015, 1, 0), nullptr, "DeleteAllImportContexts"},
{0x00170044, nullptr, "ImportTwlBackupLegacy"}, {IPC::MakeHeader(0x0016, 0, 0), nullptr, "DeleteAllTemporaryPrograms"},
{0x00180080, nullptr, "InitializeTitleDatabase"}, {IPC::MakeHeader(0x0017, 1, 4), nullptr, "ImportTwlBackupLegacy"},
{0x00190040, &AM_SYS::QueryAvailableTitleDatabase, "QueryAvailableTitleDatabase"}, {IPC::MakeHeader(0x0018, 2, 0), nullptr, "InitializeTitleDatabase"},
{0x001A00C0, nullptr, "CalcTwlBackupSize"}, {IPC::MakeHeader(0x0019, 1, 0), &AM_SYS::QueryAvailableTitleDatabase, "QueryAvailableTitleDatabase"},
{0x001B0144, nullptr, "ExportTwlBackup"}, {IPC::MakeHeader(0x001A, 3, 0), nullptr, "CalcTwlBackupSize"},
{0x001C0084, nullptr, "ImportTwlBackup"}, {IPC::MakeHeader(0x001B, 5, 4), nullptr, "ExportTwlBackup"},
{0x001D0000, nullptr, "DeleteAllTwlUserPrograms"}, {IPC::MakeHeader(0x001C, 2, 4), nullptr, "ImportTwlBackup"},
{0x001E00C8, nullptr, "ReadTwlBackupInfo"}, {IPC::MakeHeader(0x001D, 0, 0), nullptr, "DeleteAllTwlUserPrograms"},
{0x001F0040, nullptr, "DeleteAllExpiredUserPrograms"}, {IPC::MakeHeader(0x001E, 3, 8), nullptr, "ReadTwlBackupInfo"},
{0x00200000, nullptr, "GetTwlArchiveResourceInfo"}, {IPC::MakeHeader(0x001F, 1, 0), nullptr, "DeleteAllExpiredUserPrograms"},
{0x00210042, nullptr, "GetPersonalizedTicketInfoList"}, {IPC::MakeHeader(0x0020, 0, 0), nullptr, "GetTwlArchiveResourceInfo"},
{0x00220080, nullptr, "DeleteAllImportContextsFiltered"}, {IPC::MakeHeader(0x0021, 1, 2), nullptr, "GetPersonalizedTicketInfoList"},
{0x00230080, nullptr, "GetNumImportTitleContextsFiltered"}, {IPC::MakeHeader(0x0022, 2, 0), nullptr, "DeleteAllImportContextsFiltered"},
{0x002400C2, nullptr, "GetImportTitleContextListFiltered"}, {IPC::MakeHeader(0x0023, 2, 0), nullptr, "GetNumImportTitleContextsFiltered"},
{0x002500C0, &AM_SYS::CheckContentRights, "CheckContentRights"}, {IPC::MakeHeader(0x0024, 3, 2), nullptr, "GetImportTitleContextListFiltered"},
{0x00260044, nullptr, "GetTicketLimitInfos"}, {IPC::MakeHeader(0x0025, 3, 0), &AM_SYS::CheckContentRights, "CheckContentRights"},
{0x00270044, nullptr, "GetDemoLaunchInfos"}, {IPC::MakeHeader(0x0026, 1, 4), nullptr, "GetTicketLimitInfos"},
{0x00280108, nullptr, "ReadTwlBackupInfoEx"}, {IPC::MakeHeader(0x0027, 1, 4), nullptr, "GetDemoLaunchInfos"},
{0x00290082, nullptr, "DeleteUserProgramsAtomically"}, {IPC::MakeHeader(0x0028, 4, 8), nullptr, "ReadTwlBackupInfoEx"},
{0x002A00C0, nullptr, "GetNumExistingContentInfosSystem"}, {IPC::MakeHeader(0x0029, 2, 2), nullptr, "DeleteUserProgramsAtomically"},
{0x002B0142, nullptr, "ListExistingContentInfosSystem"}, {IPC::MakeHeader(0x002A, 3, 0), nullptr, "GetNumExistingContentInfosSystem"},
{0x002C0084, nullptr, "GetProgramInfosIgnorePlatform"}, {IPC::MakeHeader(0x002B, 5, 2), nullptr, "ListExistingContentInfosSystem"},
{0x002D00C0, &AM_SYS::CheckContentRightsIgnorePlatform, "CheckContentRightsIgnorePlatform"}, {IPC::MakeHeader(0x002C, 2, 4), nullptr, "GetProgramInfosIgnorePlatform"},
{0x100100C0, &AM_SYS::GetDLCContentInfoCount, "GetDLCContentInfoCount"}, {IPC::MakeHeader(0x002D, 3, 0), &AM_SYS::CheckContentRightsIgnorePlatform, "CheckContentRightsIgnorePlatform"},
{0x10020104, &AM_SYS::FindDLCContentInfos, "FindDLCContentInfos"}, {IPC::MakeHeader(0x1001, 3, 0), &AM_SYS::GetDLCContentInfoCount, "GetDLCContentInfoCount"},
{0x10030142, &AM_SYS::ListDLCContentInfos, "ListDLCContentInfos"}, {IPC::MakeHeader(0x1002, 4, 4), &AM_SYS::FindDLCContentInfos, "FindDLCContentInfos"},
{0x10040102, &AM_SYS::DeleteContents, "DeleteContents"}, {IPC::MakeHeader(0x1003, 5, 2), &AM_SYS::ListDLCContentInfos, "ListDLCContentInfos"},
{0x10050084, &AM_SYS::GetDLCTitleInfos, "GetDLCTitleInfos"}, {IPC::MakeHeader(0x1004, 4, 2), &AM_SYS::DeleteContents, "DeleteContents"},
{0x10060080, nullptr, "GetNumDataTitleTickets"}, {IPC::MakeHeader(0x1005, 2, 4), &AM_SYS::GetDLCTitleInfos, "GetDLCTitleInfos"},
{0x10070102, &AM_SYS::ListDataTitleTicketInfos, "ListDataTitleTicketInfos"}, {IPC::MakeHeader(0x1006, 2, 0), nullptr, "GetNumDataTitleTickets"},
{0x100801C2, nullptr, "GetItemRights"}, {IPC::MakeHeader(0x1007, 4, 2), &AM_SYS::ListDataTitleTicketInfos, "ListDataTitleTicketInfos"},
{0x100900C0, nullptr, "IsDataTitleInUse"}, {IPC::MakeHeader(0x1008, 7, 2), nullptr, "GetItemRights"},
{0x100A0000, nullptr, "IsExternalTitleDatabaseInitialized"}, {IPC::MakeHeader(0x1009, 3, 0), nullptr, "IsDataTitleInUse"},
{0x100B00C0, nullptr, "GetNumExistingContentInfos"}, {IPC::MakeHeader(0x100A, 0, 0), nullptr, "IsExternalTitleDatabaseInitialized"},
{0x100C0142, nullptr, "ListExistingContentInfos"}, {IPC::MakeHeader(0x100B, 3, 0), nullptr, "GetNumExistingContentInfos"},
{0x100D0084, &AM_SYS::GetPatchTitleInfos, "GetPatchTitleInfos"}, {IPC::MakeHeader(0x100C, 5, 2), nullptr, "ListExistingContentInfos"},
{IPC::MakeHeader(0x100D, 2, 4), &AM_SYS::GetPatchTitleInfos, "GetPatchTitleInfos"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

142
src/core/hle/service/am/am_u.cpp
View File

@@ -9,76 +9,78 @@ namespace Service::AM {
AM_U::AM_U(std::shared_ptr<Module> am) : Module::Interface(std::move(am), "am:u", 5) { AM_U::AM_U(std::shared_ptr<Module> am) : Module::Interface(std::move(am), "am:u", 5) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x00010040, &AM_U::GetNumPrograms, "GetNumPrograms"}, // clang-format off
{0x00020082, &AM_U::GetProgramList, "GetProgramList"}, {IPC::MakeHeader(0x0001, 1, 0), &AM_U::GetNumPrograms, "GetNumPrograms"},
{0x00030084, &AM_U::GetProgramInfos, "GetProgramInfos"}, {IPC::MakeHeader(0x0002, 2, 2), &AM_U::GetProgramList, "GetProgramList"},
{0x000400C0, &AM_U::DeleteUserProgram, "DeleteUserProgram"}, {IPC::MakeHeader(0x0003, 2, 4), &AM_U::GetProgramInfos, "GetProgramInfos"},
{0x000500C0, &AM_U::GetProductCode, "GetProductCode"}, {IPC::MakeHeader(0x0004, 3, 0), &AM_U::DeleteUserProgram, "DeleteUserProgram"},
{0x000600C0, nullptr, "GetStorageId"}, {IPC::MakeHeader(0x0005, 3, 0), &AM_U::GetProductCode, "GetProductCode"},
{0x00070080, &AM_U::DeleteTicket, "DeleteTicket"}, {IPC::MakeHeader(0x0006, 3, 0), nullptr, "GetStorageId"},
{0x00080000, &AM_U::GetNumTickets, "GetNumTickets"}, {IPC::MakeHeader(0x0007, 2, 0), &AM_U::DeleteTicket, "DeleteTicket"},
{0x00090082, &AM_U::GetTicketList, "GetTicketList"}, {IPC::MakeHeader(0x0008, 0, 0), &AM_U::GetNumTickets, "GetNumTickets"},
{0x000A0000, nullptr, "GetDeviceID"}, {IPC::MakeHeader(0x0009, 2, 2), &AM_U::GetTicketList, "GetTicketList"},
{0x000B0040, nullptr, "GetNumImportTitleContexts"}, {IPC::MakeHeader(0x000A, 0, 0), nullptr, "GetDeviceID"},
{0x000C0082, nullptr, "GetImportTitleContextList"}, {IPC::MakeHeader(0x000B, 1, 0), nullptr, "GetNumImportTitleContexts"},
{0x000D0084, nullptr, "GetImportTitleContexts"}, {IPC::MakeHeader(0x000C, 2, 2), nullptr, "GetImportTitleContextList"},
{0x000E00C0, nullptr, "DeleteImportTitleContext"}, {IPC::MakeHeader(0x000D, 2, 4), nullptr, "GetImportTitleContexts"},
{0x000F00C0, nullptr, "GetNumImportContentContexts"}, {IPC::MakeHeader(0x000E, 3, 0), nullptr, "DeleteImportTitleContext"},
{0x00100102, nullptr, "GetImportContentContextList"}, {IPC::MakeHeader(0x000F, 3, 0), nullptr, "GetNumImportContentContexts"},
{0x00110104, nullptr, "GetImportContentContexts"}, {IPC::MakeHeader(0x0010, 4, 2), nullptr, "GetImportContentContextList"},
{0x00120102, nullptr, "DeleteImportContentContexts"}, {IPC::MakeHeader(0x0011, 4, 4), nullptr, "GetImportContentContexts"},
{0x00130040, nullptr, "NeedsCleanup"}, {IPC::MakeHeader(0x0012, 4, 2), nullptr, "DeleteImportContentContexts"},
{0x00140040, nullptr, "DoCleanup"}, {IPC::MakeHeader(0x0013, 1, 0), nullptr, "NeedsCleanup"},
{0x00150040, nullptr, "DeleteAllImportContexts"}, {IPC::MakeHeader(0x0014, 1, 0), nullptr, "DoCleanup"},
{0x00160000, nullptr, "DeleteAllTemporaryPrograms"}, {IPC::MakeHeader(0x0015, 1, 0), nullptr, "DeleteAllImportContexts"},
{0x00170044, nullptr, "ImportTwlBackupLegacy"}, {IPC::MakeHeader(0x0016, 0, 0), nullptr, "DeleteAllTemporaryPrograms"},
{0x00180080, nullptr, "InitializeTitleDatabase"}, {IPC::MakeHeader(0x0017, 1, 4), nullptr, "ImportTwlBackupLegacy"},
{0x00190040, nullptr, "QueryAvailableTitleDatabase"}, {IPC::MakeHeader(0x0018, 2, 0), nullptr, "InitializeTitleDatabase"},
{0x001A00C0, nullptr, "CalcTwlBackupSize"}, {IPC::MakeHeader(0x0019, 1, 0), nullptr, "QueryAvailableTitleDatabase"},
{0x001B0144, nullptr, "ExportTwlBackup"}, {IPC::MakeHeader(0x001A, 3, 0), nullptr, "CalcTwlBackupSize"},
{0x001C0084, nullptr, "ImportTwlBackup"}, {IPC::MakeHeader(0x001B, 5, 4), nullptr, "ExportTwlBackup"},
{0x001D0000, nullptr, "DeleteAllTwlUserPrograms"}, {IPC::MakeHeader(0x001C, 2, 4), nullptr, "ImportTwlBackup"},
{0x001E00C8, nullptr, "ReadTwlBackupInfo"}, {IPC::MakeHeader(0x001D, 0, 0), nullptr, "DeleteAllTwlUserPrograms"},
{0x001F0040, nullptr, "DeleteAllExpiredUserPrograms"}, {IPC::MakeHeader(0x001E, 3, 8), nullptr, "ReadTwlBackupInfo"},
{0x00200000, nullptr, "GetTwlArchiveResourceInfo"}, {IPC::MakeHeader(0x001F, 1, 0), nullptr, "DeleteAllExpiredUserPrograms"},
{0x00210042, nullptr, "GetPersonalizedTicketInfoList"}, {IPC::MakeHeader(0x0020, 0, 0), nullptr, "GetTwlArchiveResourceInfo"},
{0x00220080, nullptr, "DeleteAllImportContextsFiltered"}, {IPC::MakeHeader(0x0021, 1, 2), nullptr, "GetPersonalizedTicketInfoList"},
{0x00230080, nullptr, "GetNumImportTitleContextsFiltered"}, {IPC::MakeHeader(0x0022, 2, 0), nullptr, "DeleteAllImportContextsFiltered"},
{0x002400C2, nullptr, "GetImportTitleContextListFiltered"}, {IPC::MakeHeader(0x0023, 2, 0), nullptr, "GetNumImportTitleContextsFiltered"},
{0x002500C0, nullptr, "CheckContentRights"}, {IPC::MakeHeader(0x0024, 3, 2), nullptr, "GetImportTitleContextListFiltered"},
{0x00260044, nullptr, "GetTicketLimitInfos"}, {IPC::MakeHeader(0x0025, 3, 0), nullptr, "CheckContentRights"},
{0x00270044, nullptr, "GetDemoLaunchInfos"}, {IPC::MakeHeader(0x0026, 1, 4), nullptr, "GetTicketLimitInfos"},
{0x00280108, nullptr, "ReadTwlBackupInfoEx"}, {IPC::MakeHeader(0x0027, 1, 4), nullptr, "GetDemoLaunchInfos"},
{0x00290082, nullptr, "DeleteUserProgramsAtomically"}, {IPC::MakeHeader(0x0028, 4, 8), nullptr, "ReadTwlBackupInfoEx"},
{0x002A00C0, nullptr, "GetNumExistingContentInfosSystem"}, {IPC::MakeHeader(0x0029, 2, 2), nullptr, "DeleteUserProgramsAtomically"},
{0x002B0142, nullptr, "ListExistingContentInfosSystem"}, {IPC::MakeHeader(0x002A, 3, 0), nullptr, "GetNumExistingContentInfosSystem"},
{0x002C0084, nullptr, "GetProgramInfosIgnorePlatform"}, {IPC::MakeHeader(0x002B, 5, 2), nullptr, "ListExistingContentInfosSystem"},
{0x002D00C0, nullptr, "CheckContentRightsIgnorePlatform"}, {IPC::MakeHeader(0x002C, 2, 4), nullptr, "GetProgramInfosIgnorePlatform"},
{0x04010080, nullptr, "UpdateFirmwareTo"}, {IPC::MakeHeader(0x002D, 3, 0), nullptr, "CheckContentRightsIgnorePlatform"},
{0x04020040, &AM_U::BeginImportProgram, "BeginImportProgram"}, {IPC::MakeHeader(0x0401, 2, 0), nullptr, "UpdateFirmwareTo"},
{0x04030000, &AM_U::BeginImportProgramTemporarily, "BeginImportProgramTemporarily"}, {IPC::MakeHeader(0x0402, 1, 0), &AM_U::BeginImportProgram, "BeginImportProgram"},
{0x04040002, nullptr, "CancelImportProgram"}, {IPC::MakeHeader(0x0403, 0, 0), &AM_U::BeginImportProgramTemporarily, "BeginImportProgramTemporarily"},
{0x04050002, &AM_U::EndImportProgram, "EndImportProgram"}, {IPC::MakeHeader(0x0404, 0, 2), nullptr, "CancelImportProgram"},
{0x04060002, &AM_U::EndImportProgramWithoutCommit, "EndImportProgramWithoutCommit"}, {IPC::MakeHeader(0x0405, 0, 2), &AM_U::EndImportProgram, "EndImportProgram"},
{0x040700C2, &AM_U::CommitImportPrograms, "CommitImportPrograms"}, {IPC::MakeHeader(0x0406, 0, 2), &AM_U::EndImportProgramWithoutCommit, "EndImportProgramWithoutCommit"},
{0x04080042, &AM_U::GetProgramInfoFromCia, "GetProgramInfoFromCia"}, {IPC::MakeHeader(0x0407, 3, 2), &AM_U::CommitImportPrograms, "CommitImportPrograms"},
{0x04090004, &AM_U::GetSystemMenuDataFromCia, "GetSystemMenuDataFromCia"}, {IPC::MakeHeader(0x0408, 1, 2), &AM_U::GetProgramInfoFromCia, "GetProgramInfoFromCia"},
{0x040A0002, &AM_U::GetDependencyListFromCia, "GetDependencyListFromCia"}, {IPC::MakeHeader(0x0409, 0, 4), &AM_U::GetSystemMenuDataFromCia, "GetSystemMenuDataFromCia"},
{0x040B0002, &AM_U::GetTransferSizeFromCia, "GetTransferSizeFromCia"}, {IPC::MakeHeader(0x040A, 0, 2), &AM_U::GetDependencyListFromCia, "GetDependencyListFromCia"},
{0x040C0002, &AM_U::GetCoreVersionFromCia, "GetCoreVersionFromCia"}, {IPC::MakeHeader(0x040B, 0, 2), &AM_U::GetTransferSizeFromCia, "GetTransferSizeFromCia"},
{0x040D0042, &AM_U::GetRequiredSizeFromCia, "GetRequiredSizeFromCia"}, {IPC::MakeHeader(0x040C, 0, 2), &AM_U::GetCoreVersionFromCia, "GetCoreVersionFromCia"},
{0x040E00C2, nullptr, "CommitImportProgramsAndUpdateFirmwareAuto"}, {IPC::MakeHeader(0x040D, 1, 2), &AM_U::GetRequiredSizeFromCia, "GetRequiredSizeFromCia"},
{0x040F0000, nullptr, "UpdateFirmwareAuto"}, {IPC::MakeHeader(0x040E, 3, 2), nullptr, "CommitImportProgramsAndUpdateFirmwareAuto"},
{0x041000C0, &AM_U::DeleteProgram, "DeleteProgram"}, {IPC::MakeHeader(0x040F, 0, 0), nullptr, "UpdateFirmwareAuto"},
{0x04110044, nullptr, "GetTwlProgramListForReboot"}, {IPC::MakeHeader(0x0410, 3, 0), &AM_U::DeleteProgram, "DeleteProgram"},
{0x04120000, &AM_U::GetSystemUpdaterMutex, "GetSystemUpdaterMutex"}, {IPC::MakeHeader(0x0411, 1, 4), nullptr, "GetTwlProgramListForReboot"},
{0x04130002, &AM_U::GetMetaSizeFromCia, "GetMetaSizeFromCia"}, {IPC::MakeHeader(0x0412, 0, 0), &AM_U::GetSystemUpdaterMutex, "GetSystemUpdaterMutex"},
{0x04140044, &AM_U::GetMetaDataFromCia, "GetMetaDataFromCia"}, {IPC::MakeHeader(0x0413, 0, 2), &AM_U::GetMetaSizeFromCia, "GetMetaSizeFromCia"},
{0x04150080, nullptr, "CheckDemoLaunchRights"}, {IPC::MakeHeader(0x0414, 1, 4), &AM_U::GetMetaDataFromCia, "GetMetaDataFromCia"},
{0x041600C0, nullptr, "GetInternalTitleLocationInfo"}, {IPC::MakeHeader(0x0415, 2, 0), nullptr, "CheckDemoLaunchRights"},
{0x041700C0, nullptr, "PerpetuateAgbSaveData"}, {IPC::MakeHeader(0x0416, 3, 0), nullptr, "GetInternalTitleLocationInfo"},
{0x04180040, nullptr, "BeginImportProgramForOverWrite"}, {IPC::MakeHeader(0x0417, 3, 0), nullptr, "PerpetuateAgbSaveData"},
{0x04190000, nullptr, "BeginImportSystemProgram"}, {IPC::MakeHeader(0x0418, 1, 0), nullptr, "BeginImportProgramForOverWrite"},
{IPC::MakeHeader(0x0419, 0, 0), nullptr, "BeginImportSystemProgram"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

186
src/core/hle/service/apt/apt_a.cpp
View File

@@ -10,98 +10,100 @@ namespace Service::APT {
APT_A::APT_A(std::shared_ptr<Module> apt) APT_A::APT_A(std::shared_ptr<Module> apt)
: Module::APTInterface(std::move(apt), "APT:A", MaxAPTSessions) { : Module::APTInterface(std::move(apt), "APT:A", MaxAPTSessions) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x00010040, &APT_A::GetLockHandle, "GetLockHandle"}, // clang-format off
{0x00020080, &APT_A::Initialize, "Initialize"}, {IPC::MakeHeader(0x0001, 1, 0), &APT_A::GetLockHandle, "GetLockHandle"},
{0x00030040, &APT_A::Enable, "Enable"}, {IPC::MakeHeader(0x0002, 2, 0), &APT_A::Initialize, "Initialize"},
{0x00040040, nullptr, "Finalize"}, {IPC::MakeHeader(0x0003, 1, 0), &APT_A::Enable, "Enable"},
{0x00050040, &APT_A::GetAppletManInfo, "GetAppletManInfo"}, {IPC::MakeHeader(0x0004, 1, 0), nullptr, "Finalize"},
{0x00060040, &APT_A::GetAppletInfo, "GetAppletInfo"}, {IPC::MakeHeader(0x0005, 1, 0), &APT_A::GetAppletManInfo, "GetAppletManInfo"},
{0x00070000, nullptr, "GetLastSignaledAppletId"}, {IPC::MakeHeader(0x0006, 1, 0), &APT_A::GetAppletInfo, "GetAppletInfo"},
{0x00080000, nullptr, "CountRegisteredApplet"}, {IPC::MakeHeader(0x0007, 0, 0), nullptr, "GetLastSignaledAppletId"},
{0x00090040, &APT_A::IsRegistered, "IsRegistered"}, {IPC::MakeHeader(0x0008, 0, 0), nullptr, "CountRegisteredApplet"},
{0x000A0040, nullptr, "GetAttribute"}, {IPC::MakeHeader(0x0009, 1, 0), &APT_A::IsRegistered, "IsRegistered"},
{0x000B0040, &APT_A::InquireNotification, "InquireNotification"}, {IPC::MakeHeader(0x000A, 1, 0), nullptr, "GetAttribute"},
{0x000C0104, &APT_A::SendParameter, "SendParameter"}, {IPC::MakeHeader(0x000B, 1, 0), &APT_A::InquireNotification, "InquireNotification"},
{0x000D0080, &APT_A::ReceiveParameter, "ReceiveParameter"}, {IPC::MakeHeader(0x000C, 4, 4), &APT_A::SendParameter, "SendParameter"},
{0x000E0080, &APT_A::GlanceParameter, "GlanceParameter"}, {IPC::MakeHeader(0x000D, 2, 0), &APT_A::ReceiveParameter, "ReceiveParameter"},
{0x000F0100, &APT_A::CancelParameter, "CancelParameter"}, {IPC::MakeHeader(0x000E, 2, 0), &APT_A::GlanceParameter, "GlanceParameter"},
{0x001000C2, nullptr, "DebugFunc"}, {IPC::MakeHeader(0x000F, 4, 0), &APT_A::CancelParameter, "CancelParameter"},
{0x001100C0, nullptr, "MapProgramIdForDebug"}, {IPC::MakeHeader(0x0010, 3, 2), nullptr, "DebugFunc"},
{0x00120040, nullptr, "SetHomeMenuAppletIdForDebug"}, {IPC::MakeHeader(0x0011, 3, 0), nullptr, "MapProgramIdForDebug"},
{0x00130000, nullptr, "GetPreparationState"}, {IPC::MakeHeader(0x0012, 1, 0), nullptr, "SetHomeMenuAppletIdForDebug"},
{0x00140040, nullptr, "SetPreparationState"}, {IPC::MakeHeader(0x0013, 0, 0), nullptr, "GetPreparationState"},
{0x00150140, &APT_A::PrepareToStartApplication, "PrepareToStartApplication"}, {IPC::MakeHeader(0x0014, 1, 0), nullptr, "SetPreparationState"},
{0x00160040, &APT_A::PreloadLibraryApplet, "PreloadLibraryApplet"}, {IPC::MakeHeader(0x0015, 5, 0), &APT_A::PrepareToStartApplication, "PrepareToStartApplication"},
{0x00170040, &APT_A::FinishPreloadingLibraryApplet, "FinishPreloadingLibraryApplet"}, {IPC::MakeHeader(0x0016, 1, 0), &APT_A::PreloadLibraryApplet, "PreloadLibraryApplet"},
{0x00180040, &APT_A::PrepareToStartLibraryApplet, "PrepareToStartLibraryApplet"}, {IPC::MakeHeader(0x0017, 1, 0), &APT_A::FinishPreloadingLibraryApplet, "FinishPreloadingLibraryApplet"},
{0x00190040, &APT_A::PrepareToStartSystemApplet, "PrepareToStartSystemApplet"}, {IPC::MakeHeader(0x0018, 1, 0), &APT_A::PrepareToStartLibraryApplet, "PrepareToStartLibraryApplet"},
{0x001A0000, &APT_A::PrepareToStartNewestHomeMenu, "PrepareToStartNewestHomeMenu"}, {IPC::MakeHeader(0x0019, 1, 0), &APT_A::PrepareToStartSystemApplet, "PrepareToStartSystemApplet"},
{0x001B00C4, &APT_A::StartApplication, "StartApplication"}, {IPC::MakeHeader(0x001A, 0, 0), &APT_A::PrepareToStartNewestHomeMenu, "PrepareToStartNewestHomeMenu"},
{0x001C0000, &APT_A::WakeupApplication, "WakeupApplication"}, {IPC::MakeHeader(0x001B, 3, 4), &APT_A::StartApplication, "StartApplication"},
{0x001D0000, nullptr, "CancelApplication"}, {IPC::MakeHeader(0x001C, 0, 0), &APT_A::WakeupApplication, "WakeupApplication"},
{0x001E0084, &APT_A::StartLibraryApplet, "StartLibraryApplet"}, {IPC::MakeHeader(0x001D, 0, 0), nullptr, "CancelApplication"},
{0x001F0084, &APT_A::StartSystemApplet, "StartSystemApplet"}, {IPC::MakeHeader(0x001E, 2, 4), &APT_A::StartLibraryApplet, "StartLibraryApplet"},
{0x00200044, nullptr, "StartNewestHomeMenu"}, {IPC::MakeHeader(0x001F, 2, 4), &APT_A::StartSystemApplet, "StartSystemApplet"},
{0x00210000, &APT_A::OrderToCloseApplication, "OrderToCloseApplication"}, {IPC::MakeHeader(0x0020, 1, 4), nullptr, "StartNewestHomeMenu"},
{0x00220040, &APT_A::PrepareToCloseApplication, "PrepareToCloseApplication"}, {IPC::MakeHeader(0x0021, 0, 0), &APT_A::OrderToCloseApplication, "OrderToCloseApplication"},
{0x00230040, nullptr, "PrepareToJumpToApplication"}, {IPC::MakeHeader(0x0022, 1, 0), &APT_A::PrepareToCloseApplication, "PrepareToCloseApplication"},
{0x00240044, nullptr, "JumpToApplication"}, {IPC::MakeHeader(0x0023, 1, 0), nullptr, "PrepareToJumpToApplication"},
{0x002500C0, &APT_A::PrepareToCloseLibraryApplet, "PrepareToCloseLibraryApplet"}, {IPC::MakeHeader(0x0024, 1, 4), nullptr, "JumpToApplication"},
{0x00260000, &APT_A::PrepareToCloseSystemApplet, "PrepareToCloseSystemApplet"}, {IPC::MakeHeader(0x0025, 3, 0), &APT_A::PrepareToCloseLibraryApplet, "PrepareToCloseLibraryApplet"},
{0x00270044, &APT_A::CloseApplication, "CloseApplication"}, {IPC::MakeHeader(0x0026, 0, 0), &APT_A::PrepareToCloseSystemApplet, "PrepareToCloseSystemApplet"},
{0x00280044, &APT_A::CloseLibraryApplet, "CloseLibraryApplet"}, {IPC::MakeHeader(0x0027, 1, 4), &APT_A::CloseApplication, "CloseApplication"},
{0x00290044, &APT_A::CloseSystemApplet, "CloseSystemApplet"}, {IPC::MakeHeader(0x0028, 1, 4), &APT_A::CloseLibraryApplet, "CloseLibraryApplet"},
{0x002A0000, &APT_A::OrderToCloseSystemApplet, "OrderToCloseSystemApplet"}, {IPC::MakeHeader(0x0029, 1, 4), &APT_A::CloseSystemApplet, "CloseSystemApplet"},
{0x002B0000, &APT_A::PrepareToJumpToHomeMenu, "PrepareToJumpToHomeMenu"}, {IPC::MakeHeader(0x002A, 0, 0), &APT_A::OrderToCloseSystemApplet, "OrderToCloseSystemApplet"},
{0x002C0044, &APT_A::JumpToHomeMenu, "JumpToHomeMenu"}, {IPC::MakeHeader(0x002B, 0, 0), &APT_A::PrepareToJumpToHomeMenu, "PrepareToJumpToHomeMenu"},
{0x002D0000, &APT_A::PrepareToLeaveHomeMenu, "PrepareToLeaveHomeMenu"}, {IPC::MakeHeader(0x002C, 1, 4), &APT_A::JumpToHomeMenu, "JumpToHomeMenu"},
{0x002E0044, &APT_A::LeaveHomeMenu, "LeaveHomeMenu"}, {IPC::MakeHeader(0x002D, 0, 0), &APT_A::PrepareToLeaveHomeMenu, "PrepareToLeaveHomeMenu"},
{0x002F0040, nullptr, "PrepareToLeaveResidentApplet"}, {IPC::MakeHeader(0x002E, 1, 4), &APT_A::LeaveHomeMenu, "LeaveHomeMenu"},
{0x00300044, nullptr, "LeaveResidentApplet"}, {IPC::MakeHeader(0x002F, 1, 0), nullptr, "PrepareToLeaveResidentApplet"},
{0x00310100, &APT_A::PrepareToDoApplicationJump, "PrepareToDoApplicationJump"}, {IPC::MakeHeader(0x0030, 1, 4), nullptr, "LeaveResidentApplet"},
{0x00320084, &APT_A::DoApplicationJump, "DoApplicationJump"}, {IPC::MakeHeader(0x0031, 4, 0), &APT_A::PrepareToDoApplicationJump, "PrepareToDoApplicationJump"},
{0x00330000, &APT_A::GetProgramIdOnApplicationJump, "GetProgramIdOnApplicationJump"}, {IPC::MakeHeader(0x0032, 2, 4), &APT_A::DoApplicationJump, "DoApplicationJump"},
{0x00340084, nullptr, "SendDeliverArg"}, {IPC::MakeHeader(0x0033, 0, 0), &APT_A::GetProgramIdOnApplicationJump, "GetProgramIdOnApplicationJump"},
{0x00350080, &APT_A::ReceiveDeliverArg, "ReceiveDeliverArg"}, {IPC::MakeHeader(0x0034, 2, 4), nullptr, "SendDeliverArg"},
{0x00360040, &APT_A::LoadSysMenuArg, "LoadSysMenuArg"}, {IPC::MakeHeader(0x0035, 2, 0), &APT_A::ReceiveDeliverArg, "ReceiveDeliverArg"},
{0x00370042, &APT_A::StoreSysMenuArg, "StoreSysMenuArg"}, {IPC::MakeHeader(0x0036, 1, 0), &APT_A::LoadSysMenuArg, "LoadSysMenuArg"},
{0x00380040, nullptr, "PreloadResidentApplet"}, {IPC::MakeHeader(0x0037, 1, 2), &APT_A::StoreSysMenuArg, "StoreSysMenuArg"},
{0x00390040, nullptr, "PrepareToStartResidentApplet"}, {IPC::MakeHeader(0x0038, 1, 0), nullptr, "PreloadResidentApplet"},
{0x003A0044, nullptr, "StartResidentApplet"}, {IPC::MakeHeader(0x0039, 1, 0), nullptr, "PrepareToStartResidentApplet"},
{0x003B0040, &APT_A::CancelLibraryApplet, "CancelLibraryApplet"}, {IPC::MakeHeader(0x003A, 1, 4), nullptr, "StartResidentApplet"},
{0x003C0042, nullptr, "SendDspSleep"}, {IPC::MakeHeader(0x003B, 1, 0), &APT_A::CancelLibraryApplet, "CancelLibraryApplet"},
{0x003D0042, nullptr, "SendDspWakeUp"}, {IPC::MakeHeader(0x003C, 1, 2), nullptr, "SendDspSleep"},
{0x003E0080, nullptr, "ReplySleepQuery"}, {IPC::MakeHeader(0x003D, 1, 2), nullptr, "SendDspWakeUp"},
{0x003F0040, nullptr, "ReplySleepNotificationComplete"}, {IPC::MakeHeader(0x003E, 2, 0), nullptr, "ReplySleepQuery"},
{0x00400042, &APT_A::SendCaptureBufferInfo, "SendCaptureBufferInfo"}, {IPC::MakeHeader(0x003F, 1, 0), nullptr, "ReplySleepNotificationComplete"},
{0x00410040, &APT_A::ReceiveCaptureBufferInfo, "ReceiveCaptureBufferInfo"}, {IPC::MakeHeader(0x0040, 1, 2), &APT_A::SendCaptureBufferInfo, "SendCaptureBufferInfo"},
{0x00420080, nullptr, "SleepSystem"}, {IPC::MakeHeader(0x0041, 1, 0), &APT_A::ReceiveCaptureBufferInfo, "ReceiveCaptureBufferInfo"},
{0x00430040, &APT_A::NotifyToWait, "NotifyToWait"}, {IPC::MakeHeader(0x0042, 2, 0), nullptr, "SleepSystem"},
{0x00440000, &APT_A::GetSharedFont, "GetSharedFont"}, {IPC::MakeHeader(0x0043, 1, 0), &APT_A::NotifyToWait, "NotifyToWait"},
{0x00450040, &APT_A::GetWirelessRebootInfo, "GetWirelessRebootInfo"}, {IPC::MakeHeader(0x0044, 0, 0), &APT_A::GetSharedFont, "GetSharedFont"},
{0x00460104, &APT_A::Wrap, "Wrap"}, {IPC::MakeHeader(0x0045, 1, 0), &APT_A::GetWirelessRebootInfo, "GetWirelessRebootInfo"},
{0x00470104, &APT_A::Unwrap, "Unwrap"}, {IPC::MakeHeader(0x0046, 4, 4), &APT_A::Wrap, "Wrap"},
{0x00480100, nullptr, "GetProgramInfo"}, {IPC::MakeHeader(0x0047, 4, 4), &APT_A::Unwrap, "Unwrap"},
{0x00490180, nullptr, "Reboot"}, {IPC::MakeHeader(0x0048, 4, 0), nullptr, "GetProgramInfo"},
{0x004A0040, &APT_A::GetCaptureInfo, "GetCaptureInfo"}, {IPC::MakeHeader(0x0049, 6, 0), nullptr, "Reboot"},
{0x004B00C2, &APT_A::AppletUtility, "AppletUtility"}, {IPC::MakeHeader(0x004A, 1, 0), &APT_A::GetCaptureInfo, "GetCaptureInfo"},
{0x004C0000, nullptr, "SetFatalErrDispMode"}, {IPC::MakeHeader(0x004B, 3, 2), &APT_A::AppletUtility, "AppletUtility"},
{0x004D0080, nullptr, "GetAppletProgramInfo"}, {IPC::MakeHeader(0x004C, 0, 0), nullptr, "SetFatalErrDispMode"},
{0x004E0000, nullptr, "HardwareResetAsync"}, {IPC::MakeHeader(0x004D, 2, 0), nullptr, "GetAppletProgramInfo"},
{0x004F0080, &APT_A::SetAppCpuTimeLimit, "SetAppCpuTimeLimit"}, {IPC::MakeHeader(0x004E, 0, 0), nullptr, "HardwareResetAsync"},
{0x00500040, &APT_A::GetAppCpuTimeLimit, "GetAppCpuTimeLimit"}, {IPC::MakeHeader(0x004F, 2, 0), &APT_A::SetAppCpuTimeLimit, "SetAppCpuTimeLimit"},
{0x00510080, &APT_A::GetStartupArgument, "GetStartupArgument"}, {IPC::MakeHeader(0x0050, 1, 0), &APT_A::GetAppCpuTimeLimit, "GetAppCpuTimeLimit"},
{0x00520104, nullptr, "Wrap1"}, {IPC::MakeHeader(0x0051, 2, 0), &APT_A::GetStartupArgument, "GetStartupArgument"},
{0x00530104, nullptr, "Unwrap1"}, {IPC::MakeHeader(0x0052, 4, 4), nullptr, "Wrap1"},
{0x00550040, &APT_A::SetScreenCapPostPermission, "SetScreenCapPostPermission"}, {IPC::MakeHeader(0x0053, 4, 4), nullptr, "Unwrap1"},
{0x00560000, &APT_A::GetScreenCapPostPermission, "GetScreenCapPostPermission"}, {IPC::MakeHeader(0x0055, 1, 0), &APT_A::SetScreenCapPostPermission, "SetScreenCapPostPermission"},
{0x00570044, nullptr, "WakeupApplication2"}, {IPC::MakeHeader(0x0056, 0, 0), &APT_A::GetScreenCapPostPermission, "GetScreenCapPostPermission"},
{0x00580002, nullptr, "GetProgramID"}, {IPC::MakeHeader(0x0057, 1, 4), nullptr, "WakeupApplication2"},
{0x01010000, &APT_A::CheckNew3DSApp, "CheckNew3DSApp"}, {IPC::MakeHeader(0x0058, 0, 2), nullptr, "GetProgramID"},
{0x01020000, &APT_A::CheckNew3DS, "CheckNew3DS"}, {IPC::MakeHeader(0x0101, 0, 0), &APT_A::CheckNew3DSApp, "CheckNew3DSApp"},
{0x01030000, &APT_A::Unknown0x0103, "Unknown0x0103"}, {IPC::MakeHeader(0x0102, 0, 0), &APT_A::CheckNew3DS, "CheckNew3DS"},
{0x01040000, nullptr, "IsStandardMemoryLayout"}, {IPC::MakeHeader(0x0103, 0, 0), &APT_A::Unknown0x0103, "Unknown0x0103"},
{0x01050100, &APT_A::IsTitleAllowed, "IsTitleAllowed"}, {IPC::MakeHeader(0x0104, 0, 0), nullptr, "IsStandardMemoryLayout"},
{IPC::MakeHeader(0x0105, 4, 0), &APT_A::IsTitleAllowed, "IsTitleAllowed"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

186
src/core/hle/service/apt/apt_s.cpp
View File

@@ -10,98 +10,100 @@ namespace Service::APT {
APT_S::APT_S(std::shared_ptr<Module> apt) APT_S::APT_S(std::shared_ptr<Module> apt)
: Module::APTInterface(std::move(apt), "APT:S", MaxAPTSessions) { : Module::APTInterface(std::move(apt), "APT:S", MaxAPTSessions) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x00010040, &APT_S::GetLockHandle, "GetLockHandle"}, // clang-format off
{0x00020080, &APT_S::Initialize, "Initialize"}, {IPC::MakeHeader(0x0001, 1, 0), &APT_S::GetLockHandle, "GetLockHandle"},
{0x00030040, &APT_S::Enable, "Enable"}, {IPC::MakeHeader(0x0002, 2, 0), &APT_S::Initialize, "Initialize"},
{0x00040040, nullptr, "Finalize"}, {IPC::MakeHeader(0x0003, 1, 0), &APT_S::Enable, "Enable"},
{0x00050040, &APT_S::GetAppletManInfo, "GetAppletManInfo"}, {IPC::MakeHeader(0x0004, 1, 0), nullptr, "Finalize"},
{0x00060040, &APT_S::GetAppletInfo, "GetAppletInfo"}, {IPC::MakeHeader(0x0005, 1, 0), &APT_S::GetAppletManInfo, "GetAppletManInfo"},
{0x00070000, nullptr, "GetLastSignaledAppletId"}, {IPC::MakeHeader(0x0006, 1, 0), &APT_S::GetAppletInfo, "GetAppletInfo"},
{0x00080000, nullptr, "CountRegisteredApplet"}, {IPC::MakeHeader(0x0007, 0, 0), nullptr, "GetLastSignaledAppletId"},
{0x00090040, &APT_S::IsRegistered, "IsRegistered"}, {IPC::MakeHeader(0x0008, 0, 0), nullptr, "CountRegisteredApplet"},
{0x000A0040, nullptr, "GetAttribute"}, {IPC::MakeHeader(0x0009, 1, 0), &APT_S::IsRegistered, "IsRegistered"},
{0x000B0040, &APT_S::InquireNotification, "InquireNotification"}, {IPC::MakeHeader(0x000A, 1, 0), nullptr, "GetAttribute"},
{0x000C0104, &APT_S::SendParameter, "SendParameter"}, {IPC::MakeHeader(0x000B, 1, 0), &APT_S::InquireNotification, "InquireNotification"},
{0x000D0080, &APT_S::ReceiveParameter, "ReceiveParameter"}, {IPC::MakeHeader(0x000C, 4, 4), &APT_S::SendParameter, "SendParameter"},
{0x000E0080, &APT_S::GlanceParameter, "GlanceParameter"}, {IPC::MakeHeader(0x000D, 2, 0), &APT_S::ReceiveParameter, "ReceiveParameter"},
{0x000F0100, &APT_S::CancelParameter, "CancelParameter"}, {IPC::MakeHeader(0x000E, 2, 0), &APT_S::GlanceParameter, "GlanceParameter"},
{0x001000C2, nullptr, "DebugFunc"}, {IPC::MakeHeader(0x000F, 4, 0), &APT_S::CancelParameter, "CancelParameter"},
{0x001100C0, nullptr, "MapProgramIdForDebug"}, {IPC::MakeHeader(0x0010, 3, 2), nullptr, "DebugFunc"},
{0x00120040, nullptr, "SetHomeMenuAppletIdForDebug"}, {IPC::MakeHeader(0x0011, 3, 0), nullptr, "MapProgramIdForDebug"},
{0x00130000, nullptr, "GetPreparationState"}, {IPC::MakeHeader(0x0012, 1, 0), nullptr, "SetHomeMenuAppletIdForDebug"},
{0x00140040, nullptr, "SetPreparationState"}, {IPC::MakeHeader(0x0013, 0, 0), nullptr, "GetPreparationState"},
{0x00150140, &APT_S::PrepareToStartApplication, "PrepareToStartApplication"}, {IPC::MakeHeader(0x0014, 1, 0), nullptr, "SetPreparationState"},
{0x00160040, &APT_S::PreloadLibraryApplet, "PreloadLibraryApplet"}, {IPC::MakeHeader(0x0015, 5, 0), &APT_S::PrepareToStartApplication, "PrepareToStartApplication"},
{0x00170040, &APT_S::FinishPreloadingLibraryApplet, "FinishPreloadingLibraryApplet"}, {IPC::MakeHeader(0x0016, 1, 0), &APT_S::PreloadLibraryApplet, "PreloadLibraryApplet"},
{0x00180040, &APT_S::PrepareToStartLibraryApplet, "PrepareToStartLibraryApplet"}, {IPC::MakeHeader(0x0017, 1, 0), &APT_S::FinishPreloadingLibraryApplet, "FinishPreloadingLibraryApplet"},
{0x00190040, &APT_S::PrepareToStartSystemApplet, "PrepareToStartSystemApplet"}, {IPC::MakeHeader(0x0018, 1, 0), &APT_S::PrepareToStartLibraryApplet, "PrepareToStartLibraryApplet"},
{0x001A0000, &APT_S::PrepareToStartNewestHomeMenu, "PrepareToStartNewestHomeMenu"}, {IPC::MakeHeader(0x0019, 1, 0), &APT_S::PrepareToStartSystemApplet, "PrepareToStartSystemApplet"},
{0x001B00C4, &APT_S::StartApplication, "StartApplication"}, {IPC::MakeHeader(0x001A, 0, 0), &APT_S::PrepareToStartNewestHomeMenu, "PrepareToStartNewestHomeMenu"},
{0x001C0000, &APT_S::WakeupApplication, "WakeupApplication"}, {IPC::MakeHeader(0x001B, 3, 4), &APT_S::StartApplication, "StartApplication"},
{0x001D0000, nullptr, "CancelApplication"}, {IPC::MakeHeader(0x001C, 0, 0), &APT_S::WakeupApplication, "WakeupApplication"},
{0x001E0084, &APT_S::StartLibraryApplet, "StartLibraryApplet"}, {IPC::MakeHeader(0x001D, 0, 0), nullptr, "CancelApplication"},
{0x001F0084, &APT_S::StartSystemApplet, "StartSystemApplet"}, {IPC::MakeHeader(0x001E, 2, 4), &APT_S::StartLibraryApplet, "StartLibraryApplet"},
{0x00200044, nullptr, "StartNewestHomeMenu"}, {IPC::MakeHeader(0x001F, 2, 4), &APT_S::StartSystemApplet, "StartSystemApplet"},
{0x00210000, &APT_S::OrderToCloseApplication, "OrderToCloseApplication"}, {IPC::MakeHeader(0x0020, 1, 4), nullptr, "StartNewestHomeMenu"},
{0x00220040, &APT_S::PrepareToCloseApplication, "PrepareToCloseApplication"}, {IPC::MakeHeader(0x0021, 0, 0), &APT_S::OrderToCloseApplication, "OrderToCloseApplication"},
{0x00230040, nullptr, "PrepareToJumpToApplication"}, {IPC::MakeHeader(0x0022, 1, 0), &APT_S::PrepareToCloseApplication, "PrepareToCloseApplication"},
{0x00240044, nullptr, "JumpToApplication"}, {IPC::MakeHeader(0x0023, 1, 0), nullptr, "PrepareToJumpToApplication"},
{0x002500C0, &APT_S::PrepareToCloseLibraryApplet, "PrepareToCloseLibraryApplet"}, {IPC::MakeHeader(0x0024, 1, 4), nullptr, "JumpToApplication"},
{0x00260000, &APT_S::PrepareToCloseSystemApplet, "PrepareToCloseSystemApplet"}, {IPC::MakeHeader(0x0025, 3, 0), &APT_S::PrepareToCloseLibraryApplet, "PrepareToCloseLibraryApplet"},
{0x00270044, &APT_S::CloseApplication, "CloseApplication"}, {IPC::MakeHeader(0x0026, 0, 0), &APT_S::PrepareToCloseSystemApplet, "PrepareToCloseSystemApplet"},
{0x00280044, &APT_S::CloseLibraryApplet, "CloseLibraryApplet"}, {IPC::MakeHeader(0x0027, 1, 4), &APT_S::CloseApplication, "CloseApplication"},
{0x00290044, &APT_S::CloseSystemApplet, "CloseSystemApplet"}, {IPC::MakeHeader(0x0028, 1, 4), &APT_S::CloseLibraryApplet, "CloseLibraryApplet"},
{0x002A0000, &APT_S::OrderToCloseSystemApplet, "OrderToCloseSystemApplet"}, {IPC::MakeHeader(0x0029, 1, 4), &APT_S::CloseSystemApplet, "CloseSystemApplet"},
{0x002B0000, &APT_S::PrepareToJumpToHomeMenu, "PrepareToJumpToHomeMenu"}, {IPC::MakeHeader(0x002A, 0, 0), &APT_S::OrderToCloseSystemApplet, "OrderToCloseSystemApplet"},
{0x002C0044, &APT_S::JumpToHomeMenu, "JumpToHomeMenu"}, {IPC::MakeHeader(0x002B, 0, 0), &APT_S::PrepareToJumpToHomeMenu, "PrepareToJumpToHomeMenu"},
{0x002D0000, &APT_S::PrepareToLeaveHomeMenu, "PrepareToLeaveHomeMenu"}, {IPC::MakeHeader(0x002C, 1, 4), &APT_S::JumpToHomeMenu, "JumpToHomeMenu"},
{0x002E0044, &APT_S::LeaveHomeMenu, "LeaveHomeMenu"}, {IPC::MakeHeader(0x002D, 0, 0), &APT_S::PrepareToLeaveHomeMenu, "PrepareToLeaveHomeMenu"},
{0x002F0040, nullptr, "PrepareToLeaveResidentApplet"}, {IPC::MakeHeader(0x002E, 1, 4), &APT_S::LeaveHomeMenu, "LeaveHomeMenu"},
{0x00300044, nullptr, "LeaveResidentApplet"}, {IPC::MakeHeader(0x002F, 1, 0), nullptr, "PrepareToLeaveResidentApplet"},
{0x00310100, &APT_S::PrepareToDoApplicationJump, "PrepareToDoApplicationJump"}, {IPC::MakeHeader(0x0030, 1, 4), nullptr, "LeaveResidentApplet"},
{0x00320084, &APT_S::DoApplicationJump, "DoApplicationJump"}, {IPC::MakeHeader(0x0031, 4, 0), &APT_S::PrepareToDoApplicationJump, "PrepareToDoApplicationJump"},
{0x00330000, &APT_S::GetProgramIdOnApplicationJump, "GetProgramIdOnApplicationJump"}, {IPC::MakeHeader(0x0032, 2, 4), &APT_S::DoApplicationJump, "DoApplicationJump"},
{0x00340084, nullptr, "SendDeliverArg"}, {IPC::MakeHeader(0x0033, 0, 0), &APT_S::GetProgramIdOnApplicationJump, "GetProgramIdOnApplicationJump"},
{0x00350080, &APT_S::ReceiveDeliverArg, "ReceiveDeliverArg"}, {IPC::MakeHeader(0x0034, 2, 4), nullptr, "SendDeliverArg"},
{0x00360040, &APT_S::LoadSysMenuArg, "LoadSysMenuArg"}, {IPC::MakeHeader(0x0035, 2, 0), &APT_S::ReceiveDeliverArg, "ReceiveDeliverArg"},
{0x00370042, &APT_S::StoreSysMenuArg, "StoreSysMenuArg"}, {IPC::MakeHeader(0x0036, 1, 0), &APT_S::LoadSysMenuArg, "LoadSysMenuArg"},
{0x00380040, nullptr, "PreloadResidentApplet"}, {IPC::MakeHeader(0x0037, 1, 2), &APT_S::StoreSysMenuArg, "StoreSysMenuArg"},
{0x00390040, nullptr, "PrepareToStartResidentApplet"}, {IPC::MakeHeader(0x0038, 1, 0), nullptr, "PreloadResidentApplet"},
{0x003A0044, nullptr, "StartResidentApplet"}, {IPC::MakeHeader(0x0039, 1, 0), nullptr, "PrepareToStartResidentApplet"},
{0x003B0040, &APT_S::CancelLibraryApplet, "CancelLibraryApplet"}, {IPC::MakeHeader(0x003A, 1, 4), nullptr, "StartResidentApplet"},
{0x003C0042, nullptr, "SendDspSleep"}, {IPC::MakeHeader(0x003B, 1, 0), &APT_S::CancelLibraryApplet, "CancelLibraryApplet"},
{0x003D0042, nullptr, "SendDspWakeUp"}, {IPC::MakeHeader(0x003C, 1, 2), nullptr, "SendDspSleep"},
{0x003E0080, nullptr, "ReplySleepQuery"}, {IPC::MakeHeader(0x003D, 1, 2), nullptr, "SendDspWakeUp"},
{0x003F0040, nullptr, "ReplySleepNotificationComplete"}, {IPC::MakeHeader(0x003E, 2, 0), nullptr, "ReplySleepQuery"},
{0x00400042, &APT_S::SendCaptureBufferInfo, "SendCaptureBufferInfo"}, {IPC::MakeHeader(0x003F, 1, 0), nullptr, "ReplySleepNotificationComplete"},
{0x00410040, &APT_S::ReceiveCaptureBufferInfo, "ReceiveCaptureBufferInfo"}, {IPC::MakeHeader(0x0040, 1, 2), &APT_S::SendCaptureBufferInfo, "SendCaptureBufferInfo"},
{0x00420080, nullptr, "SleepSystem"}, {IPC::MakeHeader(0x0041, 1, 0), &APT_S::ReceiveCaptureBufferInfo, "ReceiveCaptureBufferInfo"},
{0x00430040, &APT_S::NotifyToWait, "NotifyToWait"}, {IPC::MakeHeader(0x0042, 2, 0), nullptr, "SleepSystem"},
{0x00440000, &APT_S::GetSharedFont, "GetSharedFont"}, {IPC::MakeHeader(0x0043, 1, 0), &APT_S::NotifyToWait, "NotifyToWait"},
{0x00450040, &APT_S::GetWirelessRebootInfo, "GetWirelessRebootInfo"}, {IPC::MakeHeader(0x0044, 0, 0), &APT_S::GetSharedFont, "GetSharedFont"},
{0x00460104, &APT_S::Wrap, "Wrap"}, {IPC::MakeHeader(0x0045, 1, 0), &APT_S::GetWirelessRebootInfo, "GetWirelessRebootInfo"},
{0x00470104, &APT_S::Unwrap, "Unwrap"}, {IPC::MakeHeader(0x0046, 4, 4), &APT_S::Wrap, "Wrap"},
{0x00480100, nullptr, "GetProgramInfo"}, {IPC::MakeHeader(0x0047, 4, 4), &APT_S::Unwrap, "Unwrap"},
{0x00490180, nullptr, "Reboot"}, {IPC::MakeHeader(0x0048, 4, 0), nullptr, "GetProgramInfo"},
{0x004A0040, &APT_S::GetCaptureInfo, "GetCaptureInfo"}, {IPC::MakeHeader(0x0049, 6, 0), nullptr, "Reboot"},
{0x004B00C2, &APT_S::AppletUtility, "AppletUtility"}, {IPC::MakeHeader(0x004A, 1, 0), &APT_S::GetCaptureInfo, "GetCaptureInfo"},
{0x004C0000, nullptr, "SetFatalErrDispMode"}, {IPC::MakeHeader(0x004B, 3, 2), &APT_S::AppletUtility, "AppletUtility"},
{0x004D0080, nullptr, "GetAppletProgramInfo"}, {IPC::MakeHeader(0x004C, 0, 0), nullptr, "SetFatalErrDispMode"},
{0x004E0000, nullptr, "HardwareResetAsync"}, {IPC::MakeHeader(0x004D, 2, 0), nullptr, "GetAppletProgramInfo"},
{0x004F0080, &APT_S::SetAppCpuTimeLimit, "SetAppCpuTimeLimit"}, {IPC::MakeHeader(0x004E, 0, 0), nullptr, "HardwareResetAsync"},
{0x00500040, &APT_S::GetAppCpuTimeLimit, "GetAppCpuTimeLimit"}, {IPC::MakeHeader(0x004F, 2, 0), &APT_S::SetAppCpuTimeLimit, "SetAppCpuTimeLimit"},
{0x00510080, &APT_S::GetStartupArgument, "GetStartupArgument"}, {IPC::MakeHeader(0x0050, 1, 0), &APT_S::GetAppCpuTimeLimit, "GetAppCpuTimeLimit"},
{0x00520104, nullptr, "Wrap1"}, {IPC::MakeHeader(0x0051, 2, 0), &APT_S::GetStartupArgument, "GetStartupArgument"},
{0x00530104, nullptr, "Unwrap1"}, {IPC::MakeHeader(0x0052, 4, 4), nullptr, "Wrap1"},
{0x00550040, &APT_S::SetScreenCapPostPermission, "SetScreenCapPostPermission"}, {IPC::MakeHeader(0x0053, 4, 4), nullptr, "Unwrap1"},
{0x00560000, &APT_S::GetScreenCapPostPermission, "GetScreenCapPostPermission"}, {IPC::MakeHeader(0x0055, 1, 0), &APT_S::SetScreenCapPostPermission, "SetScreenCapPostPermission"},
{0x00570044, nullptr, "WakeupApplication2"}, {IPC::MakeHeader(0x0056, 0, 0), &APT_S::GetScreenCapPostPermission, "GetScreenCapPostPermission"},
{0x00580002, nullptr, "GetProgramID"}, {IPC::MakeHeader(0x0057, 1, 4), nullptr, "WakeupApplication2"},
{0x01010000, &APT_S::CheckNew3DSApp, "CheckNew3DSApp"}, {IPC::MakeHeader(0x0058, 0, 2), nullptr, "GetProgramID"},
{0x01020000, &APT_S::CheckNew3DS, "CheckNew3DS"}, {IPC::MakeHeader(0x0101, 0, 0), &APT_S::CheckNew3DSApp, "CheckNew3DSApp"},
{0x01030000, &APT_S::Unknown0x0103, "Unknown0x0103"}, {IPC::MakeHeader(0x0102, 0, 0), &APT_S::CheckNew3DS, "CheckNew3DS"},
{0x01040000, nullptr, "IsStandardMemoryLayout"}, {IPC::MakeHeader(0x0103, 0, 0), &APT_S::Unknown0x0103, "Unknown0x0103"},
{0x01050100, &APT_S::IsTitleAllowed, "IsTitleAllowed"}, {IPC::MakeHeader(0x0104, 0, 0), nullptr, "IsStandardMemoryLayout"},
{IPC::MakeHeader(0x0105, 4, 0), &APT_S::IsTitleAllowed, "IsTitleAllowed"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

186
src/core/hle/service/apt/apt_u.cpp
View File

@@ -10,98 +10,100 @@ namespace Service::APT {
APT_U::APT_U(std::shared_ptr<Module> apt) APT_U::APT_U(std::shared_ptr<Module> apt)
: Module::APTInterface(std::move(apt), "APT:U", MaxAPTSessions) { : Module::APTInterface(std::move(apt), "APT:U", MaxAPTSessions) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x00010040, &APT_U::GetLockHandle, "GetLockHandle"}, // clang-format off
{0x00020080, &APT_U::Initialize, "Initialize"}, {IPC::MakeHeader(0x0001, 1, 0), &APT_U::GetLockHandle, "GetLockHandle"},
{0x00030040, &APT_U::Enable, "Enable"}, {IPC::MakeHeader(0x0002, 2, 0), &APT_U::Initialize, "Initialize"},
{0x00040040, nullptr, "Finalize"}, {IPC::MakeHeader(0x0003, 1, 0), &APT_U::Enable, "Enable"},
{0x00050040, &APT_U::GetAppletManInfo, "GetAppletManInfo"}, {IPC::MakeHeader(0x0004, 1, 0), nullptr, "Finalize"},
{0x00060040, &APT_U::GetAppletInfo, "GetAppletInfo"}, {IPC::MakeHeader(0x0005, 1, 0), &APT_U::GetAppletManInfo, "GetAppletManInfo"},
{0x00070000, nullptr, "GetLastSignaledAppletId"}, {IPC::MakeHeader(0x0006, 1, 0), &APT_U::GetAppletInfo, "GetAppletInfo"},
{0x00080000, nullptr, "CountRegisteredApplet"}, {IPC::MakeHeader(0x0007, 0, 0), nullptr, "GetLastSignaledAppletId"},
{0x00090040, &APT_U::IsRegistered, "IsRegistered"}, {IPC::MakeHeader(0x0008, 0, 0), nullptr, "CountRegisteredApplet"},
{0x000A0040, nullptr, "GetAttribute"}, {IPC::MakeHeader(0x0009, 1, 0), &APT_U::IsRegistered, "IsRegistered"},
{0x000B0040, &APT_U::InquireNotification, "InquireNotification"}, {IPC::MakeHeader(0x000A, 1, 0), nullptr, "GetAttribute"},
{0x000C0104, &APT_U::SendParameter, "SendParameter"}, {IPC::MakeHeader(0x000B, 1, 0), &APT_U::InquireNotification, "InquireNotification"},
{0x000D0080, &APT_U::ReceiveParameter, "ReceiveParameter"}, {IPC::MakeHeader(0x000C, 4, 4), &APT_U::SendParameter, "SendParameter"},
{0x000E0080, &APT_U::GlanceParameter, "GlanceParameter"}, {IPC::MakeHeader(0x000D, 2, 0), &APT_U::ReceiveParameter, "ReceiveParameter"},
{0x000F0100, &APT_U::CancelParameter, "CancelParameter"}, {IPC::MakeHeader(0x000E, 2, 0), &APT_U::GlanceParameter, "GlanceParameter"},
{0x001000C2, nullptr, "DebugFunc"}, {IPC::MakeHeader(0x000F, 4, 0), &APT_U::CancelParameter, "CancelParameter"},
{0x001100C0, nullptr, "MapProgramIdForDebug"}, {IPC::MakeHeader(0x0010, 3, 2), nullptr, "DebugFunc"},
{0x00120040, nullptr, "SetHomeMenuAppletIdForDebug"}, {IPC::MakeHeader(0x0011, 3, 0), nullptr, "MapProgramIdForDebug"},
{0x00130000, nullptr, "GetPreparationState"}, {IPC::MakeHeader(0x0012, 1, 0), nullptr, "SetHomeMenuAppletIdForDebug"},
{0x00140040, nullptr, "SetPreparationState"}, {IPC::MakeHeader(0x0013, 0, 0), nullptr, "GetPreparationState"},
{0x00150140, &APT_U::PrepareToStartApplication, "PrepareToStartApplication"}, {IPC::MakeHeader(0x0014, 1, 0), nullptr, "SetPreparationState"},
{0x00160040, &APT_U::PreloadLibraryApplet, "PreloadLibraryApplet"}, {IPC::MakeHeader(0x0015, 5, 0), &APT_U::PrepareToStartApplication, "PrepareToStartApplication"},
{0x00170040, &APT_U::FinishPreloadingLibraryApplet, "FinishPreloadingLibraryApplet"}, {IPC::MakeHeader(0x0016, 1, 0), &APT_U::PreloadLibraryApplet, "PreloadLibraryApplet"},
{0x00180040, &APT_U::PrepareToStartLibraryApplet, "PrepareToStartLibraryApplet"}, {IPC::MakeHeader(0x0017, 1, 0), &APT_U::FinishPreloadingLibraryApplet, "FinishPreloadingLibraryApplet"},
{0x00190040, &APT_U::PrepareToStartSystemApplet, "PrepareToStartSystemApplet"}, {IPC::MakeHeader(0x0018, 1, 0), &APT_U::PrepareToStartLibraryApplet, "PrepareToStartLibraryApplet"},
{0x001A0000, &APT_U::PrepareToStartNewestHomeMenu, "PrepareToStartNewestHomeMenu"}, {IPC::MakeHeader(0x0019, 1, 0), &APT_U::PrepareToStartSystemApplet, "PrepareToStartSystemApplet"},
{0x001B00C4, &APT_U::StartApplication, "StartApplication"}, {IPC::MakeHeader(0x001A, 0, 0), &APT_U::PrepareToStartNewestHomeMenu, "PrepareToStartNewestHomeMenu"},
{0x001C0000, &APT_U::WakeupApplication, "WakeupApplication"}, {IPC::MakeHeader(0x001B, 3, 4), &APT_U::StartApplication, "StartApplication"},
{0x001D0000, nullptr, "CancelApplication"}, {IPC::MakeHeader(0x001C, 0, 0), &APT_U::WakeupApplication, "WakeupApplication"},
{0x001E0084, &APT_U::StartLibraryApplet, "StartLibraryApplet"}, {IPC::MakeHeader(0x001D, 0, 0), nullptr, "CancelApplication"},
{0x001F0084, &APT_U::StartSystemApplet, "StartSystemApplet"}, {IPC::MakeHeader(0x001E, 2, 4), &APT_U::StartLibraryApplet, "StartLibraryApplet"},
{0x00200044, nullptr, "StartNewestHomeMenu"}, {IPC::MakeHeader(0x001F, 2, 4), &APT_U::StartSystemApplet, "StartSystemApplet"},
{0x00210000, &APT_U::OrderToCloseApplication, "OrderToCloseApplication"}, {IPC::MakeHeader(0x0020, 1, 4), nullptr, "StartNewestHomeMenu"},
{0x00220040, &APT_U::PrepareToCloseApplication, "PrepareToCloseApplication"}, {IPC::MakeHeader(0x0021, 0, 0), &APT_U::OrderToCloseApplication, "OrderToCloseApplication"},
{0x00230040, nullptr, "PrepareToJumpToApplication"}, {IPC::MakeHeader(0x0022, 1, 0), &APT_U::PrepareToCloseApplication, "PrepareToCloseApplication"},
{0x00240044, nullptr, "JumpToApplication"}, {IPC::MakeHeader(0x0023, 1, 0), nullptr, "PrepareToJumpToApplication"},
{0x002500C0, &APT_U::PrepareToCloseLibraryApplet, "PrepareToCloseLibraryApplet"}, {IPC::MakeHeader(0x0024, 1, 4), nullptr, "JumpToApplication"},
{0x00260000, &APT_U::PrepareToCloseSystemApplet, "PrepareToCloseSystemApplet"}, {IPC::MakeHeader(0x0025, 3, 0), &APT_U::PrepareToCloseLibraryApplet, "PrepareToCloseLibraryApplet"},
{0x00270044, &APT_U::CloseApplication, "CloseApplication"}, {IPC::MakeHeader(0x0026, 0, 0), &APT_U::PrepareToCloseSystemApplet, "PrepareToCloseSystemApplet"},
{0x00280044, &APT_U::CloseLibraryApplet, "CloseLibraryApplet"}, {IPC::MakeHeader(0x0027, 1, 4), &APT_U::CloseApplication, "CloseApplication"},
{0x00290044, &APT_U::CloseSystemApplet, "CloseSystemApplet"}, {IPC::MakeHeader(0x0028, 1, 4), &APT_U::CloseLibraryApplet, "CloseLibraryApplet"},
{0x002A0000, &APT_U::OrderToCloseSystemApplet, "OrderToCloseSystemApplet"}, {IPC::MakeHeader(0x0029, 1, 4), &APT_U::CloseSystemApplet, "CloseSystemApplet"},
{0x002B0000, &APT_U::PrepareToJumpToHomeMenu, "PrepareToJumpToHomeMenu"}, {IPC::MakeHeader(0x002A, 0, 0), &APT_U::OrderToCloseSystemApplet, "OrderToCloseSystemApplet"},
{0x002C0044, &APT_U::JumpToHomeMenu, "JumpToHomeMenu"}, {IPC::MakeHeader(0x002B, 0, 0), &APT_U::PrepareToJumpToHomeMenu, "PrepareToJumpToHomeMenu"},
{0x002D0000, &APT_U::PrepareToLeaveHomeMenu, "PrepareToLeaveHomeMenu"}, {IPC::MakeHeader(0x002C, 1, 4), &APT_U::JumpToHomeMenu, "JumpToHomeMenu"},
{0x002E0044, &APT_U::LeaveHomeMenu, "LeaveHomeMenu"}, {IPC::MakeHeader(0x002D, 0, 0), &APT_U::PrepareToLeaveHomeMenu, "PrepareToLeaveHomeMenu"},
{0x002F0040, nullptr, "PrepareToLeaveResidentApplet"}, {IPC::MakeHeader(0x002E, 1, 4), &APT_U::LeaveHomeMenu, "LeaveHomeMenu"},
{0x00300044, nullptr, "LeaveResidentApplet"}, {IPC::MakeHeader(0x002F, 1, 0), nullptr, "PrepareToLeaveResidentApplet"},
{0x00310100, &APT_U::PrepareToDoApplicationJump, "PrepareToDoApplicationJump"}, {IPC::MakeHeader(0x0030, 1, 4), nullptr, "LeaveResidentApplet"},
{0x00320084, &APT_U::DoApplicationJump, "DoApplicationJump"}, {IPC::MakeHeader(0x0031, 4, 0), &APT_U::PrepareToDoApplicationJump, "PrepareToDoApplicationJump"},
{0x00330000, &APT_U::GetProgramIdOnApplicationJump, "GetProgramIdOnApplicationJump"}, {IPC::MakeHeader(0x0032, 2, 4), &APT_U::DoApplicationJump, "DoApplicationJump"},
{0x00340084, nullptr, "SendDeliverArg"}, {IPC::MakeHeader(0x0033, 0, 0), &APT_U::GetProgramIdOnApplicationJump, "GetProgramIdOnApplicationJump"},
{0x00350080, &APT_U::ReceiveDeliverArg, "ReceiveDeliverArg"}, {IPC::MakeHeader(0x0034, 2, 4), nullptr, "SendDeliverArg"},
{0x00360040, &APT_U::LoadSysMenuArg, "LoadSysMenuArg"}, {IPC::MakeHeader(0x0035, 2, 0), &APT_U::ReceiveDeliverArg, "ReceiveDeliverArg"},
{0x00370042, &APT_U::StoreSysMenuArg, "StoreSysMenuArg"}, {IPC::MakeHeader(0x0036, 1, 0), &APT_U::LoadSysMenuArg, "LoadSysMenuArg"},
{0x00380040, nullptr, "PreloadResidentApplet"}, {IPC::MakeHeader(0x0037, 1, 2), &APT_U::StoreSysMenuArg, "StoreSysMenuArg"},
{0x00390040, nullptr, "PrepareToStartResidentApplet"}, {IPC::MakeHeader(0x0038, 1, 0), nullptr, "PreloadResidentApplet"},
{0x003A0044, nullptr, "StartResidentApplet"}, {IPC::MakeHeader(0x0039, 1, 0), nullptr, "PrepareToStartResidentApplet"},
{0x003B0040, &APT_U::CancelLibraryApplet, "CancelLibraryApplet"}, {IPC::MakeHeader(0x003A, 1, 4), nullptr, "StartResidentApplet"},
{0x003C0042, nullptr, "SendDspSleep"}, {IPC::MakeHeader(0x003B, 1, 0), &APT_U::CancelLibraryApplet, "CancelLibraryApplet"},
{0x003D0042, nullptr, "SendDspWakeUp"}, {IPC::MakeHeader(0x003C, 1, 2), nullptr, "SendDspSleep"},
{0x003E0080, nullptr, "ReplySleepQuery"}, {IPC::MakeHeader(0x003D, 1, 2), nullptr, "SendDspWakeUp"},
{0x003F0040, nullptr, "ReplySleepNotificationComplete"}, {IPC::MakeHeader(0x003E, 2, 0), nullptr, "ReplySleepQuery"},
{0x00400042, &APT_U::SendCaptureBufferInfo, "SendCaptureBufferInfo"}, {IPC::MakeHeader(0x003F, 1, 0), nullptr, "ReplySleepNotificationComplete"},
{0x00410040, &APT_U::ReceiveCaptureBufferInfo, "ReceiveCaptureBufferInfo"}, {IPC::MakeHeader(0x0040, 1, 2), &APT_U::SendCaptureBufferInfo, "SendCaptureBufferInfo"},
{0x00420080, nullptr, "SleepSystem"}, {IPC::MakeHeader(0x0041, 1, 0), &APT_U::ReceiveCaptureBufferInfo, "ReceiveCaptureBufferInfo"},
{0x00430040, &APT_U::NotifyToWait, "NotifyToWait"}, {IPC::MakeHeader(0x0042, 2, 0), nullptr, "SleepSystem"},
{0x00440000, &APT_U::GetSharedFont, "GetSharedFont"}, {IPC::MakeHeader(0x0043, 1, 0), &APT_U::NotifyToWait, "NotifyToWait"},
{0x00450040, &APT_U::GetWirelessRebootInfo, "GetWirelessRebootInfo"}, {IPC::MakeHeader(0x0044, 0, 0), &APT_U::GetSharedFont, "GetSharedFont"},
{0x00460104, &APT_U::Wrap, "Wrap"}, {IPC::MakeHeader(0x0045, 1, 0), &APT_U::GetWirelessRebootInfo, "GetWirelessRebootInfo"},
{0x00470104, &APT_U::Unwrap, "Unwrap"}, {IPC::MakeHeader(0x0046, 4, 4), &APT_U::Wrap, "Wrap"},
{0x00480100, nullptr, "GetProgramInfo"}, {IPC::MakeHeader(0x0047, 4, 4), &APT_U::Unwrap, "Unwrap"},
{0x00490180, nullptr, "Reboot"}, {IPC::MakeHeader(0x0048, 4, 0), nullptr, "GetProgramInfo"},
{0x004A0040, &APT_U::GetCaptureInfo, "GetCaptureInfo"}, {IPC::MakeHeader(0x0049, 6, 0), nullptr, "Reboot"},
{0x004B00C2, &APT_U::AppletUtility, "AppletUtility"}, {IPC::MakeHeader(0x004A, 1, 0), &APT_U::GetCaptureInfo, "GetCaptureInfo"},
{0x004C0000, nullptr, "SetFatalErrDispMode"}, {IPC::MakeHeader(0x004B, 3, 2), &APT_U::AppletUtility, "AppletUtility"},
{0x004D0080, nullptr, "GetAppletProgramInfo"}, {IPC::MakeHeader(0x004C, 0, 0), nullptr, "SetFatalErrDispMode"},
{0x004E0000, nullptr, "HardwareResetAsync"}, {IPC::MakeHeader(0x004D, 2, 0), nullptr, "GetAppletProgramInfo"},
{0x004F0080, &APT_U::SetAppCpuTimeLimit, "SetAppCpuTimeLimit"}, {IPC::MakeHeader(0x004E, 0, 0), nullptr, "HardwareResetAsync"},
{0x00500040, &APT_U::GetAppCpuTimeLimit, "GetAppCpuTimeLimit"}, {IPC::MakeHeader(0x004F, 2, 0), &APT_U::SetAppCpuTimeLimit, "SetAppCpuTimeLimit"},
{0x00510080, &APT_U::GetStartupArgument, "GetStartupArgument"}, {IPC::MakeHeader(0x0050, 1, 0), &APT_U::GetAppCpuTimeLimit, "GetAppCpuTimeLimit"},
{0x00520104, nullptr, "Wrap1"}, {IPC::MakeHeader(0x0051, 2, 0), &APT_U::GetStartupArgument, "GetStartupArgument"},
{0x00530104, nullptr, "Unwrap1"}, {IPC::MakeHeader(0x0052, 4, 4), nullptr, "Wrap1"},
{0x00550040, &APT_U::SetScreenCapPostPermission, "SetScreenCapPostPermission"}, {IPC::MakeHeader(0x0053, 4, 4), nullptr, "Unwrap1"},
{0x00560000, &APT_U::GetScreenCapPostPermission, "GetScreenCapPostPermission"}, {IPC::MakeHeader(0x0055, 1, 0), &APT_U::SetScreenCapPostPermission, "SetScreenCapPostPermission"},
{0x00570044, nullptr, "WakeupApplication2"}, {IPC::MakeHeader(0x0056, 0, 0), &APT_U::GetScreenCapPostPermission, "GetScreenCapPostPermission"},
{0x00580002, nullptr, "GetProgramID"}, {IPC::MakeHeader(0x0057, 1, 4), nullptr, "WakeupApplication2"},
{0x01010000, &APT_U::CheckNew3DSApp, "CheckNew3DSApp"}, {IPC::MakeHeader(0x0058, 0, 2), nullptr, "GetProgramID"},
{0x01020000, &APT_U::CheckNew3DS, "CheckNew3DS"}, {IPC::MakeHeader(0x0101, 0, 0), &APT_U::CheckNew3DSApp, "CheckNew3DSApp"},
{0x01030000, &APT_U::Unknown0x0103, "Unknown0x0103"}, {IPC::MakeHeader(0x0102, 0, 0), &APT_U::CheckNew3DS, "CheckNew3DS"},
{0x01040000, nullptr, "IsStandardMemoryLayout"}, {IPC::MakeHeader(0x0103, 0, 0), &APT_U::Unknown0x0103, "Unknown0x0103"},
{0x01050100, &APT_U::IsTitleAllowed, "IsTitleAllowed"}, {IPC::MakeHeader(0x0104, 0, 0), nullptr, "IsStandardMemoryLayout"},
{IPC::MakeHeader(0x0105, 4, 0), &APT_U::IsTitleAllowed, "IsTitleAllowed"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

6
src/core/hle/service/apt/ns_c.cpp
View File

@@ -10,8 +10,10 @@ namespace Service::NS {
NS_C::NS_C(std::shared_ptr<Service::APT::Module> apt) NS_C::NS_C(std::shared_ptr<Service::APT::Module> apt)
: Service::APT::Module::NSInterface(std::move(apt), "ns:c", 1) { : Service::APT::Module::NSInterface(std::move(apt), "ns:c", 1) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x00010100, nullptr, "LockSpecialContent"}, // clang-format off
{0x00020100, nullptr, "UnlockSpecialContent"}, {IPC::MakeHeader(0x0001, 4, 0), nullptr, "LockSpecialContent"},
{IPC::MakeHeader(0x0002, 4, 0), nullptr, "UnlockSpecialContent"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

32
src/core/hle/service/apt/ns_s.cpp
View File

@@ -10,21 +10,23 @@ namespace Service::NS {
NS_S::NS_S(std::shared_ptr<Service::APT::Module> apt) NS_S::NS_S(std::shared_ptr<Service::APT::Module> apt)
: Service::APT::Module::NSInterface(std::move(apt), "ns:s", 3) { : Service::APT::Module::NSInterface(std::move(apt), "ns:s", 3) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x000100C0, nullptr, "LaunchFIRM"}, // clang-format off
{0x000200C0, nullptr, "LaunchTitle"}, {IPC::MakeHeader(0x0001, 3, 0), nullptr, "LaunchFIRM"},
{0x00030000, nullptr, "TerminateApplication"}, {IPC::MakeHeader(0x0002, 3, 0), nullptr, "LaunchTitle"},
{0x00040040, nullptr, "TerminateProcess"}, {IPC::MakeHeader(0x0003, 0, 0), nullptr, "TerminateApplication"},
{0x000500C0, nullptr, "LaunchApplicationFIRM"}, {IPC::MakeHeader(0x0004, 1, 0), nullptr, "TerminateProcess"},
{0x00060042, &NS_S::SetWirelessRebootInfo, "SetWirelessRebootInfo"}, {IPC::MakeHeader(0x0005, 3, 0), nullptr, "LaunchApplicationFIRM"},
{0x00070042, nullptr, "CardUpdateInitialize"}, {IPC::MakeHeader(0x0006, 1, 2), &NS_S::SetWirelessRebootInfo, "SetWirelessRebootInfo"},
{0x00080000, nullptr, "CardUpdateShutdown"}, {IPC::MakeHeader(0x0007, 1, 2), nullptr, "CardUpdateInitialize"},
{0x000D0140, nullptr, "SetTWLBannerHMAC"}, {IPC::MakeHeader(0x0008, 0, 0), nullptr, "CardUpdateShutdown"},
{0x000E0000, &NS_S::ShutdownAsync, "ShutdownAsync"}, {IPC::MakeHeader(0x000D, 5, 0), nullptr, "SetTWLBannerHMAC"},
{0x00100180, &NS_S::RebootSystem, "RebootSystem"}, {IPC::MakeHeader(0x000E, 0, 0), &NS_S::ShutdownAsync, "ShutdownAsync"},
{0x00110100, nullptr, "TerminateTitle"}, {IPC::MakeHeader(0x0010, 6, 0), &NS_S::RebootSystem, "RebootSystem"},
{0x001200C0, nullptr, "SetApplicationCpuTimeLimit"}, {IPC::MakeHeader(0x0011, 4, 0), nullptr, "TerminateTitle"},
{0x00150140, nullptr, "LaunchApplication"}, {IPC::MakeHeader(0x0012, 3, 0), nullptr, "SetApplicationCpuTimeLimit"},
{0x00160000, &NS_S::RebootSystemClean, "RebootSystemClean"}, {IPC::MakeHeader(0x0015, 5, 0), nullptr, "LaunchApplication"},
{IPC::MakeHeader(0x0016, 0, 0), &NS_S::RebootSystemClean, "RebootSystemClean"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

130
src/core/hle/service/boss/boss_p.cpp
View File

@@ -12,72 +12,72 @@ BOSS_P::BOSS_P(std::shared_ptr<Module> boss)
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
// boss:u shared commands // boss:u shared commands
// clang-format off // clang-format off
{0x00010082, &BOSS_P::InitializeSession, "InitializeSession"}, {IPC::MakeHeader(0x0001, 2, 2), &BOSS_P::InitializeSession, "InitializeSession"},
{0x00020100, &BOSS_P::SetStorageInfo, "RegisterStorage"}, {IPC::MakeHeader(0x0002, 4, 0), &BOSS_P::SetStorageInfo, "RegisterStorage"},
{0x00030000, &BOSS_P::UnregisterStorage, "UnregisterStorage"}, {IPC::MakeHeader(0x0003, 0, 0), &BOSS_P::UnregisterStorage, "UnregisterStorage"},
{0x00040000, &BOSS_P::GetStorageInfo, "GetStorageInfo"}, {IPC::MakeHeader(0x0004, 0, 0), &BOSS_P::GetStorageInfo, "GetStorageInfo"},
{0x00050042, &BOSS_P::RegisterPrivateRootCa, "RegisterPrivateRootCa"}, {IPC::MakeHeader(0x0005, 1, 2), &BOSS_P::RegisterPrivateRootCa, "RegisterPrivateRootCa"},
{0x00060084, &BOSS_P::RegisterPrivateClientCert, "RegisterPrivateClientCert"}, {IPC::MakeHeader(0x0006, 2, 4), &BOSS_P::RegisterPrivateClientCert, "RegisterPrivateClientCert"},
{0x00070000, &BOSS_P::GetNewArrivalFlag, "GetNewArrivalFlag"}, {IPC::MakeHeader(0x0007, 0, 0), &BOSS_P::GetNewArrivalFlag, "GetNewArrivalFlag"},
{0x00080002, &BOSS_P::RegisterNewArrivalEvent, "RegisterNewArrivalEvent"}, {IPC::MakeHeader(0x0008, 0, 2), &BOSS_P::RegisterNewArrivalEvent, "RegisterNewArrivalEvent"},
{0x00090040, &BOSS_P::SetOptoutFlag, "SetOptoutFlag"}, {IPC::MakeHeader(0x0009, 1, 0), &BOSS_P::SetOptoutFlag, "SetOptoutFlag"},
{0x000A0000, &BOSS_P::GetOptoutFlag, "GetOptoutFlag"}, {IPC::MakeHeader(0x000A, 0, 0), &BOSS_P::GetOptoutFlag, "GetOptoutFlag"},
{0x000B00C2, &BOSS_P::RegisterTask, "RegisterTask"}, {IPC::MakeHeader(0x000B, 3, 2), &BOSS_P::RegisterTask, "RegisterTask"},
{0x000C0082, &BOSS_P::UnregisterTask, "UnregisterTask"}, {IPC::MakeHeader(0x000C, 2, 2), &BOSS_P::UnregisterTask, "UnregisterTask"},
{0x000D0082, &BOSS_P::ReconfigureTask, "ReconfigureTask"}, {IPC::MakeHeader(0x000D, 2, 2), &BOSS_P::ReconfigureTask, "ReconfigureTask"},
{0x000E0000, &BOSS_P::GetTaskIdList, "GetTaskIdList"}, {IPC::MakeHeader(0x000E, 0, 0), &BOSS_P::GetTaskIdList, "GetTaskIdList"},
{0x000F0042, &BOSS_P::GetStepIdList, "GetStepIdList"}, {IPC::MakeHeader(0x000F, 1, 2), &BOSS_P::GetStepIdList, "GetStepIdList"},
{0x00100102, &BOSS_P::GetNsDataIdList, "GetNsDataIdList"}, {IPC::MakeHeader(0x0010, 4, 2), &BOSS_P::GetNsDataIdList, "GetNsDataIdList"},
{0x00110102, &BOSS_P::GetNsDataIdList1, "GetNsDataIdList1"}, {IPC::MakeHeader(0x0011, 4, 2), &BOSS_P::GetNsDataIdList1, "GetNsDataIdList1"},
{0x00120102, &BOSS_P::GetNsDataIdList2, "GetNsDataIdList2"}, {IPC::MakeHeader(0x0012, 4, 2), &BOSS_P::GetNsDataIdList2, "GetNsDataIdList2"},
{0x00130102, &BOSS_P::GetNsDataIdList3, "GetNsDataIdList3"}, {IPC::MakeHeader(0x0013, 4, 2), &BOSS_P::GetNsDataIdList3, "GetNsDataIdList3"},
{0x00140082, &BOSS_P::SendProperty, "SendProperty"}, {IPC::MakeHeader(0x0014, 2, 2), &BOSS_P::SendProperty, "SendProperty"},
{0x00150042, &BOSS_P::SendPropertyHandle, "SendPropertyHandle"}, {IPC::MakeHeader(0x0015, 1, 2), &BOSS_P::SendPropertyHandle, "SendPropertyHandle"},
{0x00160082, &BOSS_P::ReceiveProperty, "ReceiveProperty"}, {IPC::MakeHeader(0x0016, 2, 2), &BOSS_P::ReceiveProperty, "ReceiveProperty"},
{0x00170082, &BOSS_P::UpdateTaskInterval, "UpdateTaskInterval"}, {IPC::MakeHeader(0x0017, 2, 2), &BOSS_P::UpdateTaskInterval, "UpdateTaskInterval"},
{0x00180082, &BOSS_P::UpdateTaskCount, "UpdateTaskCount"}, {IPC::MakeHeader(0x0018, 2, 2), &BOSS_P::UpdateTaskCount, "UpdateTaskCount"},
{0x00190042, &BOSS_P::GetTaskInterval, "GetTaskInterval"}, {IPC::MakeHeader(0x0019, 1, 2), &BOSS_P::GetTaskInterval, "GetTaskInterval"},
{0x001A0042, &BOSS_P::GetTaskCount, "GetTaskCount"}, {IPC::MakeHeader(0x001A, 1, 2), &BOSS_P::GetTaskCount, "GetTaskCount"},
{0x001B0042, &BOSS_P::GetTaskServiceStatus, "GetTaskServiceStatus"}, {IPC::MakeHeader(0x001B, 1, 2), &BOSS_P::GetTaskServiceStatus, "GetTaskServiceStatus"},
{0x001C0042, &BOSS_P::StartTask, "StartTask"}, {IPC::MakeHeader(0x001C, 1, 2), &BOSS_P::StartTask, "StartTask"},
{0x001D0042, &BOSS_P::StartTaskImmediate, "StartTaskImmediate"}, {IPC::MakeHeader(0x001D, 1, 2), &BOSS_P::StartTaskImmediate, "StartTaskImmediate"},
{0x001E0042, &BOSS_P::CancelTask, "CancelTask"}, {IPC::MakeHeader(0x001E, 1, 2), &BOSS_P::CancelTask, "CancelTask"},
{0x001F0000, &BOSS_P::GetTaskFinishHandle, "GetTaskFinishHandle"}, {IPC::MakeHeader(0x001F, 0, 0), &BOSS_P::GetTaskFinishHandle, "GetTaskFinishHandle"},
{0x00200082, &BOSS_P::GetTaskState, "GetTaskState"}, {IPC::MakeHeader(0x0020, 2, 2), &BOSS_P::GetTaskState, "GetTaskState"},
{0x00210042, &BOSS_P::GetTaskResult, "GetTaskResult"}, {IPC::MakeHeader(0x0021, 1, 2), &BOSS_P::GetTaskResult, "GetTaskResult"},
{0x00220042, &BOSS_P::GetTaskCommErrorCode, "GetTaskCommErrorCode"}, {IPC::MakeHeader(0x0022, 1, 2), &BOSS_P::GetTaskCommErrorCode, "GetTaskCommErrorCode"},
{0x002300C2, &BOSS_P::GetTaskStatus, "GetTaskStatus"}, {IPC::MakeHeader(0x0023, 3, 2), &BOSS_P::GetTaskStatus, "GetTaskStatus"},
{0x00240082, &BOSS_P::GetTaskError, "GetTaskError"}, {IPC::MakeHeader(0x0024, 2, 2), &BOSS_P::GetTaskError, "GetTaskError"},
{0x00250082, &BOSS_P::GetTaskInfo, "GetTaskInfo"}, {IPC::MakeHeader(0x0025, 2, 2), &BOSS_P::GetTaskInfo, "GetTaskInfo"},
{0x00260040, &BOSS_P::DeleteNsData, "DeleteNsData"}, {IPC::MakeHeader(0x0026, 1, 0), &BOSS_P::DeleteNsData, "DeleteNsData"},
{0x002700C2, &BOSS_P::GetNsDataHeaderInfo, "GetNsDataHeaderInfo"}, {IPC::MakeHeader(0x0027, 3, 2), &BOSS_P::GetNsDataHeaderInfo, "GetNsDataHeaderInfo"},
{0x00280102, &BOSS_P::ReadNsData, "ReadNsData"}, {IPC::MakeHeader(0x0028, 4, 2), &BOSS_P::ReadNsData, "ReadNsData"},
{0x00290080, &BOSS_P::SetNsDataAdditionalInfo, "SetNsDataAdditionalInfo"}, {IPC::MakeHeader(0x0029, 2, 0), &BOSS_P::SetNsDataAdditionalInfo, "SetNsDataAdditionalInfo"},
{0x002A0040, &BOSS_P::GetNsDataAdditionalInfo, "GetNsDataAdditionalInfo"}, {IPC::MakeHeader(0x002A, 1, 0), &BOSS_P::GetNsDataAdditionalInfo, "GetNsDataAdditionalInfo"},
{0x002B0080, &BOSS_P::SetNsDataNewFlag, "SetNsDataNewFlag"}, {IPC::MakeHeader(0x002B, 2, 0), &BOSS_P::SetNsDataNewFlag, "SetNsDataNewFlag"},
{0x002C0040, &BOSS_P::GetNsDataNewFlag, "GetNsDataNewFlag"}, {IPC::MakeHeader(0x002C, 1, 0), &BOSS_P::GetNsDataNewFlag, "GetNsDataNewFlag"},
{0x002D0040, &BOSS_P::GetNsDataLastUpdate, "GetNsDataLastUpdate"}, {IPC::MakeHeader(0x002D, 1, 0), &BOSS_P::GetNsDataLastUpdate, "GetNsDataLastUpdate"},
{0x002E0040, &BOSS_P::GetErrorCode, "GetErrorCode"}, {IPC::MakeHeader(0x002E, 1, 0), &BOSS_P::GetErrorCode, "GetErrorCode"},
{0x002F0140, &BOSS_P::RegisterStorageEntry, "RegisterStorageEntry"}, {IPC::MakeHeader(0x002F, 5, 0), &BOSS_P::RegisterStorageEntry, "RegisterStorageEntry"},
{0x00300000, &BOSS_P::GetStorageEntryInfo, "GetStorageEntryInfo"}, {IPC::MakeHeader(0x0030, 0, 0), &BOSS_P::GetStorageEntryInfo, "GetStorageEntryInfo"},
{0x00310100, &BOSS_P::SetStorageOption, "SetStorageOption"}, {IPC::MakeHeader(0x0031, 4, 0), &BOSS_P::SetStorageOption, "SetStorageOption"},
{0x00320000, &BOSS_P::GetStorageOption, "GetStorageOption"}, {IPC::MakeHeader(0x0032, 0, 0), &BOSS_P::GetStorageOption, "GetStorageOption"},
{0x00330042, &BOSS_P::StartBgImmediate, "StartBgImmediate"}, {IPC::MakeHeader(0x0033, 1, 2), &BOSS_P::StartBgImmediate, "StartBgImmediate"},
{0x00340042, &BOSS_P::GetTaskProperty0, "GetTaskProperty0"}, {IPC::MakeHeader(0x0034, 1, 2), &BOSS_P::GetTaskProperty0, "GetTaskProperty0"},
{0x003500C2, &BOSS_P::RegisterImmediateTask, "RegisterImmediateTask"}, {IPC::MakeHeader(0x0035, 3, 2), &BOSS_P::RegisterImmediateTask, "RegisterImmediateTask"},
{0x00360084, &BOSS_P::SetTaskQuery, "SetTaskQuery"}, {IPC::MakeHeader(0x0036, 2, 4), &BOSS_P::SetTaskQuery, "SetTaskQuery"},
{0x00370084, &BOSS_P::GetTaskQuery, "GetTaskQuery"}, {IPC::MakeHeader(0x0037, 2, 4), &BOSS_P::GetTaskQuery, "GetTaskQuery"},
// boss:p // boss:p
{0x04010082, &BOSS_P::InitializeSessionPrivileged, "InitializeSessionPrivileged"}, {IPC::MakeHeader(0x0401, 2, 2), &BOSS_P::InitializeSessionPrivileged, "InitializeSessionPrivileged"},
{0x04040080, &BOSS_P::GetAppNewFlag, "GetAppNewFlag"}, {IPC::MakeHeader(0x0404, 2, 0), &BOSS_P::GetAppNewFlag, "GetAppNewFlag"},
{0x040D0182, &BOSS_P::GetNsDataIdListPrivileged, "GetNsDataIdListPrivileged"}, {IPC::MakeHeader(0x040D, 6, 2), &BOSS_P::GetNsDataIdListPrivileged, "GetNsDataIdListPrivileged"},
{0x040E0182, &BOSS_P::GetNsDataIdListPrivileged1, "GetNsDataIdListPrivileged1"}, {IPC::MakeHeader(0x040E, 6, 2), &BOSS_P::GetNsDataIdListPrivileged1, "GetNsDataIdListPrivileged1"},
{0x04130082, &BOSS_P::SendPropertyPrivileged, "SendPropertyPrivileged"}, {IPC::MakeHeader(0x0413, 2, 2), &BOSS_P::SendPropertyPrivileged, "SendPropertyPrivileged"},
{0x041500C0, &BOSS_P::DeleteNsDataPrivileged, "DeleteNsDataPrivileged"}, {IPC::MakeHeader(0x0415, 3, 0), &BOSS_P::DeleteNsDataPrivileged, "DeleteNsDataPrivileged"},
{0x04160142, &BOSS_P::GetNsDataHeaderInfoPrivileged, "GetNsDataHeaderInfoPrivileged"}, {IPC::MakeHeader(0x0416, 5, 2), &BOSS_P::GetNsDataHeaderInfoPrivileged, "GetNsDataHeaderInfoPrivileged"},
{0x04170182, &BOSS_P::ReadNsDataPrivileged, "ReadNsDataPrivileged"}, {IPC::MakeHeader(0x0417, 6, 2), &BOSS_P::ReadNsDataPrivileged, "ReadNsDataPrivileged"},
{0x041A0100, &BOSS_P::SetNsDataNewFlagPrivileged, "SetNsDataNewFlagPrivileged"}, {IPC::MakeHeader(0x041A, 4, 0), &BOSS_P::SetNsDataNewFlagPrivileged, "SetNsDataNewFlagPrivileged"},
{0x041B00C0, &BOSS_P::GetNsDataNewFlagPrivileged, "GetNsDataNewFlagPrivileged"}, {IPC::MakeHeader(0x041B, 3, 0), &BOSS_P::GetNsDataNewFlagPrivileged, "GetNsDataNewFlagPrivileged"},
// clang-format on // clang-format on
}; };

110
src/core/hle/service/boss/boss_u.cpp
View File

@@ -11,61 +11,61 @@ BOSS_U::BOSS_U(std::shared_ptr<Module> boss)
: Module::Interface(std::move(boss), "boss:U", DefaultMaxSessions) { : Module::Interface(std::move(boss), "boss:U", DefaultMaxSessions) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
// clang-format off // clang-format off
{0x00010082, &BOSS_U::InitializeSession, "InitializeSession"}, {IPC::MakeHeader(0x0001, 2, 2), &BOSS_U::InitializeSession, "InitializeSession"},
{0x00020100, &BOSS_U::SetStorageInfo, "SetStorageInfo"}, {IPC::MakeHeader(0x0002, 4, 0), &BOSS_U::SetStorageInfo, "SetStorageInfo"},
{0x00030000, &BOSS_U::UnregisterStorage, "UnregisterStorage"}, {IPC::MakeHeader(0x0003, 0, 0), &BOSS_U::UnregisterStorage, "UnregisterStorage"},
{0x00040000, &BOSS_U::GetStorageInfo, "GetStorageInfo"}, {IPC::MakeHeader(0x0004, 0, 0), &BOSS_U::GetStorageInfo, "GetStorageInfo"},
{0x00050042, &BOSS_U::RegisterPrivateRootCa, "RegisterPrivateRootCa"}, {IPC::MakeHeader(0x0005, 1, 2), &BOSS_U::RegisterPrivateRootCa, "RegisterPrivateRootCa"},
{0x00060084, &BOSS_U::RegisterPrivateClientCert, "RegisterPrivateClientCert"}, {IPC::MakeHeader(0x0006, 2, 4), &BOSS_U::RegisterPrivateClientCert, "RegisterPrivateClientCert"},
{0x00070000, &BOSS_U::GetNewArrivalFlag, "GetNewArrivalFlag"}, {IPC::MakeHeader(0x0007, 0, 0), &BOSS_U::GetNewArrivalFlag, "GetNewArrivalFlag"},
{0x00080002, &BOSS_U::RegisterNewArrivalEvent, "RegisterNewArrivalEvent"}, {IPC::MakeHeader(0x0008, 0, 2), &BOSS_U::RegisterNewArrivalEvent, "RegisterNewArrivalEvent"},
{0x00090040, &BOSS_U::SetOptoutFlag, "SetOptoutFlag"}, {IPC::MakeHeader(0x0009, 1, 0), &BOSS_U::SetOptoutFlag, "SetOptoutFlag"},
{0x000A0000, &BOSS_U::GetOptoutFlag, "GetOptoutFlag"}, {IPC::MakeHeader(0x000A, 0, 0), &BOSS_U::GetOptoutFlag, "GetOptoutFlag"},
{0x000B00C2, &BOSS_U::RegisterTask, "RegisterTask"}, {IPC::MakeHeader(0x000B, 3, 2), &BOSS_U::RegisterTask, "RegisterTask"},
{0x000C0082, &BOSS_U::UnregisterTask, "UnregisterTask"}, {IPC::MakeHeader(0x000C, 2, 2), &BOSS_U::UnregisterTask, "UnregisterTask"},
{0x000D0082, &BOSS_U::ReconfigureTask, "ReconfigureTask"}, {IPC::MakeHeader(0x000D, 2, 2), &BOSS_U::ReconfigureTask, "ReconfigureTask"},
{0x000E0000, &BOSS_U::GetTaskIdList, "GetTaskIdList"}, {IPC::MakeHeader(0x000E, 0, 0), &BOSS_U::GetTaskIdList, "GetTaskIdList"},
{0x000F0042, &BOSS_U::GetStepIdList, "GetStepIdList"}, {IPC::MakeHeader(0x000F, 1, 2), &BOSS_U::GetStepIdList, "GetStepIdList"},
{0x00100102, &BOSS_U::GetNsDataIdList, "GetNsDataIdList"}, {IPC::MakeHeader(0x0010, 4, 2), &BOSS_U::GetNsDataIdList, "GetNsDataIdList"},
{0x00110102, &BOSS_U::GetNsDataIdList1, "GetNsDataIdList1"}, {IPC::MakeHeader(0x0011, 4, 2), &BOSS_U::GetNsDataIdList1, "GetNsDataIdList1"},
{0x00120102, &BOSS_U::GetNsDataIdList2, "GetNsDataIdList2"}, {IPC::MakeHeader(0x0012, 4, 2), &BOSS_U::GetNsDataIdList2, "GetNsDataIdList2"},
{0x00130102, &BOSS_U::GetNsDataIdList3, "GetNsDataIdList3"}, {IPC::MakeHeader(0x0013, 4, 2), &BOSS_U::GetNsDataIdList3, "GetNsDataIdList3"},
{0x00140082, &BOSS_U::SendProperty, "SendProperty"}, {IPC::MakeHeader(0x0014, 2, 2), &BOSS_U::SendProperty, "SendProperty"},
{0x00150042, &BOSS_U::SendPropertyHandle, "SendPropertyHandle"}, {IPC::MakeHeader(0x0015, 1, 2), &BOSS_U::SendPropertyHandle, "SendPropertyHandle"},
{0x00160082, &BOSS_U::ReceiveProperty, "ReceiveProperty"}, {IPC::MakeHeader(0x0016, 2, 2), &BOSS_U::ReceiveProperty, "ReceiveProperty"},
{0x00170082, &BOSS_U::UpdateTaskInterval, "UpdateTaskInterval"}, {IPC::MakeHeader(0x0017, 2, 2), &BOSS_U::UpdateTaskInterval, "UpdateTaskInterval"},
{0x00180082, &BOSS_U::UpdateTaskCount, "UpdateTaskCount"}, {IPC::MakeHeader(0x0018, 2, 2), &BOSS_U::UpdateTaskCount, "UpdateTaskCount"},
{0x00190042, &BOSS_U::GetTaskInterval, "GetTaskInterval"}, {IPC::MakeHeader(0x0019, 1, 2), &BOSS_U::GetTaskInterval, "GetTaskInterval"},
{0x001A0042, &BOSS_U::GetTaskCount, "GetTaskCount"}, {IPC::MakeHeader(0x001A, 1, 2), &BOSS_U::GetTaskCount, "GetTaskCount"},
{0x001B0042, &BOSS_U::GetTaskServiceStatus, "GetTaskServiceStatus"}, {IPC::MakeHeader(0x001B, 1, 2), &BOSS_U::GetTaskServiceStatus, "GetTaskServiceStatus"},
{0x001C0042, &BOSS_U::StartTask, "StartTask"}, {IPC::MakeHeader(0x001C, 1, 2), &BOSS_U::StartTask, "StartTask"},
{0x001D0042, &BOSS_U::StartTaskImmediate, "StartTaskImmediate"}, {IPC::MakeHeader(0x001D, 1, 2), &BOSS_U::StartTaskImmediate, "StartTaskImmediate"},
{0x001E0042, &BOSS_U::CancelTask, "CancelTask"}, {IPC::MakeHeader(0x001E, 1, 2), &BOSS_U::CancelTask, "CancelTask"},
{0x001F0000, &BOSS_U::GetTaskFinishHandle, "GetTaskFinishHandle"}, {IPC::MakeHeader(0x001F, 0, 0), &BOSS_U::GetTaskFinishHandle, "GetTaskFinishHandle"},
{0x00200082, &BOSS_U::GetTaskState, "GetTaskState"}, {IPC::MakeHeader(0x0020, 2, 2), &BOSS_U::GetTaskState, "GetTaskState"},
{0x00210042, &BOSS_U::GetTaskResult, "GetTaskResult"}, {IPC::MakeHeader(0x0021, 1, 2), &BOSS_U::GetTaskResult, "GetTaskResult"},
{0x00220042, &BOSS_U::GetTaskCommErrorCode, "GetTaskCommErrorCode"}, {IPC::MakeHeader(0x0022, 1, 2), &BOSS_U::GetTaskCommErrorCode, "GetTaskCommErrorCode"},
{0x002300C2, &BOSS_U::GetTaskStatus, "GetTaskStatus"}, {IPC::MakeHeader(0x0023, 3, 2), &BOSS_U::GetTaskStatus, "GetTaskStatus"},
{0x00240082, &BOSS_U::GetTaskError, "GetTaskError"}, {IPC::MakeHeader(0x0024, 2, 2), &BOSS_U::GetTaskError, "GetTaskError"},
{0x00250082, &BOSS_U::GetTaskInfo, "GetTaskInfo"}, {IPC::MakeHeader(0x0025, 2, 2), &BOSS_U::GetTaskInfo, "GetTaskInfo"},
{0x00260040, &BOSS_U::DeleteNsData, "DeleteNsData"}, {IPC::MakeHeader(0x0026, 1, 0), &BOSS_U::DeleteNsData, "DeleteNsData"},
{0x002700C2, &BOSS_U::GetNsDataHeaderInfo, "GetNsDataHeaderInfo"}, {IPC::MakeHeader(0x0027, 3, 2), &BOSS_U::GetNsDataHeaderInfo, "GetNsDataHeaderInfo"},
{0x00280102, &BOSS_U::ReadNsData, "ReadNsData"}, {IPC::MakeHeader(0x0028, 4, 2), &BOSS_U::ReadNsData, "ReadNsData"},
{0x00290080, &BOSS_U::SetNsDataAdditionalInfo, "SetNsDataAdditionalInfo"}, {IPC::MakeHeader(0x0029, 2, 0), &BOSS_U::SetNsDataAdditionalInfo, "SetNsDataAdditionalInfo"},
{0x002A0040, &BOSS_U::GetNsDataAdditionalInfo, "GetNsDataAdditionalInfo"}, {IPC::MakeHeader(0x002A, 1, 0), &BOSS_U::GetNsDataAdditionalInfo, "GetNsDataAdditionalInfo"},
{0x002B0080, &BOSS_U::SetNsDataNewFlag, "SetNsDataNewFlag"}, {IPC::MakeHeader(0x002B, 2, 0), &BOSS_U::SetNsDataNewFlag, "SetNsDataNewFlag"},
{0x002C0040, &BOSS_U::GetNsDataNewFlag, "GetNsDataNewFlag"}, {IPC::MakeHeader(0x002C, 1, 0), &BOSS_U::GetNsDataNewFlag, "GetNsDataNewFlag"},
{0x002D0040, &BOSS_U::GetNsDataLastUpdate, "GetNsDataLastUpdate"}, {IPC::MakeHeader(0x002D, 1, 0), &BOSS_U::GetNsDataLastUpdate, "GetNsDataLastUpdate"},
{0x002E0040, &BOSS_U::GetErrorCode, "GetErrorCode"}, {IPC::MakeHeader(0x002E, 1, 0), &BOSS_U::GetErrorCode, "GetErrorCode"},
{0x002F0140, &BOSS_U::RegisterStorageEntry, "RegisterStorageEntry"}, {IPC::MakeHeader(0x002F, 5, 0), &BOSS_U::RegisterStorageEntry, "RegisterStorageEntry"},
{0x00300000, &BOSS_U::GetStorageEntryInfo, "GetStorageEntryInfo"}, {IPC::MakeHeader(0x0030, 0, 0), &BOSS_U::GetStorageEntryInfo, "GetStorageEntryInfo"},
{0x00310100, &BOSS_U::SetStorageOption, "SetStorageOption"}, {IPC::MakeHeader(0x0031, 4, 0), &BOSS_U::SetStorageOption, "SetStorageOption"},
{0x00320000, &BOSS_U::GetStorageOption, "GetStorageOption"}, {IPC::MakeHeader(0x0032, 0, 0), &BOSS_U::GetStorageOption, "GetStorageOption"},
{0x00330042, &BOSS_U::StartBgImmediate, "StartBgImmediate"}, {IPC::MakeHeader(0x0033, 1, 2), &BOSS_U::StartBgImmediate, "StartBgImmediate"},
{0x00340042, &BOSS_U::GetTaskProperty0, "GetTaskProperty0"}, {IPC::MakeHeader(0x0034, 1, 2), &BOSS_U::GetTaskProperty0, "GetTaskProperty0"},
{0x003500C2, &BOSS_U::RegisterImmediateTask, "RegisterImmediateTask"}, {IPC::MakeHeader(0x0035, 3, 2), &BOSS_U::RegisterImmediateTask, "RegisterImmediateTask"},
{0x00360084, &BOSS_U::SetTaskQuery, "SetTaskQuery"}, {IPC::MakeHeader(0x0036, 2, 4), &BOSS_U::SetTaskQuery, "SetTaskQuery"},
{0x00370084, &BOSS_U::GetTaskQuery, "GetTaskQuery"}, {IPC::MakeHeader(0x0037, 2, 4), &BOSS_U::GetTaskQuery, "GetTaskQuery"},
// clang-format on // clang-format on
}; };

129
src/core/hle/service/cam/cam_c.cpp
View File

@@ -10,71 +10,70 @@ namespace Service::CAM {
CAM_C::CAM_C(std::shared_ptr<Module> cam) : Module::Interface(std::move(cam), "cam:c", 1) { CAM_C::CAM_C(std::shared_ptr<Module> cam) : Module::Interface(std::move(cam), "cam:c", 1) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x00010040, &CAM_C::StartCapture, "StartCapture"}, // clang-format off
{0x00020040, &CAM_C::StopCapture, "StopCapture"}, {IPC::MakeHeader(0x0001, 1, 0), &CAM_C::StartCapture, "StartCapture"},
{0x00030040, &CAM_C::IsBusy, "IsBusy"}, {IPC::MakeHeader(0x0002, 1, 0), &CAM_C::StopCapture, "StopCapture"},
{0x00040040, &CAM_C::ClearBuffer, "ClearBuffer"}, {IPC::MakeHeader(0x0003, 1, 0), &CAM_C::IsBusy, "IsBusy"},
{0x00050040, &CAM_C::GetVsyncInterruptEvent, "GetVsyncInterruptEvent"}, {IPC::MakeHeader(0x0004, 1, 0), &CAM_C::ClearBuffer, "ClearBuffer"},
{0x00060040, &CAM_C::GetBufferErrorInterruptEvent, "GetBufferErrorInterruptEvent"}, {IPC::MakeHeader(0x0005, 1, 0), &CAM_C::GetVsyncInterruptEvent, "GetVsyncInterruptEvent"},
{0x00070102, &CAM_C::SetReceiving, "SetReceiving"}, {IPC::MakeHeader(0x0006, 1, 0), &CAM_C::GetBufferErrorInterruptEvent, "GetBufferErrorInterruptEvent"},
{0x00080040, &CAM_C::IsFinishedReceiving, "IsFinishedReceiving"}, {IPC::MakeHeader(0x0007, 4, 2), &CAM_C::SetReceiving, "SetReceiving"},
{0x00090100, &CAM_C::SetTransferLines, "SetTransferLines"}, {IPC::MakeHeader(0x0008, 1, 0), &CAM_C::IsFinishedReceiving, "IsFinishedReceiving"},
{0x000A0080, &CAM_C::GetMaxLines, "GetMaxLines"}, {IPC::MakeHeader(0x0009, 4, 0), &CAM_C::SetTransferLines, "SetTransferLines"},
{0x000B0100, &CAM_C::SetTransferBytes, "SetTransferBytes"}, {IPC::MakeHeader(0x000A, 2, 0), &CAM_C::GetMaxLines, "GetMaxLines"},
{0x000C0040, &CAM_C::GetTransferBytes, "GetTransferBytes"}, {IPC::MakeHeader(0x000B, 4, 0), &CAM_C::SetTransferBytes, "SetTransferBytes"},
{0x000D0080, &CAM_C::GetMaxBytes, "GetMaxBytes"}, {IPC::MakeHeader(0x000C, 1, 0), &CAM_C::GetTransferBytes, "GetTransferBytes"},
{0x000E0080, &CAM_C::SetTrimming, "SetTrimming"}, {IPC::MakeHeader(0x000D, 2, 0), &CAM_C::GetMaxBytes, "GetMaxBytes"},
{0x000F0040, &CAM_C::IsTrimming, "IsTrimming"}, {IPC::MakeHeader(0x000E, 2, 0), &CAM_C::SetTrimming, "SetTrimming"},
{0x00100140, &CAM_C::SetTrimmingParams, "SetTrimmingParams"}, {IPC::MakeHeader(0x000F, 1, 0), &CAM_C::IsTrimming, "IsTrimming"},
{0x00110040, &CAM_C::GetTrimmingParams, "GetTrimmingParams"}, {IPC::MakeHeader(0x0010, 5, 0), &CAM_C::SetTrimmingParams, "SetTrimmingParams"},
{0x00120140, &CAM_C::SetTrimmingParamsCenter, "SetTrimmingParamsCenter"}, {IPC::MakeHeader(0x0011, 1, 0), &CAM_C::GetTrimmingParams, "GetTrimmingParams"},
{0x00130040, &CAM_C::Activate, "Activate"}, {IPC::MakeHeader(0x0012, 5, 0), &CAM_C::SetTrimmingParamsCenter, "SetTrimmingParamsCenter"},
{0x00140080, &CAM_C::SwitchContext, "SwitchContext"}, {IPC::MakeHeader(0x0013, 1, 0), &CAM_C::Activate, "Activate"},
{0x00150080, nullptr, "SetExposure"}, {IPC::MakeHeader(0x0014, 2, 0), &CAM_C::SwitchContext, "SwitchContext"},
{0x00160080, nullptr, "SetWhiteBalance"}, {IPC::MakeHeader(0x0015, 2, 0), nullptr, "SetExposure"},
{0x00170080, nullptr, "SetWhiteBalanceWithoutBaseUp"}, {IPC::MakeHeader(0x0016, 2, 0), nullptr, "SetWhiteBalance"},
{0x00180080, nullptr, "SetSharpness"}, {IPC::MakeHeader(0x0017, 2, 0), nullptr, "SetWhiteBalanceWithoutBaseUp"},
{0x00190080, nullptr, "SetAutoExposure"}, {IPC::MakeHeader(0x0018, 2, 0), nullptr, "SetSharpness"},
{0x001A0040, nullptr, "IsAutoExposure"}, {IPC::MakeHeader(0x0019, 2, 0), nullptr, "SetAutoExposure"},
{0x001B0080, nullptr, "SetAutoWhiteBalance"}, {IPC::MakeHeader(0x001A, 1, 0), nullptr, "IsAutoExposure"},
{0x001C0040, nullptr, "IsAutoWhiteBalance"}, {IPC::MakeHeader(0x001B, 2, 0), nullptr, "SetAutoWhiteBalance"},
{0x001D00C0, &CAM_C::FlipImage, "FlipImage"}, {IPC::MakeHeader(0x001C, 1, 0), nullptr, "IsAutoWhiteBalance"},
{0x001E0200, &CAM_C::SetDetailSize, "SetDetailSize"}, {IPC::MakeHeader(0x001D, 3, 0), &CAM_C::FlipImage, "FlipImage"},
{0x001F00C0, &CAM_C::SetSize, "SetSize"}, {IPC::MakeHeader(0x001E, 8, 0), &CAM_C::SetDetailSize, "SetDetailSize"},
{0x00200080, &CAM_C::SetFrameRate, "SetFrameRate"}, {IPC::MakeHeader(0x001F, 3, 0), &CAM_C::SetSize, "SetSize"},
{0x00210080, nullptr, "SetPhotoMode"}, {IPC::MakeHeader(0x0020, 2, 0), &CAM_C::SetFrameRate, "SetFrameRate"},
{0x002200C0, &CAM_C::SetEffect, "SetEffect"}, {IPC::MakeHeader(0x0021, 2, 0), nullptr, "SetPhotoMode"},
{0x00230080, nullptr, "SetContrast"}, {IPC::MakeHeader(0x0022, 3, 0), &CAM_C::SetEffect, "SetEffect"},
{0x00240080, nullptr, "SetLensCorrection"}, {IPC::MakeHeader(0x0023, 2, 0), nullptr, "SetContrast"},
{0x002500C0, &CAM_C::SetOutputFormat, "SetOutputFormat"}, {IPC::MakeHeader(0x0024, 2, 0), nullptr, "SetLensCorrection"},
{0x00260140, nullptr, "SetAutoExposureWindow"}, {IPC::MakeHeader(0x0025, 3, 0), &CAM_C::SetOutputFormat, "SetOutputFormat"},
{0x00270140, nullptr, "SetAutoWhiteBalanceWindow"}, {IPC::MakeHeader(0x0026, 5, 0), nullptr, "SetAutoExposureWindow"},
{0x00280080, nullptr, "SetNoiseFilter"}, {IPC::MakeHeader(0x0027, 5, 0), nullptr, "SetAutoWhiteBalanceWindow"},
{0x00290080, &CAM_C::SynchronizeVsyncTiming, "SynchronizeVsyncTiming"}, {IPC::MakeHeader(0x0028, 2, 0), nullptr, "SetNoiseFilter"},
{0x002A0080, &CAM_C::GetLatestVsyncTiming, "GetLatestVsyncTiming"}, {IPC::MakeHeader(0x0029, 2, 0), &CAM_C::SynchronizeVsyncTiming, "SynchronizeVsyncTiming"},
{0x002B0000, &CAM_C::GetStereoCameraCalibrationData, "GetStereoCameraCalibrationData"}, {IPC::MakeHeader(0x002A, 2, 0), &CAM_C::GetLatestVsyncTiming, "GetLatestVsyncTiming"},
{0x002C0400, nullptr, "SetStereoCameraCalibrationData"}, {IPC::MakeHeader(0x002B, 0, 0), &CAM_C::GetStereoCameraCalibrationData, "GetStereoCameraCalibrationData"},
{0x002D00C0, nullptr, "WriteRegisterI2c"}, {IPC::MakeHeader(0x002C, 16, 0), nullptr, "SetStereoCameraCalibrationData"},
{0x002E00C0, nullptr, "WriteMcuVariableI2c"}, {IPC::MakeHeader(0x002D, 3, 0), nullptr, "WriteRegisterI2c"},
{0x002F0080, nullptr, "ReadRegisterI2cExclusive"}, {IPC::MakeHeader(0x002E, 3, 0), nullptr, "WriteMcuVariableI2c"},
{0x00300080, nullptr, "ReadMcuVariableI2cExclusive"}, {IPC::MakeHeader(0x002F, 2, 0), nullptr, "ReadRegisterI2cExclusive"},
{0x00310180, nullptr, "SetImageQualityCalibrationData"}, {IPC::MakeHeader(0x0030, 2, 0), nullptr, "ReadMcuVariableI2cExclusive"},
{0x00320000, nullptr, "GetImageQualityCalibrationData"}, {IPC::MakeHeader(0x0031, 6, 0), nullptr, "SetImageQualityCalibrationData"},
{0x003302C0, &CAM_C::SetPackageParameterWithoutContext, {IPC::MakeHeader(0x0032, 0, 0), nullptr, "GetImageQualityCalibrationData"},
"SetPackageParameterWithoutContext"}, {IPC::MakeHeader(0x0033, 11, 0), &CAM_C::SetPackageParameterWithoutContext, "SetPackageParameterWithoutContext"},
{0x00340140, &CAM_C::SetPackageParameterWithContext, "SetPackageParameterWithContext"}, {IPC::MakeHeader(0x0034, 5, 0), &CAM_C::SetPackageParameterWithContext, "SetPackageParameterWithContext"},
{0x003501C0, &CAM_C::SetPackageParameterWithContextDetail, {IPC::MakeHeader(0x0035, 7, 0), &CAM_C::SetPackageParameterWithContextDetail, "SetPackageParameterWithContextDetail"},
"SetPackageParameterWithContextDetail"}, {IPC::MakeHeader(0x0036, 0, 0), &CAM_C::GetSuitableY2rStandardCoefficient, "GetSuitableY2rStandardCoefficient"},
{0x00360000, &CAM_C::GetSuitableY2rStandardCoefficient, {IPC::MakeHeader(0x0037, 8, 2), nullptr, "PlayShutterSoundWithWave"},
"GetSuitableY2rStandardCoefficient"}, {IPC::MakeHeader(0x0038, 1, 0), &CAM_C::PlayShutterSound, "PlayShutterSound"},
{0x00370202, nullptr, "PlayShutterSoundWithWave"}, {IPC::MakeHeader(0x0039, 0, 0), &CAM_C::DriverInitialize, "DriverInitialize"},
{0x00380040, &CAM_C::PlayShutterSound, "PlayShutterSound"}, {IPC::MakeHeader(0x003A, 0, 0), &CAM_C::DriverFinalize, "DriverFinalize"},
{0x00390000, &CAM_C::DriverInitialize, "DriverInitialize"}, {IPC::MakeHeader(0x003B, 0, 0), nullptr, "GetActivatedCamera"},
{0x003A0000, &CAM_C::DriverFinalize, "DriverFinalize"}, {IPC::MakeHeader(0x003C, 0, 0), nullptr, "GetSleepCamera"},
{0x003B0000, nullptr, "GetActivatedCamera"}, {IPC::MakeHeader(0x003D, 1, 0), nullptr, "SetSleepCamera"},
{0x003C0000, nullptr, "GetSleepCamera"}, {IPC::MakeHeader(0x003E, 1, 0), nullptr, "SetBrightnessSynchronization"},
{0x003D0040, nullptr, "SetSleepCamera"}, // clang-format on
{0x003E0040, nullptr, "SetBrightnessSynchronization"},
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

129
src/core/hle/service/cam/cam_s.cpp
View File

@@ -10,71 +10,70 @@ namespace Service::CAM {
CAM_S::CAM_S(std::shared_ptr<Module> cam) : Module::Interface(std::move(cam), "cam:s", 1) { CAM_S::CAM_S(std::shared_ptr<Module> cam) : Module::Interface(std::move(cam), "cam:s", 1) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x00010040, &CAM_S::StartCapture, "StartCapture"}, // clang-format off
{0x00020040, &CAM_S::StopCapture, "StopCapture"}, {IPC::MakeHeader(0x0001, 1, 0), &CAM_S::StartCapture, "StartCapture"},
{0x00030040, &CAM_S::IsBusy, "IsBusy"}, {IPC::MakeHeader(0x0002, 1, 0), &CAM_S::StopCapture, "StopCapture"},
{0x00040040, &CAM_S::ClearBuffer, "ClearBuffer"}, {IPC::MakeHeader(0x0003, 1, 0), &CAM_S::IsBusy, "IsBusy"},
{0x00050040, &CAM_S::GetVsyncInterruptEvent, "GetVsyncInterruptEvent"}, {IPC::MakeHeader(0x0004, 1, 0), &CAM_S::ClearBuffer, "ClearBuffer"},
{0x00060040, &CAM_S::GetBufferErrorInterruptEvent, "GetBufferErrorInterruptEvent"}, {IPC::MakeHeader(0x0005, 1, 0), &CAM_S::GetVsyncInterruptEvent, "GetVsyncInterruptEvent"},
{0x00070102, &CAM_S::SetReceiving, "SetReceiving"}, {IPC::MakeHeader(0x0006, 1, 0), &CAM_S::GetBufferErrorInterruptEvent, "GetBufferErrorInterruptEvent"},
{0x00080040, &CAM_S::IsFinishedReceiving, "IsFinishedReceiving"}, {IPC::MakeHeader(0x0007, 4, 2), &CAM_S::SetReceiving, "SetReceiving"},
{0x00090100, &CAM_S::SetTransferLines, "SetTransferLines"}, {IPC::MakeHeader(0x0008, 1, 0), &CAM_S::IsFinishedReceiving, "IsFinishedReceiving"},
{0x000A0080, &CAM_S::GetMaxLines, "GetMaxLines"}, {IPC::MakeHeader(0x0009, 4, 0), &CAM_S::SetTransferLines, "SetTransferLines"},
{0x000B0100, &CAM_S::SetTransferBytes, "SetTransferBytes"}, {IPC::MakeHeader(0x000A, 2, 0), &CAM_S::GetMaxLines, "GetMaxLines"},
{0x000C0040, &CAM_S::GetTransferBytes, "GetTransferBytes"}, {IPC::MakeHeader(0x000B, 4, 0), &CAM_S::SetTransferBytes, "SetTransferBytes"},
{0x000D0080, &CAM_S::GetMaxBytes, "GetMaxBytes"}, {IPC::MakeHeader(0x000C, 1, 0), &CAM_S::GetTransferBytes, "GetTransferBytes"},
{0x000E0080, &CAM_S::SetTrimming, "SetTrimming"}, {IPC::MakeHeader(0x000D, 2, 0), &CAM_S::GetMaxBytes, "GetMaxBytes"},
{0x000F0040, &CAM_S::IsTrimming, "IsTrimming"}, {IPC::MakeHeader(0x000E, 2, 0), &CAM_S::SetTrimming, "SetTrimming"},
{0x00100140, &CAM_S::SetTrimmingParams, "SetTrimmingParams"}, {IPC::MakeHeader(0x000F, 1, 0), &CAM_S::IsTrimming, "IsTrimming"},
{0x00110040, &CAM_S::GetTrimmingParams, "GetTrimmingParams"}, {IPC::MakeHeader(0x0010, 5, 0), &CAM_S::SetTrimmingParams, "SetTrimmingParams"},
{0x00120140, &CAM_S::SetTrimmingParamsCenter, "SetTrimmingParamsCenter"}, {IPC::MakeHeader(0x0011, 1, 0), &CAM_S::GetTrimmingParams, "GetTrimmingParams"},
{0x00130040, &CAM_S::Activate, "Activate"}, {IPC::MakeHeader(0x0012, 5, 0), &CAM_S::SetTrimmingParamsCenter, "SetTrimmingParamsCenter"},
{0x00140080, &CAM_S::SwitchContext, "SwitchContext"}, {IPC::MakeHeader(0x0013, 1, 0), &CAM_S::Activate, "Activate"},
{0x00150080, nullptr, "SetExposure"}, {IPC::MakeHeader(0x0014, 2, 0), &CAM_S::SwitchContext, "SwitchContext"},
{0x00160080, nullptr, "SetWhiteBalance"}, {IPC::MakeHeader(0x0015, 2, 0), nullptr, "SetExposure"},
{0x00170080, nullptr, "SetWhiteBalanceWithoutBaseUp"}, {IPC::MakeHeader(0x0016, 2, 0), nullptr, "SetWhiteBalance"},
{0x00180080, nullptr, "SetSharpness"}, {IPC::MakeHeader(0x0017, 2, 0), nullptr, "SetWhiteBalanceWithoutBaseUp"},
{0x00190080, nullptr, "SetAutoExposure"}, {IPC::MakeHeader(0x0018, 2, 0), nullptr, "SetSharpness"},
{0x001A0040, nullptr, "IsAutoExposure"}, {IPC::MakeHeader(0x0019, 2, 0), nullptr, "SetAutoExposure"},
{0x001B0080, nullptr, "SetAutoWhiteBalance"}, {IPC::MakeHeader(0x001A, 1, 0), nullptr, "IsAutoExposure"},
{0x001C0040, nullptr, "IsAutoWhiteBalance"}, {IPC::MakeHeader(0x001B, 2, 0), nullptr, "SetAutoWhiteBalance"},
{0x001D00C0, &CAM_S::FlipImage, "FlipImage"}, {IPC::MakeHeader(0x001C, 1, 0), nullptr, "IsAutoWhiteBalance"},
{0x001E0200, &CAM_S::SetDetailSize, "SetDetailSize"}, {IPC::MakeHeader(0x001D, 3, 0), &CAM_S::FlipImage, "FlipImage"},
{0x001F00C0, &CAM_S::SetSize, "SetSize"}, {IPC::MakeHeader(0x001E, 8, 0), &CAM_S::SetDetailSize, "SetDetailSize"},
{0x00200080, &CAM_S::SetFrameRate, "SetFrameRate"}, {IPC::MakeHeader(0x001F, 3, 0), &CAM_S::SetSize, "SetSize"},
{0x00210080, nullptr, "SetPhotoMode"}, {IPC::MakeHeader(0x0020, 2, 0), &CAM_S::SetFrameRate, "SetFrameRate"},
{0x002200C0, &CAM_S::SetEffect, "SetEffect"}, {IPC::MakeHeader(0x0021, 2, 0), nullptr, "SetPhotoMode"},
{0x00230080, nullptr, "SetContrast"}, {IPC::MakeHeader(0x0022, 3, 0), &CAM_S::SetEffect, "SetEffect"},
{0x00240080, nullptr, "SetLensCorrection"}, {IPC::MakeHeader(0x0023, 2, 0), nullptr, "SetContrast"},
{0x002500C0, &CAM_S::SetOutputFormat, "SetOutputFormat"}, {IPC::MakeHeader(0x0024, 2, 0), nullptr, "SetLensCorrection"},
{0x00260140, nullptr, "SetAutoExposureWindow"}, {IPC::MakeHeader(0x0025, 3, 0), &CAM_S::SetOutputFormat, "SetOutputFormat"},
{0x00270140, nullptr, "SetAutoWhiteBalanceWindow"}, {IPC::MakeHeader(0x0026, 5, 0), nullptr, "SetAutoExposureWindow"},
{0x00280080, nullptr, "SetNoiseFilter"}, {IPC::MakeHeader(0x0027, 5, 0), nullptr, "SetAutoWhiteBalanceWindow"},
{0x00290080, &CAM_S::SynchronizeVsyncTiming, "SynchronizeVsyncTiming"}, {IPC::MakeHeader(0x0028, 2, 0), nullptr, "SetNoiseFilter"},
{0x002A0080, &CAM_S::GetLatestVsyncTiming, "GetLatestVsyncTiming"}, {IPC::MakeHeader(0x0029, 2, 0), &CAM_S::SynchronizeVsyncTiming, "SynchronizeVsyncTiming"},
{0x002B0000, &CAM_S::GetStereoCameraCalibrationData, "GetStereoCameraCalibrationData"}, {IPC::MakeHeader(0x002A, 2, 0), &CAM_S::GetLatestVsyncTiming, "GetLatestVsyncTiming"},
{0x002C0400, nullptr, "SetStereoCameraCalibrationData"}, {IPC::MakeHeader(0x002B, 0, 0), &CAM_S::GetStereoCameraCalibrationData, "GetStereoCameraCalibrationData"},
{0x002D00C0, nullptr, "WriteRegisterI2c"}, {IPC::MakeHeader(0x002C, 16, 0), nullptr, "SetStereoCameraCalibrationData"},
{0x002E00C0, nullptr, "WriteMcuVariableI2c"}, {IPC::MakeHeader(0x002D, 3, 0), nullptr, "WriteRegisterI2c"},
{0x002F0080, nullptr, "ReadRegisterI2cExclusive"}, {IPC::MakeHeader(0x002E, 3, 0), nullptr, "WriteMcuVariableI2c"},
{0x00300080, nullptr, "ReadMcuVariableI2cExclusive"}, {IPC::MakeHeader(0x002F, 2, 0), nullptr, "ReadRegisterI2cExclusive"},
{0x00310180, nullptr, "SetImageQualityCalibrationData"}, {IPC::MakeHeader(0x0030, 2, 0), nullptr, "ReadMcuVariableI2cExclusive"},
{0x00320000, nullptr, "GetImageQualityCalibrationData"}, {IPC::MakeHeader(0x0031, 6, 0), nullptr, "SetImageQualityCalibrationData"},
{0x003302C0, &CAM_S::SetPackageParameterWithoutContext, {IPC::MakeHeader(0x0032, 0, 0), nullptr, "GetImageQualityCalibrationData"},
"SetPackageParameterWithoutContext"}, {IPC::MakeHeader(0x0033, 11, 0), &CAM_S::SetPackageParameterWithoutContext, "SetPackageParameterWithoutContext"},
{0x00340140, &CAM_S::SetPackageParameterWithContext, "SetPackageParameterWithContext"}, {IPC::MakeHeader(0x0034, 5, 0), &CAM_S::SetPackageParameterWithContext, "SetPackageParameterWithContext"},
{0x003501C0, &CAM_S::SetPackageParameterWithContextDetail, {IPC::MakeHeader(0x0035, 7, 0), &CAM_S::SetPackageParameterWithContextDetail, "SetPackageParameterWithContextDetail"},
"SetPackageParameterWithContextDetail"}, {IPC::MakeHeader(0x0036, 0, 0), &CAM_S::GetSuitableY2rStandardCoefficient, "GetSuitableY2rStandardCoefficient"},
{0x00360000, &CAM_S::GetSuitableY2rStandardCoefficient, {IPC::MakeHeader(0x0037, 8, 2), nullptr, "PlayShutterSoundWithWave"},
"GetSuitableY2rStandardCoefficient"}, {IPC::MakeHeader(0x0038, 1, 0), &CAM_S::PlayShutterSound, "PlayShutterSound"},
{0x00370202, nullptr, "PlayShutterSoundWithWave"}, {IPC::MakeHeader(0x0039, 0, 0), &CAM_S::DriverInitialize, "DriverInitialize"},
{0x00380040, &CAM_S::PlayShutterSound, "PlayShutterSound"}, {IPC::MakeHeader(0x003A, 0, 0), &CAM_S::DriverFinalize, "DriverFinalize"},
{0x00390000, &CAM_S::DriverInitialize, "DriverInitialize"}, {IPC::MakeHeader(0x003B, 0, 0), nullptr, "GetActivatedCamera"},
{0x003A0000, &CAM_S::DriverFinalize, "DriverFinalize"}, {IPC::MakeHeader(0x003C, 0, 0), nullptr, "GetSleepCamera"},
{0x003B0000, nullptr, "GetActivatedCamera"}, {IPC::MakeHeader(0x003D, 1, 0), nullptr, "SetSleepCamera"},
{0x003C0000, nullptr, "GetSleepCamera"}, {IPC::MakeHeader(0x003E, 1, 0), nullptr, "SetBrightnessSynchronization"},
{0x003D0040, nullptr, "SetSleepCamera"}, // clang-format on
{0x003E0040, nullptr, "SetBrightnessSynchronization"},
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

129
src/core/hle/service/cam/cam_u.cpp
View File

@@ -10,71 +10,70 @@ namespace Service::CAM {
CAM_U::CAM_U(std::shared_ptr<Module> cam) : Module::Interface(std::move(cam), "cam:u", 1) { CAM_U::CAM_U(std::shared_ptr<Module> cam) : Module::Interface(std::move(cam), "cam:u", 1) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x00010040, &CAM_U::StartCapture, "StartCapture"}, // clang-format off
{0x00020040, &CAM_U::StopCapture, "StopCapture"}, {IPC::MakeHeader(0x0001, 1, 0), &CAM_U::StartCapture, "StartCapture"},
{0x00030040, &CAM_U::IsBusy, "IsBusy"}, {IPC::MakeHeader(0x0002, 1, 0), &CAM_U::StopCapture, "StopCapture"},
{0x00040040, &CAM_U::ClearBuffer, "ClearBuffer"}, {IPC::MakeHeader(0x0003, 1, 0), &CAM_U::IsBusy, "IsBusy"},
{0x00050040, &CAM_U::GetVsyncInterruptEvent, "GetVsyncInterruptEvent"}, {IPC::MakeHeader(0x0004, 1, 0), &CAM_U::ClearBuffer, "ClearBuffer"},
{0x00060040, &CAM_U::GetBufferErrorInterruptEvent, "GetBufferErrorInterruptEvent"}, {IPC::MakeHeader(0x0005, 1, 0), &CAM_U::GetVsyncInterruptEvent, "GetVsyncInterruptEvent"},
{0x00070102, &CAM_U::SetReceiving, "SetReceiving"}, {IPC::MakeHeader(0x0006, 1, 0), &CAM_U::GetBufferErrorInterruptEvent, "GetBufferErrorInterruptEvent"},
{0x00080040, &CAM_U::IsFinishedReceiving, "IsFinishedReceiving"}, {IPC::MakeHeader(0x0007, 4, 2), &CAM_U::SetReceiving, "SetReceiving"},
{0x00090100, &CAM_U::SetTransferLines, "SetTransferLines"}, {IPC::MakeHeader(0x0008, 1, 0), &CAM_U::IsFinishedReceiving, "IsFinishedReceiving"},
{0x000A0080, &CAM_U::GetMaxLines, "GetMaxLines"}, {IPC::MakeHeader(0x0009, 4, 0), &CAM_U::SetTransferLines, "SetTransferLines"},
{0x000B0100, &CAM_U::SetTransferBytes, "SetTransferBytes"}, {IPC::MakeHeader(0x000A, 2, 0), &CAM_U::GetMaxLines, "GetMaxLines"},
{0x000C0040, &CAM_U::GetTransferBytes, "GetTransferBytes"}, {IPC::MakeHeader(0x000B, 4, 0), &CAM_U::SetTransferBytes, "SetTransferBytes"},
{0x000D0080, &CAM_U::GetMaxBytes, "GetMaxBytes"}, {IPC::MakeHeader(0x000C, 1, 0), &CAM_U::GetTransferBytes, "GetTransferBytes"},
{0x000E0080, &CAM_U::SetTrimming, "SetTrimming"}, {IPC::MakeHeader(0x000D, 2, 0), &CAM_U::GetMaxBytes, "GetMaxBytes"},
{0x000F0040, &CAM_U::IsTrimming, "IsTrimming"}, {IPC::MakeHeader(0x000E, 2, 0), &CAM_U::SetTrimming, "SetTrimming"},
{0x00100140, &CAM_U::SetTrimmingParams, "SetTrimmingParams"}, {IPC::MakeHeader(0x000F, 1, 0), &CAM_U::IsTrimming, "IsTrimming"},
{0x00110040, &CAM_U::GetTrimmingParams, "GetTrimmingParams"}, {IPC::MakeHeader(0x0010, 5, 0), &CAM_U::SetTrimmingParams, "SetTrimmingParams"},
{0x00120140, &CAM_U::SetTrimmingParamsCenter, "SetTrimmingParamsCenter"}, {IPC::MakeHeader(0x0011, 1, 0), &CAM_U::GetTrimmingParams, "GetTrimmingParams"},
{0x00130040, &CAM_U::Activate, "Activate"}, {IPC::MakeHeader(0x0012, 5, 0), &CAM_U::SetTrimmingParamsCenter, "SetTrimmingParamsCenter"},
{0x00140080, &CAM_U::SwitchContext, "SwitchContext"}, {IPC::MakeHeader(0x0013, 1, 0), &CAM_U::Activate, "Activate"},
{0x00150080, nullptr, "SetExposure"}, {IPC::MakeHeader(0x0014, 2, 0), &CAM_U::SwitchContext, "SwitchContext"},
{0x00160080, nullptr, "SetWhiteBalance"}, {IPC::MakeHeader(0x0015, 2, 0), nullptr, "SetExposure"},
{0x00170080, nullptr, "SetWhiteBalanceWithoutBaseUp"}, {IPC::MakeHeader(0x0016, 2, 0), nullptr, "SetWhiteBalance"},
{0x00180080, nullptr, "SetSharpness"}, {IPC::MakeHeader(0x0017, 2, 0), nullptr, "SetWhiteBalanceWithoutBaseUp"},
{0x00190080, nullptr, "SetAutoExposure"}, {IPC::MakeHeader(0x0018, 2, 0), nullptr, "SetSharpness"},
{0x001A0040, nullptr, "IsAutoExposure"}, {IPC::MakeHeader(0x0019, 2, 0), nullptr, "SetAutoExposure"},
{0x001B0080, nullptr, "SetAutoWhiteBalance"}, {IPC::MakeHeader(0x001A, 1, 0), nullptr, "IsAutoExposure"},
{0x001C0040, nullptr, "IsAutoWhiteBalance"}, {IPC::MakeHeader(0x001B, 2, 0), nullptr, "SetAutoWhiteBalance"},
{0x001D00C0, &CAM_U::FlipImage, "FlipImage"}, {IPC::MakeHeader(0x001C, 1, 0), nullptr, "IsAutoWhiteBalance"},
{0x001E0200, &CAM_U::SetDetailSize, "SetDetailSize"}, {IPC::MakeHeader(0x001D, 3, 0), &CAM_U::FlipImage, "FlipImage"},
{0x001F00C0, &CAM_U::SetSize, "SetSize"}, {IPC::MakeHeader(0x001E, 8, 0), &CAM_U::SetDetailSize, "SetDetailSize"},
{0x00200080, &CAM_U::SetFrameRate, "SetFrameRate"}, {IPC::MakeHeader(0x001F, 3, 0), &CAM_U::SetSize, "SetSize"},
{0x00210080, nullptr, "SetPhotoMode"}, {IPC::MakeHeader(0x0020, 2, 0), &CAM_U::SetFrameRate, "SetFrameRate"},
{0x002200C0, &CAM_U::SetEffect, "SetEffect"}, {IPC::MakeHeader(0x0021, 2, 0), nullptr, "SetPhotoMode"},
{0x00230080, nullptr, "SetContrast"}, {IPC::MakeHeader(0x0022, 3, 0), &CAM_U::SetEffect, "SetEffect"},
{0x00240080, nullptr, "SetLensCorrection"}, {IPC::MakeHeader(0x0023, 2, 0), nullptr, "SetContrast"},
{0x002500C0, &CAM_U::SetOutputFormat, "SetOutputFormat"}, {IPC::MakeHeader(0x0024, 2, 0), nullptr, "SetLensCorrection"},
{0x00260140, nullptr, "SetAutoExposureWindow"}, {IPC::MakeHeader(0x0025, 3, 0), &CAM_U::SetOutputFormat, "SetOutputFormat"},
{0x00270140, nullptr, "SetAutoWhiteBalanceWindow"}, {IPC::MakeHeader(0x0026, 5, 0), nullptr, "SetAutoExposureWindow"},
{0x00280080, nullptr, "SetNoiseFilter"}, {IPC::MakeHeader(0x0027, 5, 0), nullptr, "SetAutoWhiteBalanceWindow"},
{0x00290080, &CAM_U::SynchronizeVsyncTiming, "SynchronizeVsyncTiming"}, {IPC::MakeHeader(0x0028, 2, 0), nullptr, "SetNoiseFilter"},
{0x002A0080, &CAM_U::GetLatestVsyncTiming, "GetLatestVsyncTiming"}, {IPC::MakeHeader(0x0029, 2, 0), &CAM_U::SynchronizeVsyncTiming, "SynchronizeVsyncTiming"},
{0x002B0000, &CAM_U::GetStereoCameraCalibrationData, "GetStereoCameraCalibrationData"}, {IPC::MakeHeader(0x002A, 2, 0), &CAM_U::GetLatestVsyncTiming, "GetLatestVsyncTiming"},
{0x002C0400, nullptr, "SetStereoCameraCalibrationData"}, {IPC::MakeHeader(0x002B, 0, 0), &CAM_U::GetStereoCameraCalibrationData, "GetStereoCameraCalibrationData"},
{0x002D00C0, nullptr, "WriteRegisterI2c"}, {IPC::MakeHeader(0x002C, 16, 0), nullptr, "SetStereoCameraCalibrationData"},
{0x002E00C0, nullptr, "WriteMcuVariableI2c"}, {IPC::MakeHeader(0x002D, 3, 0), nullptr, "WriteRegisterI2c"},
{0x002F0080, nullptr, "ReadRegisterI2cExclusive"}, {IPC::MakeHeader(0x002E, 3, 0), nullptr, "WriteMcuVariableI2c"},
{0x00300080, nullptr, "ReadMcuVariableI2cExclusive"}, {IPC::MakeHeader(0x002F, 2, 0), nullptr, "ReadRegisterI2cExclusive"},
{0x00310180, nullptr, "SetImageQualityCalibrationData"}, {IPC::MakeHeader(0x0030, 2, 0), nullptr, "ReadMcuVariableI2cExclusive"},
{0x00320000, nullptr, "GetImageQualityCalibrationData"}, {IPC::MakeHeader(0x0031, 6, 0), nullptr, "SetImageQualityCalibrationData"},
{0x003302C0, &CAM_U::SetPackageParameterWithoutContext, {IPC::MakeHeader(0x0032, 0, 0), nullptr, "GetImageQualityCalibrationData"},
"SetPackageParameterWithoutContext"}, {IPC::MakeHeader(0x0033, 11, 0), &CAM_U::SetPackageParameterWithoutContext, "SetPackageParameterWithoutContext"},
{0x00340140, &CAM_U::SetPackageParameterWithContext, "SetPackageParameterWithContext"}, {IPC::MakeHeader(0x0034, 5, 0), &CAM_U::SetPackageParameterWithContext, "SetPackageParameterWithContext"},
{0x003501C0, &CAM_U::SetPackageParameterWithContextDetail, {IPC::MakeHeader(0x0035, 7, 0), &CAM_U::SetPackageParameterWithContextDetail, "SetPackageParameterWithContextDetail"},
"SetPackageParameterWithContextDetail"}, {IPC::MakeHeader(0x0036, 0, 0), &CAM_U::GetSuitableY2rStandardCoefficient, "GetSuitableY2rStandardCoefficient"},
{0x00360000, &CAM_U::GetSuitableY2rStandardCoefficient, {IPC::MakeHeader(0x0037, 8, 2), nullptr, "PlayShutterSoundWithWave"},
"GetSuitableY2rStandardCoefficient"}, {IPC::MakeHeader(0x0038, 1, 0), &CAM_U::PlayShutterSound, "PlayShutterSound"},
{0x00370202, nullptr, "PlayShutterSoundWithWave"}, {IPC::MakeHeader(0x0039, 0, 0), &CAM_U::DriverInitialize, "DriverInitialize"},
{0x00380040, &CAM_U::PlayShutterSound, "PlayShutterSound"}, {IPC::MakeHeader(0x003A, 0, 0), &CAM_U::DriverFinalize, "DriverFinalize"},
{0x00390000, &CAM_U::DriverInitialize, "DriverInitialize"}, {IPC::MakeHeader(0x003B, 0, 0), nullptr, "GetActivatedCamera"},
{0x003A0000, &CAM_U::DriverFinalize, "DriverFinalize"}, {IPC::MakeHeader(0x003C, 0, 0), nullptr, "GetSleepCamera"},
{0x003B0000, nullptr, "GetActivatedCamera"}, {IPC::MakeHeader(0x003D, 1, 0), nullptr, "SetSleepCamera"},
{0x003C0000, nullptr, "GetSleepCamera"}, {IPC::MakeHeader(0x003E, 1, 0), nullptr, "SetBrightnessSynchronization"},
{0x003D0040, nullptr, "SetSleepCamera"}, // clang-format on
{0x003E0040, nullptr, "SetBrightnessSynchronization"},
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

8
src/core/hle/service/cecd/cecd_ndm.cpp
View File

@@ -13,10 +13,10 @@ CECD_NDM::CECD_NDM(std::shared_ptr<Module> cecd)
: Module::Interface(std::move(cecd), "cecd:ndm", DefaultMaxSessions) { : Module::Interface(std::move(cecd), "cecd:ndm", DefaultMaxSessions) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
// clang-format off // clang-format off
{0x00010000, nullptr, "Initialize"}, {IPC::MakeHeader(0x0001, 0, 0), nullptr, "Initialize"},
{0x00020000, nullptr, "Deinitialize"}, {IPC::MakeHeader(0x0002, 0, 0), nullptr, "Deinitialize"},
{0x00030000, nullptr, "ResumeDaemon"}, {IPC::MakeHeader(0x0003, 0, 0), nullptr, "ResumeDaemon"},
{0x00040040, nullptr, "SuspendDaemon"}, {IPC::MakeHeader(0x0004, 1, 0), nullptr, "SuspendDaemon"},
// clang-format on // clang-format on
}; };

42
src/core/hle/service/cecd/cecd_s.cpp
View File

@@ -14,28 +14,28 @@ CECD_S::CECD_S(std::shared_ptr<Module> cecd)
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
// cecd:u shared commands // cecd:u shared commands
// clang-format off // clang-format off
{0x000100C2, &CECD_S::Open, "Open"}, {IPC::MakeHeader(0x0001, 3, 2), &CECD_S::Open, "Open"},
{0x00020042, &CECD_S::Read, "Read"}, {IPC::MakeHeader(0x0002, 1, 2), &CECD_S::Read, "Read"},
{0x00030104, &CECD_S::ReadMessage, "ReadMessage"}, {IPC::MakeHeader(0x0003, 4, 4), &CECD_S::ReadMessage, "ReadMessage"},
{0x00040106, &CECD_S::ReadMessageWithHMAC, "ReadMessageWithHMAC"}, {IPC::MakeHeader(0x0004, 4, 6), &CECD_S::ReadMessageWithHMAC, "ReadMessageWithHMAC"},
{0x00050042, &CECD_S::Write, "Write"}, {IPC::MakeHeader(0x0005, 1, 2), &CECD_S::Write, "Write"},
{0x00060104, &CECD_S::WriteMessage, "WriteMessage"}, {IPC::MakeHeader(0x0006, 4, 4), &CECD_S::WriteMessage, "WriteMessage"},
{0x00070106, &CECD_S::WriteMessageWithHMAC, "WriteMessageWithHMAC"}, {IPC::MakeHeader(0x0007, 4, 6), &CECD_S::WriteMessageWithHMAC, "WriteMessageWithHMAC"},
{0x00080102, &CECD_S::Delete, "Delete"}, {IPC::MakeHeader(0x0008, 4, 2), &CECD_S::Delete, "Delete"},
{0x000900C2, &CECD_S::SetData, "SetData"}, {IPC::MakeHeader(0x0009, 3, 2), &CECD_S::SetData, "SetData"},
{0x000A00C4, &CECD_S::ReadData, "ReadData"}, {IPC::MakeHeader(0x000A, 3, 4), &CECD_S::ReadData, "ReadData"},
{0x000B0040, &CECD_S::Start, "Start"}, {IPC::MakeHeader(0x000B, 1, 0), &CECD_S::Start, "Start"},
{0x000C0040, &CECD_S::Stop, "Stop"}, {IPC::MakeHeader(0x000C, 1, 0), &CECD_S::Stop, "Stop"},
{0x000D0082, &CECD_S::GetCecInfoBuffer, "GetCecInfoBuffer"}, {IPC::MakeHeader(0x000D, 2, 2), &CECD_S::GetCecInfoBuffer, "GetCecInfoBuffer"},
{0x000E0000, &CECD_S::GetCecdState, "GetCecdState"}, {IPC::MakeHeader(0x000E, 0, 0), &CECD_S::GetCecdState, "GetCecdState"},
{0x000F0000, &CECD_S::GetCecInfoEventHandle, "GetCecInfoEventHandle"}, {IPC::MakeHeader(0x000F, 0, 0), &CECD_S::GetCecInfoEventHandle, "GetCecInfoEventHandle"},
{0x00100000, &CECD_S::GetChangeStateEventHandle, "GetChangeStateEventHandle"}, {IPC::MakeHeader(0x0010, 0, 0), &CECD_S::GetChangeStateEventHandle, "GetChangeStateEventHandle"},
{0x00110104, &CECD_S::OpenAndWrite, "OpenAndWrite"}, {IPC::MakeHeader(0x0011, 4, 4), &CECD_S::OpenAndWrite, "OpenAndWrite"},
{0x00120104, &CECD_S::OpenAndRead, "OpenAndRead"}, {IPC::MakeHeader(0x0012, 4, 4), &CECD_S::OpenAndRead, "OpenAndRead"},
{0x001E0082, nullptr, "GetEventLog"}, {IPC::MakeHeader(0x001E, 2, 2), nullptr, "GetEventLog"},
{0x001F0000, nullptr, "GetEventLogStart"}, {IPC::MakeHeader(0x001F, 0, 0), nullptr, "GetEventLogStart"},
// cecd:s commands // cecd:s commands
{0x04020002, nullptr, "GetCecInfoEventHandleSys"}, {IPC::MakeHeader(0x0402, 0, 2), nullptr, "GetCecInfoEventHandleSys"},
// clang-format on // clang-format on
}; };

40
src/core/hle/service/cecd/cecd_u.cpp
View File

@@ -14,26 +14,26 @@ CECD_U::CECD_U(std::shared_ptr<Module> cecd)
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
// cecd:u shared commands // cecd:u shared commands
// clang-format off // clang-format off
{0x000100C2, &CECD_U::Open, "Open"}, {IPC::MakeHeader(0x0001, 3, 2), &CECD_U::Open, "Open"},
{0x00020042, &CECD_U::Read, "Read"}, {IPC::MakeHeader(0x0002, 1, 2), &CECD_U::Read, "Read"},
{0x00030104, &CECD_U::ReadMessage, "ReadMessage"}, {IPC::MakeHeader(0x0003, 4, 4), &CECD_U::ReadMessage, "ReadMessage"},
{0x00040106, &CECD_U::ReadMessageWithHMAC, "ReadMessageWithHMAC"}, {IPC::MakeHeader(0x0004, 4, 6), &CECD_U::ReadMessageWithHMAC, "ReadMessageWithHMAC"},
{0x00050042, &CECD_U::Write, "Write"}, {IPC::MakeHeader(0x0005, 1, 2), &CECD_U::Write, "Write"},
{0x00060104, &CECD_U::WriteMessage, "WriteMessage"}, {IPC::MakeHeader(0x0006, 4, 4), &CECD_U::WriteMessage, "WriteMessage"},
{0x00070106, &CECD_U::WriteMessageWithHMAC, "WriteMessageWithHMAC"}, {IPC::MakeHeader(0x0007, 4, 6), &CECD_U::WriteMessageWithHMAC, "WriteMessageWithHMAC"},
{0x00080102, &CECD_U::Delete, "Delete"}, {IPC::MakeHeader(0x0008, 4, 2), &CECD_U::Delete, "Delete"},
{0x000900C2, &CECD_U::SetData, "SetData"}, {IPC::MakeHeader(0x0009, 3, 2), &CECD_U::SetData, "SetData"},
{0x000A00C4, &CECD_U::ReadData, "ReadData"}, {IPC::MakeHeader(0x000A, 3, 4), &CECD_U::ReadData, "ReadData"},
{0x000B0040, &CECD_U::Start, "Start"}, {IPC::MakeHeader(0x000B, 1, 0), &CECD_U::Start, "Start"},
{0x000C0040, &CECD_U::Stop, "Stop"}, {IPC::MakeHeader(0x000C, 1, 0), &CECD_U::Stop, "Stop"},
{0x000D0082, &CECD_U::GetCecInfoBuffer, "GetCecInfoBuffer"}, {IPC::MakeHeader(0x000D, 2, 2), &CECD_U::GetCecInfoBuffer, "GetCecInfoBuffer"},
{0x000E0000, &CECD_U::GetCecdState, "GetCecdState"}, {IPC::MakeHeader(0x000E, 0, 0), &CECD_U::GetCecdState, "GetCecdState"},
{0x000F0000, &CECD_U::GetCecInfoEventHandle, "GetCecInfoEventHandle"}, {IPC::MakeHeader(0x000F, 0, 0), &CECD_U::GetCecInfoEventHandle, "GetCecInfoEventHandle"},
{0x00100000, &CECD_U::GetChangeStateEventHandle, "GetChangeStateEventHandle"}, {IPC::MakeHeader(0x0010, 0, 0), &CECD_U::GetChangeStateEventHandle, "GetChangeStateEventHandle"},
{0x00110104, &CECD_U::OpenAndWrite, "OpenAndWrite"}, {IPC::MakeHeader(0x0011, 4, 4), &CECD_U::OpenAndWrite, "OpenAndWrite"},
{0x00120104, &CECD_U::OpenAndRead, "OpenAndRead"}, {IPC::MakeHeader(0x0012, 4, 4), &CECD_U::OpenAndRead, "OpenAndRead"},
{0x001E0082, nullptr, "GetEventLog"}, {IPC::MakeHeader(0x001E, 2, 2), nullptr, "GetEventLog"},
{0x001F0000, nullptr, "GetEventLogStart"}, {IPC::MakeHeader(0x001F, 0, 0), nullptr, "GetEventLogStart"},
// clang-format on // clang-format on
}; };

90
src/core/hle/service/cfg/cfg_i.cpp
View File

@@ -12,52 +12,52 @@ namespace Service::CFG {
CFG_I::CFG_I(std::shared_ptr<Module> cfg) : Module::Interface(std::move(cfg), "cfg:i", 23) { CFG_I::CFG_I(std::shared_ptr<Module> cfg) : Module::Interface(std::move(cfg), "cfg:i", 23) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
// cfg common // cfg common
{0x00010082, &CFG_I::GetConfigInfoBlk2, "GetConfigInfoBlk2"}, // clang-format off
{0x00020000, &CFG_I::D<&CFG_I::SecureInfoGetRegion, 0x0002>, "SecureInfoGetRegion"}, {IPC::MakeHeader(0x0001, 2, 2), &CFG_I::GetConfigInfoBlk2, "GetConfigInfoBlk2"},
{0x00030040, &CFG_I::GenHashConsoleUnique, "GenHashConsoleUnique"}, {IPC::MakeHeader(0x0002, 0, 0), &CFG_I::D<&CFG_I::SecureInfoGetRegion, 0x0002>, "SecureInfoGetRegion"},
{0x00040000, &CFG_I::GetRegionCanadaUSA, "GetRegionCanadaUSA"}, {IPC::MakeHeader(0x0003, 1, 0), &CFG_I::GenHashConsoleUnique, "GenHashConsoleUnique"},
{0x00050000, &CFG_I::GetSystemModel, "GetSystemModel"}, {IPC::MakeHeader(0x0004, 0, 0), &CFG_I::GetRegionCanadaUSA, "GetRegionCanadaUSA"},
{0x00060000, &CFG_I::GetModelNintendo2DS, "GetModelNintendo2DS"}, {IPC::MakeHeader(0x0005, 0, 0), &CFG_I::GetSystemModel, "GetSystemModel"},
{0x00070040, nullptr, "WriteToFirstByteCfgSavegame"}, {IPC::MakeHeader(0x0006, 0, 0), &CFG_I::GetModelNintendo2DS, "GetModelNintendo2DS"},
{0x00080080, nullptr, "GoThroughTable"}, {IPC::MakeHeader(0x0007, 1, 0), nullptr, "WriteToFirstByteCfgSavegame"},
{0x00090040, &CFG_I::GetCountryCodeString, "GetCountryCodeString"}, {IPC::MakeHeader(0x0008, 2, 0), nullptr, "GoThroughTable"},
{0x000A0040, &CFG_I::GetCountryCodeID, "GetCountryCodeID"}, {IPC::MakeHeader(0x0009, 1, 0), &CFG_I::GetCountryCodeString, "GetCountryCodeString"},
{0x000B0000, nullptr, "IsFangateSupported"}, {IPC::MakeHeader(0x000A, 1, 0), &CFG_I::GetCountryCodeID, "GetCountryCodeID"},
{IPC::MakeHeader(0x000B, 0, 0), nullptr, "IsFangateSupported"},
// cfg:i // cfg:i
{0x04010082, &CFG_I::D<&CFG_I::GetConfigInfoBlk8, 0x0401>, "GetConfigInfoBlk8"}, {IPC::MakeHeader(0x0401, 2, 2), &CFG_I::D<&CFG_I::GetConfigInfoBlk8, 0x0401>, "GetConfigInfoBlk8"},
{0x04020082, &CFG_I::D<&CFG_I::SetConfigInfoBlk4, 0x0402>, "SetConfigInfoBlk4"}, {IPC::MakeHeader(0x0402, 2, 2), &CFG_I::D<&CFG_I::SetConfigInfoBlk4, 0x0402>, "SetConfigInfoBlk4"},
{0x04030000, &CFG_I::D<&CFG_I::UpdateConfigNANDSavegame, 0x0403>, {IPC::MakeHeader(0x0403, 0, 0), &CFG_I::D<&CFG_I::UpdateConfigNANDSavegame, 0x0403>, "UpdateConfigNANDSavegame"},
"UpdateConfigNANDSavegame"}, {IPC::MakeHeader(0x0404, 1, 2), nullptr, "GetLocalFriendCodeSeedData"},
{0x04040042, nullptr, "GetLocalFriendCodeSeedData"}, {IPC::MakeHeader(0x0405, 0, 0), nullptr, "GetLocalFriendCodeSeed"},
{0x04050000, nullptr, "GetLocalFriendCodeSeed"}, {IPC::MakeHeader(0x0406, 0, 0), &CFG_I::D<&CFG_I::SecureInfoGetRegion, 0x0406>, "SecureInfoGetRegion"},
{0x04060000, &CFG_I::D<&CFG_I::SecureInfoGetRegion, 0x0406>, "SecureInfoGetRegion"}, {IPC::MakeHeader(0x0407, 0, 0), nullptr, "SecureInfoGetByte101"},
{0x04070000, nullptr, "SecureInfoGetByte101"}, {IPC::MakeHeader(0x0408, 1, 2), nullptr, "SecureInfoGetSerialNo"},
{0x04080042, nullptr, "SecureInfoGetSerialNo"}, {IPC::MakeHeader(0x0409, 0, 0), nullptr, "UpdateConfigBlk00040003"},
{0x04090000, nullptr, "UpdateConfigBlk00040003"}, {IPC::MakeHeader(0x0801, 2, 2), &CFG_I::D<&CFG_I::GetConfigInfoBlk8, 0x0801>, "GetConfigInfoBlk8"},
{0x08010082, &CFG_I::D<&CFG_I::GetConfigInfoBlk8, 0x0801>, "GetConfigInfoBlk8"}, {IPC::MakeHeader(0x0802, 2, 2), &CFG_I::D<&CFG_I::SetConfigInfoBlk4, 0x0802>, "SetConfigInfoBlk4"},
{0x08020082, &CFG_I::D<&CFG_I::SetConfigInfoBlk4, 0x0802>, "SetConfigInfoBlk4"}, {IPC::MakeHeader(0x0803, 0, 0), &CFG_I::D<&CFG_I::UpdateConfigNANDSavegame, 0x0803>, "UpdateConfigNANDSavegame"},
{0x08030000, &CFG_I::D<&CFG_I::UpdateConfigNANDSavegame, 0x0803>, {IPC::MakeHeader(0x0804, 3, 2), nullptr, "CreateConfigInfoBlk"},
"UpdateConfigNANDSavegame"}, {IPC::MakeHeader(0x0805, 0, 0), nullptr, "DeleteConfigNANDSavefile"},
{0x080400C2, nullptr, "CreateConfigInfoBlk"}, {IPC::MakeHeader(0x0806, 0, 0), &CFG_I::FormatConfig, "FormatConfig"},
{0x08050000, nullptr, "DeleteConfigNANDSavefile"}, {IPC::MakeHeader(0x0808, 0, 0), nullptr, "UpdateConfigBlk1"},
{0x08060000, &CFG_I::FormatConfig, "FormatConfig"}, {IPC::MakeHeader(0x0809, 0, 0), nullptr, "UpdateConfigBlk2"},
{0x08080000, nullptr, "UpdateConfigBlk1"}, {IPC::MakeHeader(0x080A, 0, 0), nullptr, "UpdateConfigBlk3"},
{0x08090000, nullptr, "UpdateConfigBlk2"}, {IPC::MakeHeader(0x080B, 2, 2), nullptr, "SetGetLocalFriendCodeSeedData"},
{0x080A0000, nullptr, "UpdateConfigBlk3"}, {IPC::MakeHeader(0x080C, 1, 2), nullptr, "SetLocalFriendCodeSeedSignature"},
{0x080B0082, nullptr, "SetGetLocalFriendCodeSeedData"}, {IPC::MakeHeader(0x080D, 0, 0), nullptr, "DeleteCreateNANDLocalFriendCodeSeed"},
{0x080C0042, nullptr, "SetLocalFriendCodeSeedSignature"}, {IPC::MakeHeader(0x080E, 0, 0), nullptr, "VerifySigLocalFriendCodeSeed"},
{0x080D0000, nullptr, "DeleteCreateNANDLocalFriendCodeSeed"}, {IPC::MakeHeader(0x080F, 1, 2), nullptr, "GetLocalFriendCodeSeedData"},
{0x080E0000, nullptr, "VerifySigLocalFriendCodeSeed"}, {IPC::MakeHeader(0x0810, 0, 0), nullptr, "GetLocalFriendCodeSeed"},
{0x080F0042, nullptr, "GetLocalFriendCodeSeedData"}, {IPC::MakeHeader(0x0811, 2, 4), nullptr, "SetSecureInfo"},
{0x08100000, nullptr, "GetLocalFriendCodeSeed"}, {IPC::MakeHeader(0x0812, 0, 0), nullptr, "DeleteCreateNANDSecureInfo"},
{0x08110084, nullptr, "SetSecureInfo"}, {IPC::MakeHeader(0x0813, 0, 0), nullptr, "VerifySigSecureInfo"},
{0x08120000, nullptr, "DeleteCreateNANDSecureInfo"}, {IPC::MakeHeader(0x0814, 1, 2), nullptr, "SecureInfoGetData"},
{0x08130000, nullptr, "VerifySigSecureInfo"}, {IPC::MakeHeader(0x0815, 1, 2), nullptr, "SecureInfoGetSignature"},
{0x08140042, nullptr, "SecureInfoGetData"}, {IPC::MakeHeader(0x0816, 0, 0), &CFG_I::D<&CFG_I::SecureInfoGetRegion, 0x0816>, "SecureInfoGetRegion"},
{0x08150042, nullptr, "SecureInfoGetSignature"}, {IPC::MakeHeader(0x0817, 0, 0), nullptr, "SecureInfoGetByte101"},
{0x08160000, &CFG_I::D<&CFG_I::SecureInfoGetRegion, 0x0816>, "SecureInfoGetRegion"}, {IPC::MakeHeader(0x0818, 1, 2), nullptr, "SecureInfoGetSerialNo"},
{0x08170000, nullptr, "SecureInfoGetByte101"}, // clang-format on
{0x08180042, nullptr, "SecureInfoGetSerialNo"},
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

10
src/core/hle/service/cfg/cfg_nor.cpp
View File

@@ -11,10 +11,12 @@ namespace Service::CFG {
CFG_NOR::CFG_NOR() : ServiceFramework("cfg:nor", 23) { CFG_NOR::CFG_NOR() : ServiceFramework("cfg:nor", 23) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x00010040, nullptr, "Initialize"}, // clang-format off
{0x00020000, nullptr, "Shutdown"}, {IPC::MakeHeader(0x0001, 1, 0), nullptr, "Initialize"},
{0x00050082, nullptr, "ReadData"}, {IPC::MakeHeader(0x0002, 0, 0), nullptr, "Shutdown"},
{0x00060082, nullptr, "WriteData"}, {IPC::MakeHeader(0x0005, 2, 2), nullptr, "ReadData"},
{IPC::MakeHeader(0x0006, 2, 2), nullptr, "WriteData"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

43
src/core/hle/service/cfg/cfg_s.cpp
View File

@@ -12,28 +12,29 @@ namespace Service::CFG {
CFG_S::CFG_S(std::shared_ptr<Module> cfg) : Module::Interface(std::move(cfg), "cfg:s", 23) { CFG_S::CFG_S(std::shared_ptr<Module> cfg) : Module::Interface(std::move(cfg), "cfg:s", 23) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
// cfg common // cfg common
{0x00010082, &CFG_S::GetConfigInfoBlk2, "GetConfigInfoBlk2"}, // clang-format off
{0x00020000, &CFG_S::D<&CFG_S::SecureInfoGetRegion, 0x0002>, "SecureInfoGetRegion"}, {IPC::MakeHeader(0x0001, 2, 2), &CFG_S::GetConfigInfoBlk2, "GetConfigInfoBlk2"},
{0x00030040, &CFG_S::GenHashConsoleUnique, "GenHashConsoleUnique"}, {IPC::MakeHeader(0x0002, 0, 0), &CFG_S::D<&CFG_S::SecureInfoGetRegion, 0x0002>, "SecureInfoGetRegion"},
{0x00040000, &CFG_S::GetRegionCanadaUSA, "GetRegionCanadaUSA"}, {IPC::MakeHeader(0x0003, 1, 0), &CFG_S::GenHashConsoleUnique, "GenHashConsoleUnique"},
{0x00050000, &CFG_S::GetSystemModel, "GetSystemModel"}, {IPC::MakeHeader(0x0004, 0, 0), &CFG_S::GetRegionCanadaUSA, "GetRegionCanadaUSA"},
{0x00060000, &CFG_S::GetModelNintendo2DS, "GetModelNintendo2DS"}, {IPC::MakeHeader(0x0005, 0, 0), &CFG_S::GetSystemModel, "GetSystemModel"},
{0x00070040, nullptr, "WriteToFirstByteCfgSavegame"}, {IPC::MakeHeader(0x0006, 0, 0), &CFG_S::GetModelNintendo2DS, "GetModelNintendo2DS"},
{0x00080080, nullptr, "GoThroughTable"}, {IPC::MakeHeader(0x0007, 1, 0), nullptr, "WriteToFirstByteCfgSavegame"},
{0x00090040, &CFG_S::GetCountryCodeString, "GetCountryCodeString"}, {IPC::MakeHeader(0x0008, 2, 0), nullptr, "GoThroughTable"},
{0x000A0040, &CFG_S::GetCountryCodeID, "GetCountryCodeID"}, {IPC::MakeHeader(0x0009, 1, 0), &CFG_S::GetCountryCodeString, "GetCountryCodeString"},
{0x000B0000, nullptr, "IsFangateSupported"}, {IPC::MakeHeader(0x000A, 1, 0), &CFG_S::GetCountryCodeID, "GetCountryCodeID"},
{IPC::MakeHeader(0x000B, 0, 0), nullptr, "IsFangateSupported"},
// cfg:s // cfg:s
{0x04010082, &CFG_S::D<&CFG_S::GetConfigInfoBlk8, 0x0401>, "GetConfigInfoBlk8"}, {IPC::MakeHeader(0x0401, 2, 2), &CFG_S::D<&CFG_S::GetConfigInfoBlk8, 0x0401>, "GetConfigInfoBlk8"},
{0x04020082, &CFG_S::D<&CFG_S::SetConfigInfoBlk4, 0x0402>, "SetConfigInfoBlk4"}, {IPC::MakeHeader(0x0402, 2, 2), &CFG_S::D<&CFG_S::SetConfigInfoBlk4, 0x0402>, "SetConfigInfoBlk4"},
{0x04030000, &CFG_S::D<&CFG_S::UpdateConfigNANDSavegame, 0x0403>, {IPC::MakeHeader(0x0403, 0, 0), &CFG_S::D<&CFG_S::UpdateConfigNANDSavegame, 0x0403>, "UpdateConfigNANDSavegame"},
"UpdateConfigNANDSavegame"}, {IPC::MakeHeader(0x0404, 1, 2), nullptr, "GetLocalFriendCodeSeedData"},
{0x04040042, nullptr, "GetLocalFriendCodeSeedData"}, {IPC::MakeHeader(0x0405, 0, 0), nullptr, "GetLocalFriendCodeSeed"},
{0x04050000, nullptr, "GetLocalFriendCodeSeed"}, {IPC::MakeHeader(0x0406, 0, 0), &CFG_S::D<&CFG_S::SecureInfoGetRegion, 0x0406>, "SecureInfoGetRegion"},
{0x04060000, &CFG_S::D<&CFG_S::SecureInfoGetRegion, 0x0406>, "SecureInfoGetRegion"}, {IPC::MakeHeader(0x0407, 0, 0), nullptr, "SecureInfoGetByte101"},
{0x04070000, nullptr, "SecureInfoGetByte101"}, {IPC::MakeHeader(0x0408, 1, 2), nullptr, "SecureInfoGetSerialNo"},
{0x04080042, nullptr, "SecureInfoGetSerialNo"}, {IPC::MakeHeader(0x0409, 0, 0), nullptr, "UpdateConfigBlk00040003"},
{0x04090000, nullptr, "UpdateConfigBlk00040003"}, // clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

24
src/core/hle/service/cfg/cfg_u.cpp
View File

@@ -12,17 +12,19 @@ namespace Service::CFG {
CFG_U::CFG_U(std::shared_ptr<Module> cfg) : Module::Interface(std::move(cfg), "cfg:u", 23) { CFG_U::CFG_U(std::shared_ptr<Module> cfg) : Module::Interface(std::move(cfg), "cfg:u", 23) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
// cfg common // cfg common
{0x00010082, &CFG_U::GetConfigInfoBlk2, "GetConfigInfoBlk2"}, // clang-format off
{0x00020000, &CFG_U::D<&CFG_U::SecureInfoGetRegion, 0x0002>, "SecureInfoGetRegion"}, {IPC::MakeHeader(0x0001, 2, 2), &CFG_U::GetConfigInfoBlk2, "GetConfigInfoBlk2"},
{0x00030040, &CFG_U::GenHashConsoleUnique, "GenHashConsoleUnique"}, {IPC::MakeHeader(0x0002, 0, 0), &CFG_U::D<&CFG_U::SecureInfoGetRegion, 0x0002>, "SecureInfoGetRegion"},
{0x00040000, &CFG_U::GetRegionCanadaUSA, "GetRegionCanadaUSA"}, {IPC::MakeHeader(0x0003, 1, 0), &CFG_U::GenHashConsoleUnique, "GenHashConsoleUnique"},
{0x00050000, &CFG_U::GetSystemModel, "GetSystemModel"}, {IPC::MakeHeader(0x0004, 0, 0), &CFG_U::GetRegionCanadaUSA, "GetRegionCanadaUSA"},
{0x00060000, &CFG_U::GetModelNintendo2DS, "GetModelNintendo2DS"}, {IPC::MakeHeader(0x0005, 0, 0), &CFG_U::GetSystemModel, "GetSystemModel"},
{0x00070040, nullptr, "WriteToFirstByteCfgSavegame"}, {IPC::MakeHeader(0x0006, 0, 0), &CFG_U::GetModelNintendo2DS, "GetModelNintendo2DS"},
{0x00080080, nullptr, "GoThroughTable"}, {IPC::MakeHeader(0x0007, 1, 0), nullptr, "WriteToFirstByteCfgSavegame"},
{0x00090040, &CFG_U::GetCountryCodeString, "GetCountryCodeString"}, {IPC::MakeHeader(0x0008, 2, 0), nullptr, "GoThroughTable"},
{0x000A0040, &CFG_U::GetCountryCodeID, "GetCountryCodeID"}, {IPC::MakeHeader(0x0009, 1, 0), &CFG_U::GetCountryCodeString, "GetCountryCodeString"},
{0x000B0000, nullptr, "IsFangateSupported"}, {IPC::MakeHeader(0x000A, 1, 0), &CFG_U::GetCountryCodeID, "GetCountryCodeID"},
{IPC::MakeHeader(0x000B, 0, 0), nullptr, "IsFangateSupported"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

24
src/core/hle/service/csnd/csnd_snd.cpp
View File

@@ -508,18 +508,18 @@ void CSND_SND::Reset(Kernel::HLERequestContext& ctx) {
CSND_SND::CSND_SND(Core::System& system) : ServiceFramework("csnd:SND", 4), system(system) { CSND_SND::CSND_SND(Core::System& system) : ServiceFramework("csnd:SND", 4), system(system) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
// clang-format off // clang-format off
{0x00010140, &CSND_SND::Initialize, "Initialize"}, {IPC::MakeHeader(0x0001, 5, 0), &CSND_SND::Initialize, "Initialize"},
{0x00020000, &CSND_SND::Shutdown, "Shutdown"}, {IPC::MakeHeader(0x0002, 0, 0), &CSND_SND::Shutdown, "Shutdown"},
{0x00030040, &CSND_SND::ExecuteCommands, "ExecuteCommands"}, {IPC::MakeHeader(0x0003, 1, 0), &CSND_SND::ExecuteCommands, "ExecuteCommands"},
{0x00040080, nullptr, "ExecuteType1Commands"}, {IPC::MakeHeader(0x0004, 2, 0), nullptr, "ExecuteType1Commands"},
{0x00050000, &CSND_SND::AcquireSoundChannels, "AcquireSoundChannels"}, {IPC::MakeHeader(0x0005, 0, 0), &CSND_SND::AcquireSoundChannels, "AcquireSoundChannels"},
{0x00060000, &CSND_SND::ReleaseSoundChannels, "ReleaseSoundChannels"}, {IPC::MakeHeader(0x0006, 0, 0), &CSND_SND::ReleaseSoundChannels, "ReleaseSoundChannels"},
{0x00070000, &CSND_SND::AcquireCapUnit, "AcquireCapUnit"}, {IPC::MakeHeader(0x0007, 0, 0), &CSND_SND::AcquireCapUnit, "AcquireCapUnit"},
{0x00080040, &CSND_SND::ReleaseCapUnit, "ReleaseCapUnit"}, {IPC::MakeHeader(0x0008, 1, 0), &CSND_SND::ReleaseCapUnit, "ReleaseCapUnit"},
{0x00090082, &CSND_SND::FlushDataCache, "FlushDataCache"}, {IPC::MakeHeader(0x0009, 2, 2), &CSND_SND::FlushDataCache, "FlushDataCache"},
{0x000A0082, &CSND_SND::StoreDataCache, "StoreDataCache"}, {IPC::MakeHeader(0x000A, 2, 2), &CSND_SND::StoreDataCache, "StoreDataCache"},
{0x000B0082, &CSND_SND::InvalidateDataCache, "InvalidateDataCache"}, {IPC::MakeHeader(0x000B, 2, 2), &CSND_SND::InvalidateDataCache, "InvalidateDataCache"},
{0x000C0000, &CSND_SND::Reset, "Reset"}, {IPC::MakeHeader(0x000C, 0, 0), &CSND_SND::Reset, "Reset"},
// clang-format on // clang-format on
}; };

40
src/core/hle/service/dlp/dlp_clnt.cpp
View File

@@ -13,26 +13,26 @@ namespace Service::DLP {
DLP_CLNT::DLP_CLNT() : ServiceFramework("dlp:CLNT", 1) { DLP_CLNT::DLP_CLNT() : ServiceFramework("dlp:CLNT", 1) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
// clang-format off // clang-format off
{0x000100C3, nullptr, "Initialize"}, {IPC::MakeHeader(0x0001, 3, 3), nullptr, "Initialize"},
{0x00020000, nullptr, "Finalize"}, {IPC::MakeHeader(0x0002, 0, 0), nullptr, "Finalize"},
{0x00030000, nullptr, "GetEventDesc"}, {IPC::MakeHeader(0x0003, 0, 0), nullptr, "GetEventDesc"},
{0x00040000, nullptr, "GetChannel"}, {IPC::MakeHeader(0x0004, 0, 0), nullptr, "GetChannel"},
{0x00050180, nullptr, "StartScan"}, {IPC::MakeHeader(0x0005, 6, 0), nullptr, "StartScan"},
{0x00060000, nullptr, "StopScan"}, {IPC::MakeHeader(0x0006, 0, 0), nullptr, "StopScan"},
{0x00070080, nullptr, "GetServerInfo"}, {IPC::MakeHeader(0x0007, 2, 0), nullptr, "GetServerInfo"},
{0x00080100, nullptr, "GetTitleInfo"}, {IPC::MakeHeader(0x0008, 4, 0), nullptr, "GetTitleInfo"},
{0x00090040, nullptr, "GetTitleInfoInOrder"}, {IPC::MakeHeader(0x0009, 1, 0), nullptr, "GetTitleInfoInOrder"},
{0x000A0080, nullptr, "DeleteScanInfo"}, {IPC::MakeHeader(0x000A, 2, 0), nullptr, "DeleteScanInfo"},
{0x000B0100, nullptr, "PrepareForSystemDownload"}, {IPC::MakeHeader(0x000B, 4, 0), nullptr, "PrepareForSystemDownload"},
{0x000C0000, nullptr, "StartSystemDownload"}, {IPC::MakeHeader(0x000C, 0, 0), nullptr, "StartSystemDownload"},
{0x000D0100, nullptr, "StartTitleDownload"}, {IPC::MakeHeader(0x000D, 4, 0), nullptr, "StartTitleDownload"},
{0x000E0000, nullptr, "GetMyStatus"}, {IPC::MakeHeader(0x000E, 0, 0), nullptr, "GetMyStatus"},
{0x000F0040, nullptr, "GetConnectingNodes"}, {IPC::MakeHeader(0x000F, 1, 0), nullptr, "GetConnectingNodes"},
{0x00100040, nullptr, "GetNodeInfo"}, {IPC::MakeHeader(0x0010, 1, 0), nullptr, "GetNodeInfo"},
{0x00110000, nullptr, "GetWirelessRebootPassphrase"}, {IPC::MakeHeader(0x0011, 0, 0), nullptr, "GetWirelessRebootPassphrase"},
{0x00120000, nullptr, "StopSession"}, {IPC::MakeHeader(0x0012, 0, 0), nullptr, "StopSession"},
{0x00130100, nullptr, "GetCupVersion"}, {IPC::MakeHeader(0x0013, 4, 0), nullptr, "GetCupVersion"},
{0x00140100, nullptr, "GetDupAvailability"}, {IPC::MakeHeader(0x0014, 4, 0), nullptr, "GetDupAvailability"},
// clang-format on // clang-format on
}; };

34
src/core/hle/service/dlp/dlp_fkcl.cpp
View File

@@ -13,23 +13,23 @@ namespace Service::DLP {
DLP_FKCL::DLP_FKCL() : ServiceFramework("dlp:FKCL", 1) { DLP_FKCL::DLP_FKCL() : ServiceFramework("dlp:FKCL", 1) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
// clang-format off // clang-format off
{0x00010083, nullptr, "Initialize"}, {IPC::MakeHeader(0x0001, 2, 3), nullptr, "Initialize"},
{0x00020000, nullptr, "Finalize"}, {IPC::MakeHeader(0x0002, 0, 0), nullptr, "Finalize"},
{0x00030000, nullptr, "GetEventDesc"}, {IPC::MakeHeader(0x0003, 0, 0), nullptr, "GetEventDesc"},
{0x00040000, nullptr, "GetChannels"}, {IPC::MakeHeader(0x0004, 0, 0), nullptr, "GetChannels"},
{0x00050180, nullptr, "StartScan"}, {IPC::MakeHeader(0x0005, 6, 0), nullptr, "StartScan"},
{0x00060000, nullptr, "StopScan"}, {IPC::MakeHeader(0x0006, 0, 0), nullptr, "StopScan"},
{0x00070080, nullptr, "GetServerInfo"}, {IPC::MakeHeader(0x0007, 2, 0), nullptr, "GetServerInfo"},
{0x00080100, nullptr, "GetTitleInfo"}, {IPC::MakeHeader(0x0008, 4, 0), nullptr, "GetTitleInfo"},
{0x00090040, nullptr, "GetTitleInfoInOrder"}, {IPC::MakeHeader(0x0009, 1, 0), nullptr, "GetTitleInfoInOrder"},
{0x000A0080, nullptr, "DeleteScanInfo"}, {IPC::MakeHeader(0x000A, 2, 0), nullptr, "DeleteScanInfo"},
{0x000B0100, nullptr, "StartFakeSession"}, {IPC::MakeHeader(0x000B, 4, 0), nullptr, "StartFakeSession"},
{0x000C0000, nullptr, "GetMyStatus"}, {IPC::MakeHeader(0x000C, 0, 0), nullptr, "GetMyStatus"},
{0x000D0040, nullptr, "GetConnectingNodes"}, {IPC::MakeHeader(0x000D, 1, 0), nullptr, "GetConnectingNodes"},
{0x000E0040, nullptr, "GetNodeInfo"}, {IPC::MakeHeader(0x000E, 1, 0), nullptr, "GetNodeInfo"},
{0x000F0000, nullptr, "GetWirelessRebootPassphrase"}, {IPC::MakeHeader(0x000F, 0, 0), nullptr, "GetWirelessRebootPassphrase"},
{0x00100000, nullptr, "StopSession"}, {IPC::MakeHeader(0x0010, 0, 0), nullptr, "StopSession"},
{0x00110203, nullptr, "Initialize2"}, {IPC::MakeHeader(0x0011, 8, 3), nullptr, "Initialize2"},
// clang-format on // clang-format on
}; };

32
src/core/hle/service/dlp/dlp_srvr.cpp
View File

@@ -27,22 +27,22 @@ void DLP_SRVR::IsChild(Kernel::HLERequestContext& ctx) {
DLP_SRVR::DLP_SRVR() : ServiceFramework("dlp:SRVR", 1) { DLP_SRVR::DLP_SRVR() : ServiceFramework("dlp:SRVR", 1) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
// clang-format off // clang-format off
{0x00010183, nullptr, "Initialize"}, {IPC::MakeHeader(0x0001, 6, 3), nullptr, "Initialize"},
{0x00020000, nullptr, "Finalize"}, {IPC::MakeHeader(0x0002, 0, 0), nullptr, "Finalize"},
{0x00030000, nullptr, "GetServerState"}, {IPC::MakeHeader(0x0003, 0, 0), nullptr, "GetServerState"},
{0x00040000, nullptr, "GetEventDescription"}, {IPC::MakeHeader(0x0004, 0, 0), nullptr, "GetEventDescription"},
{0x00050080, nullptr, "StartAccepting"}, {IPC::MakeHeader(0x0005, 2, 0), nullptr, "StartAccepting"},
{0x00060000, nullptr, "EndAccepting"}, {IPC::MakeHeader(0x0006, 0, 0), nullptr, "EndAccepting"},
{0x00070000, nullptr, "StartDistribution"}, {IPC::MakeHeader(0x0007, 0, 0), nullptr, "StartDistribution"},
{0x000800C0, nullptr, "SendWirelessRebootPassphrase"}, {IPC::MakeHeader(0x0008, 3, 0), nullptr, "SendWirelessRebootPassphrase"},
{0x00090040, nullptr, "AcceptClient"}, {IPC::MakeHeader(0x0009, 1, 0), nullptr, "AcceptClient"},
{0x000A0040, nullptr, "DisconnectClient"}, {IPC::MakeHeader(0x000A, 1, 0), nullptr, "DisconnectClient"},
{0x000B0042, nullptr, "GetConnectingClients"}, {IPC::MakeHeader(0x000B, 1, 2), nullptr, "GetConnectingClients"},
{0x000C0040, nullptr, "GetClientInfo"}, {IPC::MakeHeader(0x000C, 1, 0), nullptr, "GetClientInfo"},
{0x000D0040, nullptr, "GetClientState"}, {IPC::MakeHeader(0x000D, 1, 0), nullptr, "GetClientState"},
{0x000E0040, &DLP_SRVR::IsChild, "IsChild"}, {IPC::MakeHeader(0x000E, 1, 0), &DLP_SRVR::IsChild, "IsChild"},
{0x000F0303, nullptr, "InitializeWithName"}, {IPC::MakeHeader(0x000F, 12, 3), nullptr, "InitializeWithName"},
{0x00100000, nullptr, "GetDupNoticeNeed"}, {IPC::MakeHeader(0x0010, 0, 0), nullptr, "GetDupNoticeNeed"},
// clang-format on // clang-format on
}; };

66
src/core/hle/service/dsp/dsp_dsp.cpp
View File

@@ -347,39 +347,39 @@ DSP_DSP::DSP_DSP(Core::System& system)
: ServiceFramework("dsp::DSP", DefaultMaxSessions), system(system) { : ServiceFramework("dsp::DSP", DefaultMaxSessions), system(system) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
// clang-format off // clang-format off
{0x00010040, &DSP_DSP::RecvData, "RecvData"}, {IPC::MakeHeader(0x0001, 1, 0), &DSP_DSP::RecvData, "RecvData"},
{0x00020040, &DSP_DSP::RecvDataIsReady, "RecvDataIsReady"}, {IPC::MakeHeader(0x0002, 1, 0), &DSP_DSP::RecvDataIsReady, "RecvDataIsReady"},
{0x00030080, nullptr, "SendData"}, {IPC::MakeHeader(0x0003, 2, 0), nullptr, "SendData"},
{0x00040040, nullptr, "SendDataIsEmpty"}, {IPC::MakeHeader(0x0004, 1, 0), nullptr, "SendDataIsEmpty"},
{0x000500C2, nullptr, "SendFifoEx"}, {IPC::MakeHeader(0x0005, 3, 2), nullptr, "SendFifoEx"},
{0x000600C0, nullptr, "RecvFifoEx"}, {IPC::MakeHeader(0x0006, 3, 0), nullptr, "RecvFifoEx"},
{0x00070040, &DSP_DSP::SetSemaphore, "SetSemaphore"}, {IPC::MakeHeader(0x0007, 1, 0), &DSP_DSP::SetSemaphore, "SetSemaphore"},
{0x00080000, nullptr, "GetSemaphore"}, {IPC::MakeHeader(0x0008, 0, 0), nullptr, "GetSemaphore"},
{0x00090040, nullptr, "ClearSemaphore"}, {IPC::MakeHeader(0x0009, 1, 0), nullptr, "ClearSemaphore"},
{0x000A0040, nullptr, "MaskSemaphore"}, {IPC::MakeHeader(0x000A, 1, 0), nullptr, "MaskSemaphore"},
{0x000B0000, nullptr, "CheckSemaphoreRequest"}, {IPC::MakeHeader(0x000B, 0, 0), nullptr, "CheckSemaphoreRequest"},
{0x000C0040, &DSP_DSP::ConvertProcessAddressFromDspDram, "ConvertProcessAddressFromDspDram"}, {IPC::MakeHeader(0x000C, 1, 0), &DSP_DSP::ConvertProcessAddressFromDspDram, "ConvertProcessAddressFromDspDram"},
{0x000D0082, &DSP_DSP::WriteProcessPipe, "WriteProcessPipe"}, {IPC::MakeHeader(0x000D, 2, 2), &DSP_DSP::WriteProcessPipe, "WriteProcessPipe"},
{0x000E00C0, &DSP_DSP::ReadPipe, "ReadPipe"}, {IPC::MakeHeader(0x000E, 3, 0), &DSP_DSP::ReadPipe, "ReadPipe"},
{0x000F0080, &DSP_DSP::GetPipeReadableSize, "GetPipeReadableSize"}, {IPC::MakeHeader(0x000F, 2, 0), &DSP_DSP::GetPipeReadableSize, "GetPipeReadableSize"},
{0x001000C0, &DSP_DSP::ReadPipeIfPossible, "ReadPipeIfPossible"}, {IPC::MakeHeader(0x0010, 3, 0), &DSP_DSP::ReadPipeIfPossible, "ReadPipeIfPossible"},
{0x001100C2, &DSP_DSP::LoadComponent, "LoadComponent"}, {IPC::MakeHeader(0x0011, 3, 2), &DSP_DSP::LoadComponent, "LoadComponent"},
{0x00120000, &DSP_DSP::UnloadComponent, "UnloadComponent"}, {IPC::MakeHeader(0x0012, 0, 0), &DSP_DSP::UnloadComponent, "UnloadComponent"},
{0x00130082, &DSP_DSP::FlushDataCache, "FlushDataCache"}, {IPC::MakeHeader(0x0013, 2, 2), &DSP_DSP::FlushDataCache, "FlushDataCache"},
{0x00140082, &DSP_DSP::InvalidateDataCache, "InvalidateDCache"}, {IPC::MakeHeader(0x0014, 2, 2), &DSP_DSP::InvalidateDataCache, "InvalidateDCache"},
{0x00150082, &DSP_DSP::RegisterInterruptEvents, "RegisterInterruptEvents"}, {IPC::MakeHeader(0x0015, 2, 2), &DSP_DSP::RegisterInterruptEvents, "RegisterInterruptEvents"},
{0x00160000, &DSP_DSP::GetSemaphoreEventHandle, "GetSemaphoreEventHandle"}, {IPC::MakeHeader(0x0016, 0, 0), &DSP_DSP::GetSemaphoreEventHandle, "GetSemaphoreEventHandle"},
{0x00170040, &DSP_DSP::SetSemaphoreMask, "SetSemaphoreMask"}, {IPC::MakeHeader(0x0017, 1, 0), &DSP_DSP::SetSemaphoreMask, "SetSemaphoreMask"},
{0x00180040, nullptr, "GetPhysicalAddress"}, {IPC::MakeHeader(0x0018, 1, 0), nullptr, "GetPhysicalAddress"},
{0x00190040, nullptr, "GetVirtualAddress"}, {IPC::MakeHeader(0x0019, 1, 0), nullptr, "GetVirtualAddress"},
{0x001A0042, nullptr, "SetIirFilterI2S1_cmd1"}, {IPC::MakeHeader(0x001A, 1, 2), nullptr, "SetIirFilterI2S1_cmd1"},
{0x001B0042, nullptr, "SetIirFilterI2S1_cmd2"}, {IPC::MakeHeader(0x001B, 1, 2), nullptr, "SetIirFilterI2S1_cmd2"},
{0x001C0082, nullptr, "SetIirFilterEQ"}, {IPC::MakeHeader(0x001C, 2, 2), nullptr, "SetIirFilterEQ"},
{0x001D00C0, nullptr, "ReadMultiEx_SPI2"}, {IPC::MakeHeader(0x001D, 3, 0), nullptr, "ReadMultiEx_SPI2"},
{0x001E00C2, nullptr, "WriteMultiEx_SPI2"}, {IPC::MakeHeader(0x001E, 3, 2), nullptr, "WriteMultiEx_SPI2"},
{0x001F0000, &DSP_DSP::GetHeadphoneStatus, "GetHeadphoneStatus"}, {IPC::MakeHeader(0x001F, 0, 0), &DSP_DSP::GetHeadphoneStatus, "GetHeadphoneStatus"},
{0x00200040, &DSP_DSP::ForceHeadphoneOut, "ForceHeadphoneOut"}, {IPC::MakeHeader(0x0020, 1, 0), &DSP_DSP::ForceHeadphoneOut, "ForceHeadphoneOut"},
{0x00210000, nullptr, "GetIsDspOccupied"}, {IPC::MakeHeader(0x0021, 0, 0), nullptr, "GetIsDspOccupied"},
// clang-format on // clang-format on
}; };

6
src/core/hle/service/err_f.cpp
View File

@@ -249,8 +249,10 @@ void ERR_F::ThrowFatalError(Kernel::HLERequestContext& ctx) {
ERR_F::ERR_F(Core::System& system) : ServiceFramework("err:f", 1), system(system) { ERR_F::ERR_F(Core::System& system) : ServiceFramework("err:f", 1), system(system) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x00010800, &ERR_F::ThrowFatalError, "ThrowFatalError"}, // clang-format off
{0x00020042, nullptr, "SetUserString"}, {IPC::MakeHeader(0x0001, 32, 0), &ERR_F::ThrowFatalError, "ThrowFatalError"},
{IPC::MakeHeader(0x0002, 1, 2), nullptr, "SetUserString"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

224
src/core/hle/service/fs/fs_user.cpp
View File

@@ -891,117 +891,119 @@ ResultVal<u16> FS_USER::GetSpecialContentIndexFromTMD(MediaType media_type, u64
FS_USER::FS_USER(Core::System& system) FS_USER::FS_USER(Core::System& system)
: ServiceFramework("fs:USER", 30), system(system), archives(system.ArchiveManager()) { : ServiceFramework("fs:USER", 30), system(system), archives(system.ArchiveManager()) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x000100C6, nullptr, "Dummy1"}, // clang-format off
{0x040100C4, nullptr, "Control"}, {IPC::MakeHeader(0x0001, 3, 6), nullptr, "Dummy1"},
{0x08010002, &FS_USER::Initialize, "Initialize"}, {IPC::MakeHeader(0x0401, 3, 4), nullptr, "Control"},
{0x080201C2, &FS_USER::OpenFile, "OpenFile"}, {IPC::MakeHeader(0x0801, 0, 2), &FS_USER::Initialize, "Initialize"},
{0x08030204, &FS_USER::OpenFileDirectly, "OpenFileDirectly"}, {IPC::MakeHeader(0x0802, 7, 2), &FS_USER::OpenFile, "OpenFile"},
{0x08040142, &FS_USER::DeleteFile, "DeleteFile"}, {IPC::MakeHeader(0x0803, 8, 4), &FS_USER::OpenFileDirectly, "OpenFileDirectly"},
{0x08050244, &FS_USER::RenameFile, "RenameFile"}, {IPC::MakeHeader(0x0804, 5, 2), &FS_USER::DeleteFile, "DeleteFile"},
{0x08060142, &FS_USER::DeleteDirectory, "DeleteDirectory"}, {IPC::MakeHeader(0x0805, 9, 4), &FS_USER::RenameFile, "RenameFile"},
{0x08070142, &FS_USER::DeleteDirectoryRecursively, "DeleteDirectoryRecursively"}, {IPC::MakeHeader(0x0806, 5, 2), &FS_USER::DeleteDirectory, "DeleteDirectory"},
{0x08080202, &FS_USER::CreateFile, "CreateFile"}, {IPC::MakeHeader(0x0807, 5, 2), &FS_USER::DeleteDirectoryRecursively, "DeleteDirectoryRecursively"},
{0x08090182, &FS_USER::CreateDirectory, "CreateDirectory"}, {IPC::MakeHeader(0x0808, 8, 2), &FS_USER::CreateFile, "CreateFile"},
{0x080A0244, &FS_USER::RenameDirectory, "RenameDirectory"}, {IPC::MakeHeader(0x0809, 6, 2), &FS_USER::CreateDirectory, "CreateDirectory"},
{0x080B0102, &FS_USER::OpenDirectory, "OpenDirectory"}, {IPC::MakeHeader(0x080A, 9, 4), &FS_USER::RenameDirectory, "RenameDirectory"},
{0x080C00C2, &FS_USER::OpenArchive, "OpenArchive"}, {IPC::MakeHeader(0x080B, 4, 2), &FS_USER::OpenDirectory, "OpenDirectory"},
{0x080D0144, nullptr, "ControlArchive"}, {IPC::MakeHeader(0x080C, 3, 2), &FS_USER::OpenArchive, "OpenArchive"},
{0x080E0080, &FS_USER::CloseArchive, "CloseArchive"}, {IPC::MakeHeader(0x080D, 5, 4), nullptr, "ControlArchive"},
{0x080F0180, &FS_USER::FormatThisUserSaveData, "FormatThisUserSaveData"}, {IPC::MakeHeader(0x080E, 2, 0), &FS_USER::CloseArchive, "CloseArchive"},
{0x08100200, &FS_USER::CreateLegacySystemSaveData, "CreateLegacySystemSaveData"}, {IPC::MakeHeader(0x080F, 6, 0), &FS_USER::FormatThisUserSaveData, "FormatThisUserSaveData"},
{0x08110040, nullptr, "DeleteSystemSaveData"}, {IPC::MakeHeader(0x0810, 8, 0), &FS_USER::CreateLegacySystemSaveData, "CreateLegacySystemSaveData"},
{0x08120080, &FS_USER::GetFreeBytes, "GetFreeBytes"}, {IPC::MakeHeader(0x0811, 1, 0), nullptr, "DeleteSystemSaveData"},
{0x08130000, nullptr, "GetCardType"}, {IPC::MakeHeader(0x0812, 2, 0), &FS_USER::GetFreeBytes, "GetFreeBytes"},
{0x08140000, &FS_USER::GetSdmcArchiveResource, "GetSdmcArchiveResource"}, {IPC::MakeHeader(0x0813, 0, 0), nullptr, "GetCardType"},
{0x08150000, &FS_USER::GetNandArchiveResource, "GetNandArchiveResource"}, {IPC::MakeHeader(0x0814, 0, 0), &FS_USER::GetSdmcArchiveResource, "GetSdmcArchiveResource"},
{0x08160000, nullptr, "GetSdmcFatfsError"}, {IPC::MakeHeader(0x0815, 0, 0), &FS_USER::GetNandArchiveResource, "GetNandArchiveResource"},
{0x08170000, &FS_USER::IsSdmcDetected, "IsSdmcDetected"}, {IPC::MakeHeader(0x0816, 0, 0), nullptr, "GetSdmcFatfsError"},
{0x08180000, &FS_USER::IsSdmcWriteable, "IsSdmcWritable"}, {IPC::MakeHeader(0x0817, 0, 0), &FS_USER::IsSdmcDetected, "IsSdmcDetected"},
{0x08190042, nullptr, "GetSdmcCid"}, {IPC::MakeHeader(0x0818, 0, 0), &FS_USER::IsSdmcWriteable, "IsSdmcWritable"},
{0x081A0042, nullptr, "GetNandCid"}, {IPC::MakeHeader(0x0819, 1, 2), nullptr, "GetSdmcCid"},
{0x081B0000, nullptr, "GetSdmcSpeedInfo"}, {IPC::MakeHeader(0x081A, 1, 2), nullptr, "GetNandCid"},
{0x081C0000, nullptr, "GetNandSpeedInfo"}, {IPC::MakeHeader(0x081B, 0, 0), nullptr, "GetSdmcSpeedInfo"},
{0x081D0042, nullptr, "GetSdmcLog"}, {IPC::MakeHeader(0x081C, 0, 0), nullptr, "GetNandSpeedInfo"},
{0x081E0042, nullptr, "GetNandLog"}, {IPC::MakeHeader(0x081D, 1, 2), nullptr, "GetSdmcLog"},
{0x081F0000, nullptr, "ClearSdmcLog"}, {IPC::MakeHeader(0x081E, 1, 2), nullptr, "GetNandLog"},
{0x08200000, nullptr, "ClearNandLog"}, {IPC::MakeHeader(0x081F, 0, 0), nullptr, "ClearSdmcLog"},
{0x08210000, &FS_USER::CardSlotIsInserted, "CardSlotIsInserted"}, {IPC::MakeHeader(0x0820, 0, 0), nullptr, "ClearNandLog"},
{0x08220000, nullptr, "CardSlotPowerOn"}, {IPC::MakeHeader(0x0821, 0, 0), &FS_USER::CardSlotIsInserted, "CardSlotIsInserted"},
{0x08230000, nullptr, "CardSlotPowerOff"}, {IPC::MakeHeader(0x0822, 0, 0), nullptr, "CardSlotPowerOn"},
{0x08240000, nullptr, "CardSlotGetCardIFPowerStatus"}, {IPC::MakeHeader(0x0823, 0, 0), nullptr, "CardSlotPowerOff"},
{0x08250040, nullptr, "CardNorDirectCommand"}, {IPC::MakeHeader(0x0824, 0, 0), nullptr, "CardSlotGetCardIFPowerStatus"},
{0x08260080, nullptr, "CardNorDirectCommandWithAddress"}, {IPC::MakeHeader(0x0825, 1, 0), nullptr, "CardNorDirectCommand"},
{0x08270082, nullptr, "CardNorDirectRead"}, {IPC::MakeHeader(0x0826, 2, 0), nullptr, "CardNorDirectCommandWithAddress"},
{0x082800C2, nullptr, "CardNorDirectReadWithAddress"}, {IPC::MakeHeader(0x0827, 2, 2), nullptr, "CardNorDirectRead"},
{0x08290082, nullptr, "CardNorDirectWrite"}, {IPC::MakeHeader(0x0828, 3, 2), nullptr, "CardNorDirectReadWithAddress"},
{0x082A00C2, nullptr, "CardNorDirectWriteWithAddress"}, {IPC::MakeHeader(0x0829, 2, 2), nullptr, "CardNorDirectWrite"},
{0x082B00C2, nullptr, "CardNorDirectRead_4xIO"}, {IPC::MakeHeader(0x082A, 3, 2), nullptr, "CardNorDirectWriteWithAddress"},
{0x082C0082, nullptr, "CardNorDirectCpuWriteWithoutVerify"}, {IPC::MakeHeader(0x082B, 3, 2), nullptr, "CardNorDirectRead_4xIO"},
{0x082D0040, nullptr, "CardNorDirectSectorEraseWithoutVerify"}, {IPC::MakeHeader(0x082C, 2, 2), nullptr, "CardNorDirectCpuWriteWithoutVerify"},
{0x082E0040, nullptr, "GetProductInfo"}, {IPC::MakeHeader(0x082D, 1, 0), nullptr, "CardNorDirectSectorEraseWithoutVerify"},
{0x082F0040, &FS_USER::GetProgramLaunchInfo, "GetProgramLaunchInfo"}, {IPC::MakeHeader(0x082E, 1, 0), nullptr, "GetProductInfo"},
{0x08300182, &FS_USER::ObsoletedCreateExtSaveData, "Obsoleted_3_0_CreateExtSaveData"}, {IPC::MakeHeader(0x082F, 1, 0), &FS_USER::GetProgramLaunchInfo, "GetProgramLaunchInfo"},
{0x08310180, nullptr, "CreateSharedExtSaveData"}, {IPC::MakeHeader(0x0830, 6, 2), &FS_USER::ObsoletedCreateExtSaveData, "Obsoleted_3_0_CreateExtSaveData"},
{0x08320102, nullptr, "ReadExtSaveDataIcon"}, {IPC::MakeHeader(0x0831, 6, 0), nullptr, "CreateSharedExtSaveData"},
{0x08330082, nullptr, "EnumerateExtSaveData"}, {IPC::MakeHeader(0x0832, 4, 2), nullptr, "ReadExtSaveDataIcon"},
{0x08340082, nullptr, "EnumerateSharedExtSaveData"}, {IPC::MakeHeader(0x0833, 2, 2), nullptr, "EnumerateExtSaveData"},
{0x08350080, &FS_USER::ObsoletedDeleteExtSaveData, "Obsoleted_3_0_DeleteExtSaveData"}, {IPC::MakeHeader(0x0834, 2, 2), nullptr, "EnumerateSharedExtSaveData"},
{0x08360080, nullptr, "DeleteSharedExtSaveData"}, {IPC::MakeHeader(0x0835, 2, 0), &FS_USER::ObsoletedDeleteExtSaveData, "Obsoleted_3_0_DeleteExtSaveData"},
{0x08370040, nullptr, "SetCardSpiBaudRate"}, {IPC::MakeHeader(0x0836, 2, 0), nullptr, "DeleteSharedExtSaveData"},
{0x08380040, nullptr, "SetCardSpiBusMode"}, {IPC::MakeHeader(0x0837, 1, 0), nullptr, "SetCardSpiBaudRate"},
{0x08390000, nullptr, "SendInitializeInfoTo9"}, {IPC::MakeHeader(0x0838, 1, 0), nullptr, "SetCardSpiBusMode"},
{0x083A0100, &FS_USER::GetSpecialContentIndex, "GetSpecialContentIndex"}, {IPC::MakeHeader(0x0839, 0, 0), nullptr, "SendInitializeInfoTo9"},
{0x083B00C2, nullptr, "GetLegacyRomHeader"}, {IPC::MakeHeader(0x083A, 4, 0), &FS_USER::GetSpecialContentIndex, "GetSpecialContentIndex"},
{0x083C00C2, nullptr, "GetLegacyBannerData"}, {IPC::MakeHeader(0x083B, 3, 2), nullptr, "GetLegacyRomHeader"},
{0x083D0100, nullptr, "CheckAuthorityToAccessExtSaveData"}, {IPC::MakeHeader(0x083C, 3, 2), nullptr, "GetLegacyBannerData"},
{0x083E00C2, nullptr, "QueryTotalQuotaSize"}, {IPC::MakeHeader(0x083D, 4, 0), nullptr, "CheckAuthorityToAccessExtSaveData"},
{0x083F00C0, nullptr, "GetExtDataBlockSize"}, {IPC::MakeHeader(0x083E, 3, 2), nullptr, "QueryTotalQuotaSize"},
{0x08400040, nullptr, "AbnegateAccessRight"}, {IPC::MakeHeader(0x083F, 3, 0), nullptr, "GetExtDataBlockSize"},
{0x08410000, nullptr, "DeleteSdmcRoot"}, {IPC::MakeHeader(0x0840, 1, 0), nullptr, "AbnegateAccessRight"},
{0x08420040, nullptr, "DeleteAllExtSaveDataOnNand"}, {IPC::MakeHeader(0x0841, 0, 0), nullptr, "DeleteSdmcRoot"},
{0x08430000, nullptr, "InitializeCtrFileSystem"}, {IPC::MakeHeader(0x0842, 1, 0), nullptr, "DeleteAllExtSaveDataOnNand"},
{0x08440000, nullptr, "CreateSeed"}, {IPC::MakeHeader(0x0843, 0, 0), nullptr, "InitializeCtrFileSystem"},
{0x084500C2, &FS_USER::GetFormatInfo, "GetFormatInfo"}, {IPC::MakeHeader(0x0844, 0, 0), nullptr, "CreateSeed"},
{0x08460102, nullptr, "GetLegacyRomHeader2"}, {IPC::MakeHeader(0x0845, 3, 2), &FS_USER::GetFormatInfo, "GetFormatInfo"},
{0x08470180, nullptr, "FormatCtrCardUserSaveData"}, {IPC::MakeHeader(0x0846, 4, 2), nullptr, "GetLegacyRomHeader2"},
{0x08480042, nullptr, "GetSdmcCtrRootPath"}, {IPC::MakeHeader(0x0847, 6, 0), nullptr, "FormatCtrCardUserSaveData"},
{0x08490040, &FS_USER::GetArchiveResource, "GetArchiveResource"}, {IPC::MakeHeader(0x0848, 1, 2), nullptr, "GetSdmcCtrRootPath"},
{0x084A0002, nullptr, "ExportIntegrityVerificationSeed"}, {IPC::MakeHeader(0x0849, 1, 0), &FS_USER::GetArchiveResource, "GetArchiveResource"},
{0x084B0002, nullptr, "ImportIntegrityVerificationSeed"}, {IPC::MakeHeader(0x084A, 0, 2), nullptr, "ExportIntegrityVerificationSeed"},
{0x084C0242, &FS_USER::FormatSaveData, "FormatSaveData"}, {IPC::MakeHeader(0x084B, 0, 2), nullptr, "ImportIntegrityVerificationSeed"},
{0x084D0102, nullptr, "GetLegacySubBannerData"}, {IPC::MakeHeader(0x084C, 9, 2), &FS_USER::FormatSaveData, "FormatSaveData"},
{0x084E0342, nullptr, "UpdateSha256Context"}, {IPC::MakeHeader(0x084D, 4, 2), nullptr, "GetLegacySubBannerData"},
{0x084F0102, nullptr, "ReadSpecialFile"}, {IPC::MakeHeader(0x084E, 13, 2), nullptr, "UpdateSha256Context"},
{0x08500040, nullptr, "GetSpecialFileSize"}, {IPC::MakeHeader(0x084F, 4, 2), nullptr, "ReadSpecialFile"},
{0x08510242, &FS_USER::CreateExtSaveData, "CreateExtSaveData"}, {IPC::MakeHeader(0x0850, 1, 0), nullptr, "GetSpecialFileSize"},
{0x08520100, &FS_USER::DeleteExtSaveData, "DeleteExtSaveData"}, {IPC::MakeHeader(0x0851, 9, 2), &FS_USER::CreateExtSaveData, "CreateExtSaveData"},
{0x08530142, nullptr, "ReadExtSaveDataIcon"}, {IPC::MakeHeader(0x0852, 4, 0), &FS_USER::DeleteExtSaveData, "DeleteExtSaveData"},
{0x085400C0, nullptr, "GetExtDataBlockSize"}, {IPC::MakeHeader(0x0853, 5, 2), nullptr, "ReadExtSaveDataIcon"},
{0x08550102, nullptr, "EnumerateExtSaveData"}, {IPC::MakeHeader(0x0854, 3, 0), nullptr, "GetExtDataBlockSize"},
{0x08560240, &FS_USER::CreateSystemSaveData, "CreateSystemSaveData"}, {IPC::MakeHeader(0x0855, 4, 2), nullptr, "EnumerateExtSaveData"},
{0x08570080, &FS_USER::DeleteSystemSaveData, "DeleteSystemSaveData"}, {IPC::MakeHeader(0x0856, 9, 0), &FS_USER::CreateSystemSaveData, "CreateSystemSaveData"},
{0x08580000, nullptr, "StartDeviceMoveAsSource"}, {IPC::MakeHeader(0x0857, 2, 0), &FS_USER::DeleteSystemSaveData, "DeleteSystemSaveData"},
{0x08590200, nullptr, "StartDeviceMoveAsDestination"}, {IPC::MakeHeader(0x0858, 0, 0), nullptr, "StartDeviceMoveAsSource"},
{0x085A00C0, nullptr, "SetArchivePriority"}, {IPC::MakeHeader(0x0859, 8, 0), nullptr, "StartDeviceMoveAsDestination"},
{0x085B0080, nullptr, "GetArchivePriority"}, {IPC::MakeHeader(0x085A, 3, 0), nullptr, "SetArchivePriority"},
{0x085C00C0, nullptr, "SetCtrCardLatencyParameter"}, {IPC::MakeHeader(0x085B, 2, 0), nullptr, "GetArchivePriority"},
{0x085D01C0, nullptr, "SetFsCompatibilityInfo"}, {IPC::MakeHeader(0x085C, 3, 0), nullptr, "SetCtrCardLatencyParameter"},
{0x085E0040, nullptr, "ResetCardCompatibilityParameter"}, {IPC::MakeHeader(0x085D, 7, 0), nullptr, "SetFsCompatibilityInfo"},
{0x085F0040, nullptr, "SwitchCleanupInvalidSaveData"}, {IPC::MakeHeader(0x085E, 1, 0), nullptr, "ResetCardCompatibilityParameter"},
{0x08600042, nullptr, "EnumerateSystemSaveData"}, {IPC::MakeHeader(0x085F, 1, 0), nullptr, "SwitchCleanupInvalidSaveData"},
{0x08610042, &FS_USER::InitializeWithSdkVersion, "InitializeWithSdkVersion"}, {IPC::MakeHeader(0x0860, 1, 2), nullptr, "EnumerateSystemSaveData"},
{0x08620040, &FS_USER::SetPriority, "SetPriority"}, {IPC::MakeHeader(0x0861, 1, 2), &FS_USER::InitializeWithSdkVersion, "InitializeWithSdkVersion"},
{0x08630000, &FS_USER::GetPriority, "GetPriority"}, {IPC::MakeHeader(0x0862, 1, 0), &FS_USER::SetPriority, "SetPriority"},
{0x08640000, nullptr, "GetNandInfo"}, {IPC::MakeHeader(0x0863, 0, 0), &FS_USER::GetPriority, "GetPriority"},
{0x08650140, &FS_USER::SetSaveDataSecureValue, "SetSaveDataSecureValue"}, {IPC::MakeHeader(0x0864, 0, 0), nullptr, "GetNandInfo"},
{0x086600C0, &FS_USER::GetSaveDataSecureValue, "GetSaveDataSecureValue"}, {IPC::MakeHeader(0x0865, 5, 0), &FS_USER::SetSaveDataSecureValue, "SetSaveDataSecureValue"},
{0x086700C4, nullptr, "ControlSecureSave"}, {IPC::MakeHeader(0x0866, 3, 0), &FS_USER::GetSaveDataSecureValue, "GetSaveDataSecureValue"},
{0x08680000, nullptr, "GetMediaType"}, {IPC::MakeHeader(0x0867, 3, 4), nullptr, "ControlSecureSave"},
{0x08690000, nullptr, "GetNandEraseCount"}, {IPC::MakeHeader(0x0868, 0, 0), nullptr, "GetMediaType"},
{0x086A0082, nullptr, "ReadNandReport"}, {IPC::MakeHeader(0x0869, 0, 0), nullptr, "GetNandEraseCount"},
{0x087A0180, &FS_USER::AddSeed, "AddSeed"}, {IPC::MakeHeader(0x086A, 2, 2), nullptr, "ReadNandReport"},
{0x087D0000, &FS_USER::GetNumSeeds, "GetNumSeeds"}, {IPC::MakeHeader(0x087A, 6, 0), &FS_USER::AddSeed, "AddSeed"},
{0x088600C0, nullptr, "CheckUpdatedDat"}, {IPC::MakeHeader(0x087D, 0, 0), &FS_USER::GetNumSeeds, "GetNumSeeds"},
{IPC::MakeHeader(0x0886, 3, 0), nullptr, "CheckUpdatedDat"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

64
src/core/hle/service/gsp/gsp_gpu.cpp
View File

@@ -820,37 +820,39 @@ SessionData* GSP_GPU::FindRegisteredThreadData(u32 thread_id) {
GSP_GPU::GSP_GPU(Core::System& system) : ServiceFramework("gsp::Gpu", 2), system(system) { GSP_GPU::GSP_GPU(Core::System& system) : ServiceFramework("gsp::Gpu", 2), system(system) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x00010082, &GSP_GPU::WriteHWRegs, "WriteHWRegs"}, // clang-format off
{0x00020084, &GSP_GPU::WriteHWRegsWithMask, "WriteHWRegsWithMask"}, {IPC::MakeHeader(0x0001, 2, 2), &GSP_GPU::WriteHWRegs, "WriteHWRegs"},
{0x00030082, nullptr, "WriteHWRegRepeat"}, {IPC::MakeHeader(0x0002, 2, 4), &GSP_GPU::WriteHWRegsWithMask, "WriteHWRegsWithMask"},
{0x00040080, &GSP_GPU::ReadHWRegs, "ReadHWRegs"}, {IPC::MakeHeader(0x0003, 2, 2), nullptr, "WriteHWRegRepeat"},
{0x00050200, &GSP_GPU::SetBufferSwap, "SetBufferSwap"}, {IPC::MakeHeader(0x0004, 2, 0), &GSP_GPU::ReadHWRegs, "ReadHWRegs"},
{0x00060082, nullptr, "SetCommandList"}, {IPC::MakeHeader(0x0005, 8, 0), &GSP_GPU::SetBufferSwap, "SetBufferSwap"},
{0x000700C2, nullptr, "RequestDma"}, {IPC::MakeHeader(0x0006, 2, 2), nullptr, "SetCommandList"},
{0x00080082, &GSP_GPU::FlushDataCache, "FlushDataCache"}, {IPC::MakeHeader(0x0007, 3, 2), nullptr, "RequestDma"},
{0x00090082, &GSP_GPU::InvalidateDataCache, "InvalidateDataCache"}, {IPC::MakeHeader(0x0008, 2, 2), &GSP_GPU::FlushDataCache, "FlushDataCache"},
{0x000A0044, nullptr, "RegisterInterruptEvents"}, {IPC::MakeHeader(0x0009, 2, 2), &GSP_GPU::InvalidateDataCache, "InvalidateDataCache"},
{0x000B0040, &GSP_GPU::SetLcdForceBlack, "SetLcdForceBlack"}, {IPC::MakeHeader(0x000A, 1, 4), nullptr, "RegisterInterruptEvents"},
{0x000C0000, &GSP_GPU::TriggerCmdReqQueue, "TriggerCmdReqQueue"}, {IPC::MakeHeader(0x000B, 1, 0), &GSP_GPU::SetLcdForceBlack, "SetLcdForceBlack"},
{0x000D0140, nullptr, "SetDisplayTransfer"}, {IPC::MakeHeader(0x000C, 0, 0), &GSP_GPU::TriggerCmdReqQueue, "TriggerCmdReqQueue"},
{0x000E0180, nullptr, "SetTextureCopy"}, {IPC::MakeHeader(0x000D, 5, 0), nullptr, "SetDisplayTransfer"},
{0x000F0200, nullptr, "SetMemoryFill"}, {IPC::MakeHeader(0x000E, 6, 0), nullptr, "SetTextureCopy"},
{0x00100040, &GSP_GPU::SetAxiConfigQoSMode, "SetAxiConfigQoSMode"}, {IPC::MakeHeader(0x000F, 8, 0), nullptr, "SetMemoryFill"},
{0x00110040, nullptr, "SetPerfLogMode"}, {IPC::MakeHeader(0x0010, 1, 0), &GSP_GPU::SetAxiConfigQoSMode, "SetAxiConfigQoSMode"},
{0x00120000, nullptr, "GetPerfLog"}, {IPC::MakeHeader(0x0011, 1, 0), nullptr, "SetPerfLogMode"},
{0x00130042, &GSP_GPU::RegisterInterruptRelayQueue, "RegisterInterruptRelayQueue"}, {IPC::MakeHeader(0x0012, 0, 0), nullptr, "GetPerfLog"},
{0x00140000, &GSP_GPU::UnregisterInterruptRelayQueue, "UnregisterInterruptRelayQueue"}, {IPC::MakeHeader(0x0013, 1, 2), &GSP_GPU::RegisterInterruptRelayQueue, "RegisterInterruptRelayQueue"},
{0x00150002, nullptr, "TryAcquireRight"}, {IPC::MakeHeader(0x0014, 0, 0), &GSP_GPU::UnregisterInterruptRelayQueue, "UnregisterInterruptRelayQueue"},
{0x00160042, &GSP_GPU::AcquireRight, "AcquireRight"}, {IPC::MakeHeader(0x0015, 0, 2), nullptr, "TryAcquireRight"},
{0x00170000, &GSP_GPU::ReleaseRight, "ReleaseRight"}, {IPC::MakeHeader(0x0016, 1, 2), &GSP_GPU::AcquireRight, "AcquireRight"},
{0x00180000, &GSP_GPU::ImportDisplayCaptureInfo, "ImportDisplayCaptureInfo"}, {IPC::MakeHeader(0x0017, 0, 0), &GSP_GPU::ReleaseRight, "ReleaseRight"},
{0x00190000, &GSP_GPU::SaveVramSysArea, "SaveVramSysArea"}, {IPC::MakeHeader(0x0018, 0, 0), &GSP_GPU::ImportDisplayCaptureInfo, "ImportDisplayCaptureInfo"},
{0x001A0000, &GSP_GPU::RestoreVramSysArea, "RestoreVramSysArea"}, {IPC::MakeHeader(0x0019, 0, 0), &GSP_GPU::SaveVramSysArea, "SaveVramSysArea"},
{0x001B0000, nullptr, "ResetGpuCore"}, {IPC::MakeHeader(0x001A, 0, 0), &GSP_GPU::RestoreVramSysArea, "RestoreVramSysArea"},
{0x001C0040, &GSP_GPU::SetLedForceOff, "SetLedForceOff"}, {IPC::MakeHeader(0x001B, 0, 0), nullptr, "ResetGpuCore"},
{0x001D0040, nullptr, "SetTestCommand"}, {IPC::MakeHeader(0x001C, 1, 0), &GSP_GPU::SetLedForceOff, "SetLedForceOff"},
{0x001E0080, nullptr, "SetInternalPriorities"}, {IPC::MakeHeader(0x001D, 1, 0), nullptr, "SetTestCommand"},
{0x001F0082, &GSP_GPU::StoreDataCache, "StoreDataCache"}, {IPC::MakeHeader(0x001E, 2, 0), nullptr, "SetInternalPriorities"},
{IPC::MakeHeader(0x001F, 2, 2), &GSP_GPU::StoreDataCache, "StoreDataCache"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);

20
src/core/hle/service/gsp/gsp_lcd.cpp
View File

@@ -12,15 +12,17 @@ namespace Service::GSP {
GSP_LCD::GSP_LCD() : ServiceFramework("gsp::Lcd") { GSP_LCD::GSP_LCD() : ServiceFramework("gsp::Lcd") {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x000A0080, nullptr, "SetBrightnessRaw"}, // clang-format off
{0x000B0080, nullptr, "SetBrightness"}, {IPC::MakeHeader(0x000A, 2, 0), nullptr, "SetBrightnessRaw"},
{0x000F0000, nullptr, "PowerOnAllBacklights"}, {IPC::MakeHeader(0x000B, 2, 0), nullptr, "SetBrightness"},
{0x00100000, nullptr, "PowerOffAllBacklights"}, {IPC::MakeHeader(0x000F, 0, 0), nullptr, "PowerOnAllBacklights"},
{0x00110040, nullptr, "PowerOnBacklight"}, {IPC::MakeHeader(0x0010, 0, 0), nullptr, "PowerOffAllBacklights"},
{0x00120040, nullptr, "PowerOffBacklight"}, {IPC::MakeHeader(0x0011, 1, 0), nullptr, "PowerOnBacklight"},
{0x00130040, nullptr, "SetLedForceOff"}, {IPC::MakeHeader(0x0012, 1, 0), nullptr, "PowerOffBacklight"},
{0x00140000, nullptr, "GetVendor"}, {IPC::MakeHeader(0x0013, 1, 0), nullptr, "SetLedForceOff"},
{0x00150040, nullptr, "GetBrightness"}, {IPC::MakeHeader(0x0014, 0, 0), nullptr, "GetVendor"},
{IPC::MakeHeader(0x0015, 1, 0), nullptr, "GetBrightness"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
}; };

27
src/core/hle/service/hid/hid_spvr.cpp
View File

@@ -11,19 +11,20 @@ namespace Service::HID {
Spvr::Spvr(std::shared_ptr<Module> hid) : Module::Interface(std::move(hid), "hid:SPVR", 6) { Spvr::Spvr(std::shared_ptr<Module> hid) : Module::Interface(std::move(hid), "hid:SPVR", 6) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x00010200, nullptr, "CalibrateTouchScreen"}, // clang-format off
{0x00020000, nullptr, "UpdateTouchConfig"}, {IPC::MakeHeader(0x0001, 8, 0), nullptr, "CalibrateTouchScreen"},
{0x000A0000, &Spvr::GetIPCHandles, "GetIPCHandles"}, {IPC::MakeHeader(0x0002, 0, 0), nullptr, "UpdateTouchConfig"},
{0x000B0000, nullptr, "StartAnalogStickCalibration"}, {IPC::MakeHeader(0x000A, 0, 0), &Spvr::GetIPCHandles, "GetIPCHandles"},
{0x000E0000, nullptr, "GetAnalogStickCalibrateParam"}, {IPC::MakeHeader(0x000B, 0, 0), nullptr, "StartAnalogStickCalibration"},
{0x00110000, &Spvr::EnableAccelerometer, "EnableAccelerometer"}, {IPC::MakeHeader(0x000E, 0, 0), nullptr, "GetAnalogStickCalibrateParam"},
{0x00120000, &Spvr::DisableAccelerometer, "DisableAccelerometer"}, {IPC::MakeHeader(0x0011, 0, 0), &Spvr::EnableAccelerometer, "EnableAccelerometer"},
{0x00130000, &Spvr::EnableGyroscopeLow, "EnableGyroscopeLow"}, {IPC::MakeHeader(0x0012, 0, 0), &Spvr::DisableAccelerometer, "DisableAccelerometer"},
{0x00140000, &Spvr::DisableGyroscopeLow, "DisableGyroscopeLow"}, {IPC::MakeHeader(0x0013, 0, 0), &Spvr::EnableGyroscopeLow, "EnableGyroscopeLow"},
{0x00150000, &Spvr::GetGyroscopeLowRawToDpsCoefficient, {IPC::MakeHeader(0x0014, 0, 0), &Spvr::DisableGyroscopeLow, "DisableGyroscopeLow"},
"GetGyroscopeLowRawToDpsCoefficient"}, {IPC::MakeHeader(0x0015, 0, 0), &Spvr::GetGyroscopeLowRawToDpsCoefficient, "GetGyroscopeLowRawToDpsCoefficient"},
{0x00160000, &Spvr::GetGyroscopeLowCalibrateParam, "GetGyroscopeLowCalibrateParam"}, {IPC::MakeHeader(0x0016, 0, 0), &Spvr::GetGyroscopeLowCalibrateParam, "GetGyroscopeLowCalibrateParam"},
{0x00170000, &Spvr::GetSoundVolume, "GetSoundVolume"}, {IPC::MakeHeader(0x0017, 0, 0), &Spvr::GetSoundVolume, "GetSoundVolume"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

27
src/core/hle/service/hid/hid_user.cpp
View File

@@ -11,19 +11,20 @@ namespace Service::HID {
User::User(std::shared_ptr<Module> hid) : Module::Interface(std::move(hid), "hid:USER", 6) { User::User(std::shared_ptr<Module> hid) : Module::Interface(std::move(hid), "hid:USER", 6) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x00010200, nullptr, "CalibrateTouchScreen"}, // clang-format off
{0x00020000, nullptr, "UpdateTouchConfig"}, {IPC::MakeHeader(0x0001, 8, 0), nullptr, "CalibrateTouchScreen"},
{0x000A0000, &User::GetIPCHandles, "GetIPCHandles"}, {IPC::MakeHeader(0x0002, 0, 0), nullptr, "UpdateTouchConfig"},
{0x000B0000, nullptr, "StartAnalogStickCalibration"}, {IPC::MakeHeader(0x000A, 0, 0), &User::GetIPCHandles, "GetIPCHandles"},
{0x000E0000, nullptr, "GetAnalogStickCalibrateParam"}, {IPC::MakeHeader(0x000B, 0, 0), nullptr, "StartAnalogStickCalibration"},
{0x00110000, &User::EnableAccelerometer, "EnableAccelerometer"}, {IPC::MakeHeader(0x000E, 0, 0), nullptr, "GetAnalogStickCalibrateParam"},
{0x00120000, &User::DisableAccelerometer, "DisableAccelerometer"}, {IPC::MakeHeader(0x0011, 0, 0), &User::EnableAccelerometer, "EnableAccelerometer"},
{0x00130000, &User::EnableGyroscopeLow, "EnableGyroscopeLow"}, {IPC::MakeHeader(0x0012, 0, 0), &User::DisableAccelerometer, "DisableAccelerometer"},
{0x00140000, &User::DisableGyroscopeLow, "DisableGyroscopeLow"}, {IPC::MakeHeader(0x0013, 0, 0), &User::EnableGyroscopeLow, "EnableGyroscopeLow"},
{0x00150000, &User::GetGyroscopeLowRawToDpsCoefficient, {IPC::MakeHeader(0x0014, 0, 0), &User::DisableGyroscopeLow, "DisableGyroscopeLow"},
"GetGyroscopeLowRawToDpsCoefficient"}, {IPC::MakeHeader(0x0015, 0, 0), &User::GetGyroscopeLowRawToDpsCoefficient, "GetGyroscopeLowRawToDpsCoefficient"},
{0x00160000, &User::GetGyroscopeLowCalibrateParam, "GetGyroscopeLowCalibrateParam"}, {IPC::MakeHeader(0x0016, 0, 0), &User::GetGyroscopeLowCalibrateParam, "GetGyroscopeLowCalibrateParam"},
{0x00170000, &User::GetSoundVolume, "GetSoundVolume"}, {IPC::MakeHeader(0x0017, 0, 0), &User::GetSoundVolume, "GetSoundVolume"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

114
src/core/hle/service/http_c.cpp
View File

@@ -868,62 +868,64 @@ void HTTP_C::DecryptClCertA() {
HTTP_C::HTTP_C() : ServiceFramework("http:C", 32) { HTTP_C::HTTP_C() : ServiceFramework("http:C", 32) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x00010044, &HTTP_C::Initialize, "Initialize"}, // clang-format off
{0x00020082, &HTTP_C::CreateContext, "CreateContext"}, {IPC::MakeHeader(0x0001, 1, 4), &HTTP_C::Initialize, "Initialize"},
{0x00030040, &HTTP_C::CloseContext, "CloseContext"}, {IPC::MakeHeader(0x0002, 2, 2), &HTTP_C::CreateContext, "CreateContext"},
{0x00040040, nullptr, "CancelConnection"}, {IPC::MakeHeader(0x0003, 1, 0), &HTTP_C::CloseContext, "CloseContext"},
{0x00050040, nullptr, "GetRequestState"}, {IPC::MakeHeader(0x0004, 1, 0), nullptr, "CancelConnection"},
{0x00060040, nullptr, "GetDownloadSizeState"}, {IPC::MakeHeader(0x0005, 1, 0), nullptr, "GetRequestState"},
{0x00070040, nullptr, "GetRequestError"}, {IPC::MakeHeader(0x0006, 1, 0), nullptr, "GetDownloadSizeState"},
{0x00080042, &HTTP_C::InitializeConnectionSession, "InitializeConnectionSession"}, {IPC::MakeHeader(0x0007, 1, 0), nullptr, "GetRequestError"},
{0x00090040, &HTTP_C::BeginRequest, "BeginRequest"}, {IPC::MakeHeader(0x0008, 1, 2), &HTTP_C::InitializeConnectionSession, "InitializeConnectionSession"},
{0x000A0040, &HTTP_C::BeginRequestAsync, "BeginRequestAsync"}, {IPC::MakeHeader(0x0009, 1, 0), &HTTP_C::BeginRequest, "BeginRequest"},
{0x000B0082, nullptr, "ReceiveData"}, {IPC::MakeHeader(0x000A, 1, 0), &HTTP_C::BeginRequestAsync, "BeginRequestAsync"},
{0x000C0102, nullptr, "ReceiveDataTimeout"}, {IPC::MakeHeader(0x000B, 2, 2), nullptr, "ReceiveData"},
{0x000D0146, nullptr, "SetProxy"}, {IPC::MakeHeader(0x000C, 4, 2), nullptr, "ReceiveDataTimeout"},
{0x000E0040, nullptr, "SetProxyDefault"}, {IPC::MakeHeader(0x000D, 5, 6), nullptr, "SetProxy"},
{0x000F00C4, nullptr, "SetBasicAuthorization"}, {IPC::MakeHeader(0x000E, 1, 0), nullptr, "SetProxyDefault"},
{0x00100080, nullptr, "SetSocketBufferSize"}, {IPC::MakeHeader(0x000F, 3, 4), nullptr, "SetBasicAuthorization"},
{0x001100C4, &HTTP_C::AddRequestHeader, "AddRequestHeader"}, {IPC::MakeHeader(0x0010, 2, 0), nullptr, "SetSocketBufferSize"},
{0x001200C4, &HTTP_C::AddPostDataAscii, "AddPostDataAscii"}, {IPC::MakeHeader(0x0011, 3, 4), &HTTP_C::AddRequestHeader, "AddRequestHeader"},
{0x001300C4, nullptr, "AddPostDataBinary"}, {IPC::MakeHeader(0x0012, 3, 4), &HTTP_C::AddPostDataAscii, "AddPostDataAscii"},
{0x00140082, nullptr, "AddPostDataRaw"}, {IPC::MakeHeader(0x0013, 3, 4), nullptr, "AddPostDataBinary"},
{0x00150080, nullptr, "SetPostDataType"}, {IPC::MakeHeader(0x0014, 2, 2), nullptr, "AddPostDataRaw"},
{0x001600C4, nullptr, "SendPostDataAscii"}, {IPC::MakeHeader(0x0015, 2, 0), nullptr, "SetPostDataType"},
{0x00170144, nullptr, "SendPostDataAsciiTimeout"}, {IPC::MakeHeader(0x0016, 3, 4), nullptr, "SendPostDataAscii"},
{0x001800C4, nullptr, "SendPostDataBinary"}, {IPC::MakeHeader(0x0017, 5, 4), nullptr, "SendPostDataAsciiTimeout"},
{0x00190144, nullptr, "SendPostDataBinaryTimeout"}, {IPC::MakeHeader(0x0018, 3, 4), nullptr, "SendPostDataBinary"},
{0x001A0082, nullptr, "SendPostDataRaw"}, {IPC::MakeHeader(0x0019, 5, 4), nullptr, "SendPostDataBinaryTimeout"},
{0x001B0102, nullptr, "SendPOSTDataRawTimeout"}, {IPC::MakeHeader(0x001A, 2, 2), nullptr, "SendPostDataRaw"},
{0x001C0080, nullptr, "SetPostDataEncoding"}, {IPC::MakeHeader(0x001B, 4, 2), nullptr, "SendPOSTDataRawTimeout"},
{0x001D0040, nullptr, "NotifyFinishSendPostData"}, {IPC::MakeHeader(0x001C, 2, 0), nullptr, "SetPostDataEncoding"},
{0x001E00C4, nullptr, "GetResponseHeader"}, {IPC::MakeHeader(0x001D, 1, 0), nullptr, "NotifyFinishSendPostData"},
{0x001F0144, nullptr, "GetResponseHeaderTimeout"}, {IPC::MakeHeader(0x001E, 3, 4), nullptr, "GetResponseHeader"},
{0x00200082, nullptr, "GetResponseData"}, {IPC::MakeHeader(0x001F, 5, 4), nullptr, "GetResponseHeaderTimeout"},
{0x00210102, nullptr, "GetResponseDataTimeout"}, {IPC::MakeHeader(0x0020, 2, 2), nullptr, "GetResponseData"},
{0x00220040, nullptr, "GetResponseStatusCode"}, {IPC::MakeHeader(0x0021, 4, 2), nullptr, "GetResponseDataTimeout"},
{0x002300C0, nullptr, "GetResponseStatusCodeTimeout"}, {IPC::MakeHeader(0x0022, 1, 0), nullptr, "GetResponseStatusCode"},
{0x00240082, nullptr, "AddTrustedRootCA"}, {IPC::MakeHeader(0x0023, 3, 0), nullptr, "GetResponseStatusCodeTimeout"},
{0x00250080, nullptr, "AddDefaultCert"}, {IPC::MakeHeader(0x0024, 2, 2), nullptr, "AddTrustedRootCA"},
{0x00260080, nullptr, "SelectRootCertChain"}, {IPC::MakeHeader(0x0025, 2, 0), nullptr, "AddDefaultCert"},
{0x002700C4, nullptr, "SetClientCert"}, {IPC::MakeHeader(0x0026, 2, 0), nullptr, "SelectRootCertChain"},
{0x00290080, &HTTP_C::SetClientCertContext, "SetClientCertContext"}, {IPC::MakeHeader(0x0027, 3, 4), nullptr, "SetClientCert"},
{0x002A0040, &HTTP_C::GetSSLError, "GetSSLError"}, {IPC::MakeHeader(0x0029, 2, 0), &HTTP_C::SetClientCertContext, "SetClientCertContext"},
{0x002B0080, nullptr, "SetSSLOpt"}, {IPC::MakeHeader(0x002A, 1, 0), &HTTP_C::GetSSLError, "GetSSLError"},
{0x002C0080, nullptr, "SetSSLClearOpt"}, {IPC::MakeHeader(0x002B, 2, 0), nullptr, "SetSSLOpt"},
{0x002D0000, nullptr, "CreateRootCertChain"}, {IPC::MakeHeader(0x002C, 2, 0), nullptr, "SetSSLClearOpt"},
{0x002E0040, nullptr, "DestroyRootCertChain"}, {IPC::MakeHeader(0x002D, 0, 0), nullptr, "CreateRootCertChain"},
{0x002F0082, nullptr, "RootCertChainAddCert"}, {IPC::MakeHeader(0x002E, 1, 0), nullptr, "DestroyRootCertChain"},
{0x00300080, nullptr, "RootCertChainAddDefaultCert"}, {IPC::MakeHeader(0x002F, 2, 2), nullptr, "RootCertChainAddCert"},
{0x00310080, nullptr, "RootCertChainRemoveCert"}, {IPC::MakeHeader(0x0030, 2, 0), nullptr, "RootCertChainAddDefaultCert"},
{0x00320084, &HTTP_C::OpenClientCertContext, "OpenClientCertContext"}, {IPC::MakeHeader(0x0031, 2, 0), nullptr, "RootCertChainRemoveCert"},
{0x00330040, &HTTP_C::OpenDefaultClientCertContext, "OpenDefaultClientCertContext"}, {IPC::MakeHeader(0x0032, 2, 4), &HTTP_C::OpenClientCertContext, "OpenClientCertContext"},
{0x00340040, &HTTP_C::CloseClientCertContext, "CloseClientCertContext"}, {IPC::MakeHeader(0x0033, 1, 0), &HTTP_C::OpenDefaultClientCertContext, "OpenDefaultClientCertContext"},
{0x00350186, nullptr, "SetDefaultProxy"}, {IPC::MakeHeader(0x0034, 1, 0), &HTTP_C::CloseClientCertContext, "CloseClientCertContext"},
{0x00360000, nullptr, "ClearDNSCache"}, {IPC::MakeHeader(0x0035, 6, 6), nullptr, "SetDefaultProxy"},
{0x00370080, nullptr, "SetKeepAlive"}, {IPC::MakeHeader(0x0036, 0, 0), nullptr, "ClearDNSCache"},
{0x003800C0, nullptr, "SetPostDataTypeSize"}, {IPC::MakeHeader(0x0037, 2, 0), nullptr, "SetKeepAlive"},
{0x00390000, &HTTP_C::Finalize, "Finalize"}, {IPC::MakeHeader(0x0038, 3, 0), nullptr, "SetPostDataTypeSize"},
{IPC::MakeHeader(0x0039, 0, 0), &HTTP_C::Finalize, "Finalize"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);

10
src/core/hle/service/ir/ir_rst.cpp
View File

@@ -180,10 +180,12 @@ IR_RST::IR_RST(Core::System& system) : ServiceFramework("ir:rst", 1), system(sys
}); });
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x00010000, &IR_RST::GetHandles, "GetHandles"}, // clang-format off
{0x00020080, &IR_RST::Initialize, "Initialize"}, {IPC::MakeHeader(0x0001, 0, 0), &IR_RST::GetHandles, "GetHandles"},
{0x00030000, &IR_RST::Shutdown, "Shutdown"}, {IPC::MakeHeader(0x0002, 2, 0), &IR_RST::Initialize, "Initialize"},
{0x00090000, nullptr, "WriteToTwoFields"}, {IPC::MakeHeader(0x0003, 0, 0), &IR_RST::Shutdown, "Shutdown"},
{IPC::MakeHeader(0x0009, 0, 0), nullptr, "WriteToTwoFields"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

38
src/core/hle/service/ir/ir_u.cpp
View File

@@ -11,24 +11,26 @@ namespace Service::IR {
IR_U::IR_U() : ServiceFramework("ir:u", 1) { IR_U::IR_U() : ServiceFramework("ir:u", 1) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x00010000, nullptr, "Initialize"}, // clang-format off
{0x00020000, nullptr, "Shutdown"}, {IPC::MakeHeader(0x0001, 0, 0), nullptr, "Initialize"},
{0x00030042, nullptr, "StartSendTransfer"}, {IPC::MakeHeader(0x0002, 0, 0), nullptr, "Shutdown"},
{0x00040000, nullptr, "WaitSendTransfer"}, {IPC::MakeHeader(0x0003, 1, 2), nullptr, "StartSendTransfer"},
{0x000500C2, nullptr, "StartRecvTransfer"}, {IPC::MakeHeader(0x0004, 0, 0), nullptr, "WaitSendTransfer"},
{0x00060000, nullptr, "WaitRecvTransfer"}, {IPC::MakeHeader(0x0005, 3, 2), nullptr, "StartRecvTransfer"},
{0x00070080, nullptr, "GetRecvTransferCount"}, {IPC::MakeHeader(0x0006, 0, 0), nullptr, "WaitRecvTransfer"},
{0x00080000, nullptr, "GetSendState"}, {IPC::MakeHeader(0x0007, 2, 0), nullptr, "GetRecvTransferCount"},
{0x00090040, nullptr, "SetBitRate"}, {IPC::MakeHeader(0x0008, 0, 0), nullptr, "GetSendState"},
{0x000A0000, nullptr, "GetBitRate"}, {IPC::MakeHeader(0x0009, 1, 0), nullptr, "SetBitRate"},
{0x000B0040, nullptr, "SetIRLEDState"}, {IPC::MakeHeader(0x000A, 0, 0), nullptr, "GetBitRate"},
{0x000C0000, nullptr, "GetIRLEDRecvState"}, {IPC::MakeHeader(0x000B, 1, 0), nullptr, "SetIRLEDState"},
{0x000D0000, nullptr, "GetSendFinishedEvent"}, {IPC::MakeHeader(0x000C, 0, 0), nullptr, "GetIRLEDRecvState"},
{0x000E0000, nullptr, "GetRecvFinishedEvent"}, {IPC::MakeHeader(0x000D, 0, 0), nullptr, "GetSendFinishedEvent"},
{0x000F0000, nullptr, "GetTransferState"}, {IPC::MakeHeader(0x000E, 0, 0), nullptr, "GetRecvFinishedEvent"},
{0x00100000, nullptr, "GetErrorStatus"}, {IPC::MakeHeader(0x000F, 0, 0), nullptr, "GetTransferState"},
{0x00110040, nullptr, "SetSleepModeActive"}, {IPC::MakeHeader(0x0010, 0, 0), nullptr, "GetErrorStatus"},
{0x00120040, nullptr, "SetSleepModeState"}, {IPC::MakeHeader(0x0011, 1, 0), nullptr, "SetSleepModeActive"},
{IPC::MakeHeader(0x0012, 1, 0), nullptr, "SetSleepModeState"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

54
src/core/hle/service/ir/ir_user.cpp
View File

@@ -425,32 +425,34 @@ void IR_USER::ReleaseReceivedData(Kernel::HLERequestContext& ctx) {
IR_USER::IR_USER(Core::System& system) : ServiceFramework("ir:USER", 1) { IR_USER::IR_USER(Core::System& system) : ServiceFramework("ir:USER", 1) {
const FunctionInfo functions[] = { const FunctionInfo functions[] = {
{0x00010182, nullptr, "InitializeIrNop"}, // clang-format off
{0x00020000, &IR_USER::FinalizeIrNop, "FinalizeIrNop"}, {IPC::MakeHeader(0x0001, 6, 2), nullptr, "InitializeIrNop"},
{0x00030000, nullptr, "ClearReceiveBuffer"}, {IPC::MakeHeader(0x0002, 0, 0), &IR_USER::FinalizeIrNop, "FinalizeIrNop"},
{0x00040000, nullptr, "ClearSendBuffer"}, {IPC::MakeHeader(0x0003, 0, 0), nullptr, "ClearReceiveBuffer"},
{0x000500C0, nullptr, "WaitConnection"}, {IPC::MakeHeader(0x0004, 0, 0), nullptr, "ClearSendBuffer"},
{0x00060040, &IR_USER::RequireConnection, "RequireConnection"}, {IPC::MakeHeader(0x0005, 3, 0), nullptr, "WaitConnection"},
{0x000702C0, nullptr, "AutoConnection"}, {IPC::MakeHeader(0x0006, 1, 0), &IR_USER::RequireConnection, "RequireConnection"},
{0x00080000, nullptr, "AnyConnection"}, {IPC::MakeHeader(0x0007, 11, 0), nullptr, "AutoConnection"},
{0x00090000, &IR_USER::Disconnect, "Disconnect"}, {IPC::MakeHeader(0x0008, 0, 0), nullptr, "AnyConnection"},
{0x000A0000, &IR_USER::GetReceiveEvent, "GetReceiveEvent"}, {IPC::MakeHeader(0x0009, 0, 0), &IR_USER::Disconnect, "Disconnect"},
{0x000B0000, &IR_USER::GetSendEvent, "GetSendEvent"}, {IPC::MakeHeader(0x000A, 0, 0), &IR_USER::GetReceiveEvent, "GetReceiveEvent"},
{0x000C0000, &IR_USER::GetConnectionStatusEvent, "GetConnectionStatusEvent"}, {IPC::MakeHeader(0x000B, 0, 0), &IR_USER::GetSendEvent, "GetSendEvent"},
{0x000D0042, &IR_USER::SendIrNop, "SendIrNop"}, {IPC::MakeHeader(0x000C, 0, 0), &IR_USER::GetConnectionStatusEvent, "GetConnectionStatusEvent"},
{0x000E0042, nullptr, "SendIrNopLarge"}, {IPC::MakeHeader(0x000D, 1, 2), &IR_USER::SendIrNop, "SendIrNop"},
{0x000F0040, nullptr, "ReceiveIrnop"}, {IPC::MakeHeader(0x000E, 1, 2), nullptr, "SendIrNopLarge"},
{0x00100042, nullptr, "ReceiveIrnopLarge"}, {IPC::MakeHeader(0x000F, 1, 0), nullptr, "ReceiveIrnop"},
{0x00110040, nullptr, "GetLatestReceiveErrorResult"}, {IPC::MakeHeader(0x0010, 1, 2), nullptr, "ReceiveIrnopLarge"},
{0x00120040, nullptr, "GetLatestSendErrorResult"}, {IPC::MakeHeader(0x0011, 1, 0), nullptr, "GetLatestReceiveErrorResult"},
{0x00130000, nullptr, "GetConnectionStatus"}, {IPC::MakeHeader(0x0012, 1, 0), nullptr, "GetLatestSendErrorResult"},
{0x00140000, nullptr, "GetTryingToConnectStatus"}, {IPC::MakeHeader(0x0013, 0, 0), nullptr, "GetConnectionStatus"},
{0x00150000, nullptr, "GetReceiveSizeFreeAndUsed"}, {IPC::MakeHeader(0x0014, 0, 0), nullptr, "GetTryingToConnectStatus"},
{0x00160000, nullptr, "GetSendSizeFreeAndUsed"}, {IPC::MakeHeader(0x0015, 0, 0), nullptr, "GetReceiveSizeFreeAndUsed"},
{0x00170000, nullptr, "GetConnectionRole"}, {IPC::MakeHeader(0x0016, 0, 0), nullptr, "GetSendSizeFreeAndUsed"},
{0x00180182, &IR_USER::InitializeIrNopShared, "InitializeIrNopShared"}, {IPC::MakeHeader(0x0017, 0, 0), nullptr, "GetConnectionRole"},
{0x00190040, &IR_USER::ReleaseReceivedData, "ReleaseReceivedData"}, {IPC::MakeHeader(0x0018, 6, 2), &IR_USER::InitializeIrNopShared, "InitializeIrNopShared"},
{0x001A0040, nullptr, "SetOwnMachineId"}, {IPC::MakeHeader(0x0019, 1, 0), &IR_USER::ReleaseReceivedData, "ReleaseReceivedData"},
{IPC::MakeHeader(0x001A, 1, 0), nullptr, "SetOwnMachineId"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);

20
src/core/hle/service/ldr_ro/ldr_ro.cpp
View File

@@ -516,15 +516,17 @@ void RO::Shutdown(Kernel::HLERequestContext& ctx) {
RO::RO(Core::System& system) : ServiceFramework("ldr:ro", 2), system(system) { RO::RO(Core::System& system) : ServiceFramework("ldr:ro", 2), system(system) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x000100C2, &RO::Initialize, "Initialize"}, // clang-format off
{0x00020082, &RO::LoadCRR, "LoadCRR"}, {IPC::MakeHeader(0x0001, 3, 2), &RO::Initialize, "Initialize"},
{0x00030042, &RO::UnloadCRR, "UnloadCRR"}, {IPC::MakeHeader(0x0002, 2, 2), &RO::LoadCRR, "LoadCRR"},
{0x000402C2, &RO::LoadCRO<false>, "LoadCRO"}, {IPC::MakeHeader(0x0003, 1, 2), &RO::UnloadCRR, "UnloadCRR"},
{0x000500C2, &RO::UnloadCRO, "UnloadCRO"}, {IPC::MakeHeader(0x0004, 11, 2), &RO::LoadCRO<false>, "LoadCRO"},
{0x00060042, &RO::LinkCRO, "LinkCRO"}, {IPC::MakeHeader(0x0005, 3, 2), &RO::UnloadCRO, "UnloadCRO"},
{0x00070042, &RO::UnlinkCRO, "UnlinkCRO"}, {IPC::MakeHeader(0x0006, 1, 2), &RO::LinkCRO, "LinkCRO"},
{0x00080042, &RO::Shutdown, "Shutdown"}, {IPC::MakeHeader(0x0007, 1, 2), &RO::UnlinkCRO, "UnlinkCRO"},
{0x000902C2, &RO::LoadCRO<true>, "LoadCRO_New"}, {IPC::MakeHeader(0x0008, 1, 2), &RO::Shutdown, "Shutdown"},
{IPC::MakeHeader(0x0009, 11, 2), &RO::LoadCRO<true>, "LoadCRO_New"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

34
src/core/hle/service/mic_u.cpp
View File

@@ -488,22 +488,24 @@ void MIC_U::SetClientVersion(Kernel::HLERequestContext& ctx) {
MIC_U::MIC_U(Core::System& system) MIC_U::MIC_U(Core::System& system)
: ServiceFramework{"mic:u", 1}, impl{std::make_unique<Impl>(system)} { : ServiceFramework{"mic:u", 1}, impl{std::make_unique<Impl>(system)} {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x00010042, &MIC_U::MapSharedMem, "MapSharedMem"}, // clang-format off
{0x00020000, &MIC_U::UnmapSharedMem, "UnmapSharedMem"}, {IPC::MakeHeader(0x0001, 1, 2), &MIC_U::MapSharedMem, "MapSharedMem"},
{0x00030140, &MIC_U::StartSampling, "StartSampling"}, {IPC::MakeHeader(0x0002, 0, 0), &MIC_U::UnmapSharedMem, "UnmapSharedMem"},
{0x00040040, &MIC_U::AdjustSampling, "AdjustSampling"}, {IPC::MakeHeader(0x0003, 5, 0), &MIC_U::StartSampling, "StartSampling"},
{0x00050000, &MIC_U::StopSampling, "StopSampling"}, {IPC::MakeHeader(0x0004, 1, 0), &MIC_U::AdjustSampling, "AdjustSampling"},
{0x00060000, &MIC_U::IsSampling, "IsSampling"}, {IPC::MakeHeader(0x0005, 0, 0), &MIC_U::StopSampling, "StopSampling"},
{0x00070000, &MIC_U::GetBufferFullEvent, "GetBufferFullEvent"}, {IPC::MakeHeader(0x0006, 0, 0), &MIC_U::IsSampling, "IsSampling"},
{0x00080040, &MIC_U::SetGain, "SetGain"}, {IPC::MakeHeader(0x0007, 0, 0), &MIC_U::GetBufferFullEvent, "GetBufferFullEvent"},
{0x00090000, &MIC_U::GetGain, "GetGain"}, {IPC::MakeHeader(0x0008, 1, 0), &MIC_U::SetGain, "SetGain"},
{0x000A0040, &MIC_U::SetPower, "SetPower"}, {IPC::MakeHeader(0x0009, 0, 0), &MIC_U::GetGain, "GetGain"},
{0x000B0000, &MIC_U::GetPower, "GetPower"}, {IPC::MakeHeader(0x000A, 1, 0), &MIC_U::SetPower, "SetPower"},
{0x000C0042, &MIC_U::SetIirFilterMic, "SetIirFilterMic"}, {IPC::MakeHeader(0x000B, 0, 0), &MIC_U::GetPower, "GetPower"},
{0x000D0040, &MIC_U::SetClamp, "SetClamp"}, {IPC::MakeHeader(0x000C, 1, 2), &MIC_U::SetIirFilterMic, "SetIirFilterMic"},
{0x000E0000, &MIC_U::GetClamp, "GetClamp"}, {IPC::MakeHeader(0x000D, 1, 0), &MIC_U::SetClamp, "SetClamp"},
{0x000F0040, &MIC_U::SetAllowShellClosed, "SetAllowShellClosed"}, {IPC::MakeHeader(0x000E, 0, 0), &MIC_U::GetClamp, "GetClamp"},
{0x00100040, &MIC_U::SetClientVersion, "SetClientVersion"}, {IPC::MakeHeader(0x000F, 1, 0), &MIC_U::SetAllowShellClosed, "SetAllowShellClosed"},
{IPC::MakeHeader(0x0010, 1, 0), &MIC_U::SetClientVersion, "SetClientVersion"},
// clang-format on
}; };
impl->CreateMic(); impl->CreateMic();

24
src/core/hle/service/mvd/mvd_std.cpp
View File

@@ -13,18 +13,18 @@ namespace Service::MVD {
MVD_STD::MVD_STD() : ServiceFramework("mvd:std", 1) { MVD_STD::MVD_STD() : ServiceFramework("mvd:std", 1) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
// clang-format off // clang-format off
{0x00010082, nullptr, "Initialize"}, {IPC::MakeHeader(0x0001, 2, 2), nullptr, "Initialize"},
{0x00020000, nullptr, "Shutdown"}, {IPC::MakeHeader(0x0002, 0, 0), nullptr, "Shutdown"},
{0x00030300, nullptr, "CalculateWorkBufSize"}, {IPC::MakeHeader(0x0003, 12, 0), nullptr, "CalculateWorkBufSize"},
{0x000400C0, nullptr, "CalculateImageSize"}, {IPC::MakeHeader(0x0004, 3, 0), nullptr, "CalculateImageSize"},
{0x00080142, nullptr, "ProcessNALUnit"}, {IPC::MakeHeader(0x0008, 5, 2), nullptr, "ProcessNALUnit"},
{0x00090042, nullptr, "ControlFrameRendering"}, {IPC::MakeHeader(0x0009, 1, 2), nullptr, "ControlFrameRendering"},
{0x000A0000, nullptr, "GetStatus"}, {IPC::MakeHeader(0x000A, 0, 0), nullptr, "GetStatus"},
{0x000B0000, nullptr, "GetStatusOther"}, {IPC::MakeHeader(0x000B, 0, 0), nullptr, "GetStatusOther"},
{0x001D0042, nullptr, "GetConfig"}, {IPC::MakeHeader(0x001D, 1, 2), nullptr, "GetConfig"},
{0x001E0044, nullptr, "SetConfig"}, {IPC::MakeHeader(0x001E, 1, 4), nullptr, "SetConfig"},
{0x001F0902, nullptr, "SetOutputBuffer"}, {IPC::MakeHeader(0x001F, 36, 2), nullptr, "SetOutputBuffer"},
{0x00210100, nullptr, "OverrideOutputBuffers"} {IPC::MakeHeader(0x0021, 4, 0), nullptr, "OverrideOutputBuffers"}
// clang-format on // clang-format on
}; };

48
src/core/hle/service/ndm/ndm_u.cpp
View File

@@ -212,29 +212,31 @@ void NDM_U::ClearHalfAwakeMacFilter(Kernel::HLERequestContext& ctx) {
NDM_U::NDM_U() : ServiceFramework("ndm:u", 6) { NDM_U::NDM_U() : ServiceFramework("ndm:u", 6) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x00010042, &NDM_U::EnterExclusiveState, "EnterExclusiveState"}, // clang-format off
{0x00020002, &NDM_U::LeaveExclusiveState, "LeaveExclusiveState"}, {IPC::MakeHeader(0x0001, 1, 2), &NDM_U::EnterExclusiveState, "EnterExclusiveState"},
{0x00030000, &NDM_U::QueryExclusiveMode, "QueryExclusiveMode"}, {IPC::MakeHeader(0x0002, 0, 2), &NDM_U::LeaveExclusiveState, "LeaveExclusiveState"},
{0x00040002, &NDM_U::LockState, "LockState"}, {IPC::MakeHeader(0x0003, 0, 0), &NDM_U::QueryExclusiveMode, "QueryExclusiveMode"},
{0x00050002, &NDM_U::UnlockState, "UnlockState"}, {IPC::MakeHeader(0x0004, 0, 2), &NDM_U::LockState, "LockState"},
{0x00060040, &NDM_U::SuspendDaemons, "SuspendDaemons"}, {IPC::MakeHeader(0x0005, 0, 2), &NDM_U::UnlockState, "UnlockState"},
{0x00070040, &NDM_U::ResumeDaemons, "ResumeDaemons"}, {IPC::MakeHeader(0x0006, 1, 0), &NDM_U::SuspendDaemons, "SuspendDaemons"},
{0x00080040, &NDM_U::SuspendScheduler, "SuspendScheduler"}, {IPC::MakeHeader(0x0007, 1, 0), &NDM_U::ResumeDaemons, "ResumeDaemons"},
{0x00090000, &NDM_U::ResumeScheduler, "ResumeScheduler"}, {IPC::MakeHeader(0x0008, 1, 0), &NDM_U::SuspendScheduler, "SuspendScheduler"},
{0x000A0000, nullptr, "GetCurrentState"}, {IPC::MakeHeader(0x0009, 0, 0), &NDM_U::ResumeScheduler, "ResumeScheduler"},
{0x000B0000, nullptr, "GetTargetState"}, {IPC::MakeHeader(0x000A, 0, 0), nullptr, "GetCurrentState"},
{0x000C0000, nullptr, "<Stubbed>"}, {IPC::MakeHeader(0x000B, 0, 0), nullptr, "GetTargetState"},
{0x000D0040, &NDM_U::QueryStatus, "QueryStatus"}, {IPC::MakeHeader(0x000C, 0, 0), nullptr, "<Stubbed>"},
{0x000E0040, &NDM_U::GetDaemonDisableCount, "GetDaemonDisableCount"}, {IPC::MakeHeader(0x000D, 1, 0), &NDM_U::QueryStatus, "QueryStatus"},
{0x000F0000, &NDM_U::GetSchedulerDisableCount, "GetSchedulerDisableCount"}, {IPC::MakeHeader(0x000E, 1, 0), &NDM_U::GetDaemonDisableCount, "GetDaemonDisableCount"},
{0x00100040, &NDM_U::SetScanInterval, "SetScanInterval"}, {IPC::MakeHeader(0x000F, 0, 0), &NDM_U::GetSchedulerDisableCount, "GetSchedulerDisableCount"},
{0x00110000, &NDM_U::GetScanInterval, "GetScanInterval"}, {IPC::MakeHeader(0x0010, 1, 0), &NDM_U::SetScanInterval, "SetScanInterval"},
{0x00120040, &NDM_U::SetRetryInterval, "SetRetryInterval"}, {IPC::MakeHeader(0x0011, 0, 0), &NDM_U::GetScanInterval, "GetScanInterval"},
{0x00130000, &NDM_U::GetRetryInterval, "GetRetryInterval"}, {IPC::MakeHeader(0x0012, 1, 0), &NDM_U::SetRetryInterval, "SetRetryInterval"},
{0x00140040, &NDM_U::OverrideDefaultDaemons, "OverrideDefaultDaemons"}, {IPC::MakeHeader(0x0013, 0, 0), &NDM_U::GetRetryInterval, "GetRetryInterval"},
{0x00150000, &NDM_U::ResetDefaultDaemons, "ResetDefaultDaemons"}, {IPC::MakeHeader(0x0014, 1, 0), &NDM_U::OverrideDefaultDaemons, "OverrideDefaultDaemons"},
{0x00160000, &NDM_U::GetDefaultDaemons, "GetDefaultDaemons"}, {IPC::MakeHeader(0x0015, 0, 0), &NDM_U::ResetDefaultDaemons, "ResetDefaultDaemons"},
{0x00170000, &NDM_U::ClearHalfAwakeMacFilter, "ClearHalfAwakeMacFilter"}, {IPC::MakeHeader(0x0016, 0, 0), &NDM_U::GetDefaultDaemons, "GetDefaultDaemons"},
{IPC::MakeHeader(0x0017, 0, 0), &NDM_U::ClearHalfAwakeMacFilter, "ClearHalfAwakeMacFilter"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

28
src/core/hle/service/news/news_s.cpp
View File

@@ -23,19 +23,21 @@ void NEWS_S::GetTotalNotifications(Kernel::HLERequestContext& ctx) {
NEWS_S::NEWS_S() : ServiceFramework("news:s", 2) { NEWS_S::NEWS_S() : ServiceFramework("news:s", 2) {
const FunctionInfo functions[] = { const FunctionInfo functions[] = {
{0x000100C6, nullptr, "AddNotification"}, // clang-format off
{0x00050000, &NEWS_S::GetTotalNotifications, "GetTotalNotifications"}, {IPC::MakeHeader(0x0001, 3, 6), nullptr, "AddNotification"},
{0x00060042, nullptr, "SetNewsDBHeader"}, {IPC::MakeHeader(0x0005, 0, 0), &NEWS_S::GetTotalNotifications, "GetTotalNotifications"},
{0x00070082, nullptr, "SetNotificationHeader"}, {IPC::MakeHeader(0x0006, 1, 2), nullptr, "SetNewsDBHeader"},
{0x00080082, nullptr, "SetNotificationMessage"}, {IPC::MakeHeader(0x0007, 2, 2), nullptr, "SetNotificationHeader"},
{0x00090082, nullptr, "SetNotificationImage"}, {IPC::MakeHeader(0x0008, 2, 2), nullptr, "SetNotificationMessage"},
{0x000A0042, nullptr, "GetNewsDBHeader"}, {IPC::MakeHeader(0x0009, 2, 2), nullptr, "SetNotificationImage"},
{0x000B0082, nullptr, "GetNotificationHeader"}, {IPC::MakeHeader(0x000A, 1, 2), nullptr, "GetNewsDBHeader"},
{0x000C0082, nullptr, "GetNotificationMessage"}, {IPC::MakeHeader(0x000B, 2, 2), nullptr, "GetNotificationHeader"},
{0x000D0082, nullptr, "GetNotificationImage"}, {IPC::MakeHeader(0x000C, 2, 2), nullptr, "GetNotificationMessage"},
{0x000E0040, nullptr, "SetInfoLEDPattern"}, {IPC::MakeHeader(0x000D, 2, 2), nullptr, "GetNotificationImage"},
{0x00120082, nullptr, "GetNotificationHeaderOther"}, {IPC::MakeHeader(0x000E, 1, 0), nullptr, "SetInfoLEDPattern"},
{0x00130000, nullptr, "WriteNewsDBSavedata"}, {IPC::MakeHeader(0x0012, 2, 2), nullptr, "GetNotificationHeaderOther"},
{IPC::MakeHeader(0x0013, 0, 0), nullptr, "WriteNewsDBSavedata"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

4
src/core/hle/service/news/news_u.cpp
View File

@@ -11,7 +11,9 @@ namespace Service::NEWS {
NEWS_U::NEWS_U() : ServiceFramework("news:u", 1) { NEWS_U::NEWS_U() : ServiceFramework("news:u", 1) {
const FunctionInfo functions[] = { const FunctionInfo functions[] = {
{0x000100C8, nullptr, "AddNotification"}, // clang-format off
{IPC::MakeHeader(0x0001, 3, 8), nullptr, "AddNotification"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

54
src/core/hle/service/nfc/nfc_m.cpp
View File

@@ -11,35 +11,35 @@ namespace Service::NFC {
NFC_M::NFC_M(std::shared_ptr<Module> nfc) : Module::Interface(std::move(nfc), "nfc:m", 1) { NFC_M::NFC_M(std::shared_ptr<Module> nfc) : Module::Interface(std::move(nfc), "nfc:m", 1) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
// clang-format off
// nfc:u shared commands // nfc:u shared commands
{0x00010040, &NFC_M::Initialize, "Initialize"}, // clang-format off
{0x00020040, &NFC_M::Shutdown, "Shutdown"}, {IPC::MakeHeader(0x0001, 1, 0), &NFC_M::Initialize, "Initialize"},
{0x00030000, &NFC_M::StartCommunication, "StartCommunication"}, {IPC::MakeHeader(0x0002, 1, 0), &NFC_M::Shutdown, "Shutdown"},
{0x00040000, &NFC_M::StopCommunication, "StopCommunication"}, {IPC::MakeHeader(0x0003, 0, 0), &NFC_M::StartCommunication, "StartCommunication"},
{0x00050040, &NFC_M::StartTagScanning, "StartTagScanning"}, {IPC::MakeHeader(0x0004, 0, 0), &NFC_M::StopCommunication, "StopCommunication"},
{0x00060000, &NFC_M::StopTagScanning, "StopTagScanning"}, {IPC::MakeHeader(0x0005, 1, 0), &NFC_M::StartTagScanning, "StartTagScanning"},
{0x00070000, &NFC_M::LoadAmiiboData, "LoadAmiiboData"}, {IPC::MakeHeader(0x0006, 0, 0), &NFC_M::StopTagScanning, "StopTagScanning"},
{0x00080000, &NFC_M::ResetTagScanState, "ResetTagScanState"}, {IPC::MakeHeader(0x0007, 0, 0), &NFC_M::LoadAmiiboData, "LoadAmiiboData"},
{0x00090002, nullptr, "UpdateStoredAmiiboData"}, {IPC::MakeHeader(0x0008, 0, 0), &NFC_M::ResetTagScanState, "ResetTagScanState"},
{0x000B0000, &NFC_M::GetTagInRangeEvent, "GetTagInRangeEvent"}, {IPC::MakeHeader(0x0009, 0, 2), nullptr, "UpdateStoredAmiiboData"},
{0x000C0000, &NFC_M::GetTagOutOfRangeEvent, "GetTagOutOfRangeEvent"}, {IPC::MakeHeader(0x000B, 0, 0), &NFC_M::GetTagInRangeEvent, "GetTagInRangeEvent"},
{0x000D0000, &NFC_M::GetTagState, "GetTagState"}, {IPC::MakeHeader(0x000C, 0, 0), &NFC_M::GetTagOutOfRangeEvent, "GetTagOutOfRangeEvent"},
{0x000F0000, &NFC_M::CommunicationGetStatus, "CommunicationGetStatus"}, {IPC::MakeHeader(0x000D, 0, 0), &NFC_M::GetTagState, "GetTagState"},
{0x00100000, nullptr, "GetTagInfo2"}, {IPC::MakeHeader(0x000F, 0, 0), &NFC_M::CommunicationGetStatus, "CommunicationGetStatus"},
{0x00110000, &NFC_M::GetTagInfo, "GetTagInfo"}, {IPC::MakeHeader(0x0010, 0, 0), nullptr, "GetTagInfo2"},
{0x00120000, nullptr, "CommunicationGetResult"}, {IPC::MakeHeader(0x0011, 0, 0), &NFC_M::GetTagInfo, "GetTagInfo"},
{0x00130040, nullptr, "OpenAppData"}, {IPC::MakeHeader(0x0012, 0, 0), nullptr, "CommunicationGetResult"},
{0x00140384, nullptr, "InitializeWriteAppData"}, {IPC::MakeHeader(0x0013, 1, 0), nullptr, "OpenAppData"},
{0x00150040, nullptr, "ReadAppData"}, {IPC::MakeHeader(0x0014, 14, 4), nullptr, "InitializeWriteAppData"},
{0x00160242, nullptr, "WriteAppData"}, {IPC::MakeHeader(0x0015, 1, 0), nullptr, "ReadAppData"},
{0x00170000, nullptr, "GetAmiiboSettings"}, {IPC::MakeHeader(0x0016, 9, 2), nullptr, "WriteAppData"},
{0x00180000, &NFC_M::GetAmiiboConfig, "GetAmiiboConfig"}, {IPC::MakeHeader(0x0017, 0, 0), nullptr, "GetAmiiboSettings"},
{0x00190000, nullptr, "GetAppDataInitStruct"}, {IPC::MakeHeader(0x0018, 0, 0), &NFC_M::GetAmiiboConfig, "GetAmiiboConfig"},
{0x001A0000, &NFC_M::Unknown0x1A, "Unknown0x1A"}, {IPC::MakeHeader(0x0019, 0, 0), nullptr, "GetAppDataInitStruct"},
{0x001B0000, &NFC_M::GetIdentificationBlock, "GetIdentificationBlock"}, {IPC::MakeHeader(0x001A, 0, 0), &NFC_M::Unknown0x1A, "Unknown0x1A"},
{IPC::MakeHeader(0x001B, 0, 0), &NFC_M::GetIdentificationBlock, "GetIdentificationBlock"},
// nfc:m // nfc:m
{0x04040A40, nullptr, "SetAmiiboSettings"} {IPC::MakeHeader(0x0404, 41, 0), nullptr, "SetAmiiboSettings"}
// clang-format on // clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);

50
src/core/hle/service/nfc/nfc_u.cpp
View File

@@ -12,31 +12,31 @@ namespace Service::NFC {
NFC_U::NFC_U(std::shared_ptr<Module> nfc) : Module::Interface(std::move(nfc), "nfc:u", 1) { NFC_U::NFC_U(std::shared_ptr<Module> nfc) : Module::Interface(std::move(nfc), "nfc:u", 1) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
// clang-format off // clang-format off
{0x00010040, &NFC_U::Initialize, "Initialize"}, {IPC::MakeHeader(0x0001, 1, 0), &NFC_U::Initialize, "Initialize"},
{0x00020040, &NFC_U::Shutdown, "Shutdown"}, {IPC::MakeHeader(0x0002, 1, 0), &NFC_U::Shutdown, "Shutdown"},
{0x00030000, &NFC_U::StartCommunication, "StartCommunication"}, {IPC::MakeHeader(0x0003, 0, 0), &NFC_U::StartCommunication, "StartCommunication"},
{0x00040000, &NFC_U::StopCommunication, "StopCommunication"}, {IPC::MakeHeader(0x0004, 0, 0), &NFC_U::StopCommunication, "StopCommunication"},
{0x00050040, &NFC_U::StartTagScanning, "StartTagScanning"}, {IPC::MakeHeader(0x0005, 1, 0), &NFC_U::StartTagScanning, "StartTagScanning"},
{0x00060000, &NFC_U::StopTagScanning, "StopTagScanning"}, {IPC::MakeHeader(0x0006, 0, 0), &NFC_U::StopTagScanning, "StopTagScanning"},
{0x00070000, &NFC_U::LoadAmiiboData, "LoadAmiiboData"}, {IPC::MakeHeader(0x0007, 0, 0), &NFC_U::LoadAmiiboData, "LoadAmiiboData"},
{0x00080000, &NFC_U::ResetTagScanState, "ResetTagScanState"}, {IPC::MakeHeader(0x0008, 0, 0), &NFC_U::ResetTagScanState, "ResetTagScanState"},
{0x00090002, nullptr, "UpdateStoredAmiiboData"}, {IPC::MakeHeader(0x0009, 0, 2), nullptr, "UpdateStoredAmiiboData"},
{0x000B0000, &NFC_U::GetTagInRangeEvent, "GetTagInRangeEvent"}, {IPC::MakeHeader(0x000B, 0, 0), &NFC_U::GetTagInRangeEvent, "GetTagInRangeEvent"},
{0x000C0000, &NFC_U::GetTagOutOfRangeEvent, "GetTagOutOfRangeEvent"}, {IPC::MakeHeader(0x000C, 0, 0), &NFC_U::GetTagOutOfRangeEvent, "GetTagOutOfRangeEvent"},
{0x000D0000, &NFC_U::GetTagState, "GetTagState"}, {IPC::MakeHeader(0x000D, 0, 0), &NFC_U::GetTagState, "GetTagState"},
{0x000F0000, &NFC_U::CommunicationGetStatus, "CommunicationGetStatus"}, {IPC::MakeHeader(0x000F, 0, 0), &NFC_U::CommunicationGetStatus, "CommunicationGetStatus"},
{0x00100000, nullptr, "GetTagInfo2"}, {IPC::MakeHeader(0x0010, 0, 0), nullptr, "GetTagInfo2"},
{0x00110000, &NFC_U::GetTagInfo, "GetTagInfo"}, {IPC::MakeHeader(0x0011, 0, 0), &NFC_U::GetTagInfo, "GetTagInfo"},
{0x00120000, nullptr, "CommunicationGetResult"}, {IPC::MakeHeader(0x0012, 0, 0), nullptr, "CommunicationGetResult"},
{0x00130040, nullptr, "OpenAppData"}, {IPC::MakeHeader(0x0013, 1, 0), nullptr, "OpenAppData"},
{0x00140384, nullptr, "InitializeWriteAppData"}, {IPC::MakeHeader(0x0014, 14, 4), nullptr, "InitializeWriteAppData"},
{0x00150040, nullptr, "ReadAppData"}, {IPC::MakeHeader(0x0015, 1, 0), nullptr, "ReadAppData"},
{0x00160242, nullptr, "WriteAppData"}, {IPC::MakeHeader(0x0016, 9, 2), nullptr, "WriteAppData"},
{0x00170000, nullptr, "GetAmiiboSettings"}, {IPC::MakeHeader(0x0017, 0, 0), nullptr, "GetAmiiboSettings"},
{0x00180000, &NFC_U::GetAmiiboConfig, "GetAmiiboConfig"}, {IPC::MakeHeader(0x0018, 0, 0), &NFC_U::GetAmiiboConfig, "GetAmiiboConfig"},
{0x00190000, nullptr, "GetAppDataInitStruct"}, {IPC::MakeHeader(0x0019, 0, 0), nullptr, "GetAppDataInitStruct"},
{0x001A0000, &NFC_U::Unknown0x1A, "Unknown0x1A"}, {IPC::MakeHeader(0x001A, 0, 0), &NFC_U::Unknown0x1A, "Unknown0x1A"},
{0x001B0000, &NFC_U::GetIdentificationBlock, "GetIdentificationBlock"}, {IPC::MakeHeader(0x001B, 0, 0), &NFC_U::GetIdentificationBlock, "GetIdentificationBlock"},
// clang-format on // clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);

18
src/core/hle/service/nim/nim_aoc.cpp
View File

@@ -11,14 +11,16 @@ namespace Service::NIM {
NIM_AOC::NIM_AOC() : ServiceFramework("nim:aoc", 2) { NIM_AOC::NIM_AOC() : ServiceFramework("nim:aoc", 2) {
const FunctionInfo functions[] = { const FunctionInfo functions[] = {
{0x00030042, nullptr, "SetApplicationId"}, // clang-format off
{0x00040042, nullptr, "SetTin"}, {IPC::MakeHeader(0x0003, 1, 2), nullptr, "SetApplicationId"},
{0x000902D0, nullptr, "ListContentSetsEx"}, {IPC::MakeHeader(0x0004, 1, 2), nullptr, "SetTin"},
{0x00180000, nullptr, "GetBalance"}, {IPC::MakeHeader(0x0009, 11, 16), nullptr, "ListContentSetsEx"},
{0x001D0000, nullptr, "GetCustomerSupportCode"}, {IPC::MakeHeader(0x0018, 0, 0), nullptr, "GetBalance"},
{0x00210000, nullptr, "Initialize"}, {IPC::MakeHeader(0x001D, 0, 0), nullptr, "GetCustomerSupportCode"},
{0x00240282, nullptr, "CalculateContentsRequiredSize"}, {IPC::MakeHeader(0x0021, 0, 0), nullptr, "Initialize"},
{0x00250000, nullptr, "RefreshServerTime"}, {IPC::MakeHeader(0x0024, 10, 2), nullptr, "CalculateContentsRequiredSize"},
{IPC::MakeHeader(0x0025, 0, 0), nullptr, "RefreshServerTime"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

12
src/core/hle/service/nim/nim_s.cpp
View File

@@ -11,11 +11,13 @@ namespace Service::NIM {
NIM_S::NIM_S() : ServiceFramework("nim:s", 1) { NIM_S::NIM_S() : ServiceFramework("nim:s", 1) {
const FunctionInfo functions[] = { const FunctionInfo functions[] = {
{0x000A0000, nullptr, "CheckSysupdateAvailableSOAP"}, // clang-format off
{0x0016020A, nullptr, "ListTitles"}, {IPC::MakeHeader(0x000A, 0, 0), nullptr, "CheckSysupdateAvailableSOAP"},
{0x00290000, nullptr, "AccountCheckBalanceSOAP"}, {IPC::MakeHeader(0x0016, 8, 10), nullptr, "ListTitles"},
{0x002D0042, nullptr, "DownloadTickets"}, {IPC::MakeHeader(0x0029, 0, 0), nullptr, "AccountCheckBalanceSOAP"},
{0x00420240, nullptr, "StartDownload"}, {IPC::MakeHeader(0x002D, 1, 2), nullptr, "DownloadTickets"},
{IPC::MakeHeader(0x0042, 9, 0), nullptr, "StartDownload"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

96
src/core/hle/service/nim/nim_u.cpp
View File

@@ -125,54 +125,54 @@ static_assert(sizeof(AutoDbgDat) == 0x108, "AutoDbgDat structure size is wrong")
NIM_U::NIM_U(Core::System& system) : ServiceFramework("nim:u", 2) { NIM_U::NIM_U(Core::System& system) : ServiceFramework("nim:u", 2) {
const FunctionInfo functions[] = { const FunctionInfo functions[] = {
{0x00010000, &NIM_U::StartNetworkUpdate, "StartNetworkUpdate"}, // clang-format off
{0x00020000, &NIM_U::GetProgress, "GetProgress"}, {IPC::MakeHeader(0x0001, 0, 0), &NIM_U::StartNetworkUpdate, "StartNetworkUpdate"},
{0x00030000, &NIM_U::Cancel, "Cancel"}, {IPC::MakeHeader(0x0002, 0, 0), &NIM_U::GetProgress, "GetProgress"},
{0x00040000, &NIM_U::CommitSystemTitles, "CommitSystemTitles"}, {IPC::MakeHeader(0x0003, 0, 0), &NIM_U::Cancel, "Cancel"},
{0x00050000, &NIM_U::GetBackgroundEventForMenu, "GetBackgroundEventForMenu"}, {IPC::MakeHeader(0x0004, 0, 0), &NIM_U::CommitSystemTitles, "CommitSystemTitles"},
{0x00060000, &NIM_U::GetBackgroundEventForNews, "GetBackgroundEventForNews"}, {IPC::MakeHeader(0x0005, 0, 0), &NIM_U::GetBackgroundEventForMenu, "GetBackgroundEventForMenu"},
{0x00070000, &NIM_U::FormatSaveData, "FormatSaveData"}, {IPC::MakeHeader(0x0006, 0, 0), &NIM_U::GetBackgroundEventForNews, "GetBackgroundEventForNews"},
{0x00080000, &NIM_U::GetCustomerSupportCode, "GetCustomerSupportCode"}, {IPC::MakeHeader(0x0007, 0, 0), &NIM_U::FormatSaveData, "FormatSaveData"},
{0x00090000, &NIM_U::IsCommittableAllSystemTitles, "IsCommittableAllSystemTitles"}, {IPC::MakeHeader(0x0008, 0, 0), &NIM_U::GetCustomerSupportCode, "GetCustomerSupportCode"},
{0x000A0000, &NIM_U::GetBackgroundProgress, "GetBackgroundProgress"}, {IPC::MakeHeader(0x0009, 0, 0), &NIM_U::IsCommittableAllSystemTitles, "IsCommittableAllSystemTitles"},
{0x000B0000, &NIM_U::GetSavedHash, "GetSavedHash"}, {IPC::MakeHeader(0x000A, 0, 0), &NIM_U::GetBackgroundProgress, "GetBackgroundProgress"},
{0x000C0082, &NIM_U::UnregisterTask, "UnregisterTask"}, {IPC::MakeHeader(0x000B, 0, 0), &NIM_U::GetSavedHash, "GetSavedHash"},
{0x000D0080, &NIM_U::IsRegistered, "IsRegistered"}, {IPC::MakeHeader(0x000C, 2, 2), &NIM_U::UnregisterTask, "UnregisterTask"},
{0x000E0080, &NIM_U::FindTaskInfo, "FindTaskInfo"}, {IPC::MakeHeader(0x000D, 2, 0), &NIM_U::IsRegistered, "IsRegistered"},
{0x000F0042, &NIM_U::GetTaskInfos, "GetTaskInfos"}, {IPC::MakeHeader(0x000E, 2, 0), &NIM_U::FindTaskInfo, "FindTaskInfo"},
{0x00100000, &NIM_U::DeleteUnmanagedContexts, "DeleteUnmanagedContexts"}, {IPC::MakeHeader(0x000F, 1, 2), &NIM_U::GetTaskInfos, "GetTaskInfos"},
{0x00110000, &NIM_U::UpdateAutoTitleDownloadTasksAsync, {IPC::MakeHeader(0x0010, 0, 0), &NIM_U::DeleteUnmanagedContexts, "DeleteUnmanagedContexts"},
"UpdateAutoTitleDownloadTasksAsync"}, {IPC::MakeHeader(0x0011, 0, 0), &NIM_U::UpdateAutoTitleDownloadTasksAsync, "UpdateAutoTitleDownloadTasksAsync"},
{0x00120000, &NIM_U::StartPendingAutoTitleDownloadTasksAsync, {IPC::MakeHeader(0x0012, 0, 0), &NIM_U::StartPendingAutoTitleDownloadTasksAsync, "StartPendingAutoTitleDownloadTasksAsync"},
"StartPendingAutoTitleDownloadTasksAsync"}, {IPC::MakeHeader(0x0013, 0, 0), &NIM_U::GetAsyncResult, "GetAsyncResult"},
{0x00130000, &NIM_U::GetAsyncResult, "GetAsyncResult"}, {IPC::MakeHeader(0x0014, 0, 0), &NIM_U::CancelAsyncCall, "CancelAsyncCall"},
{0x00140000, &NIM_U::CancelAsyncCall, "CancelAsyncCall"}, {IPC::MakeHeader(0x0015, 0, 0), &NIM_U::IsPendingAutoTitleDownloadTasks, "IsPendingAutoTitleDownloadTasks"},
{0x00150000, &NIM_U::IsPendingAutoTitleDownloadTasks, "IsPendingAutoTitleDownloadTasks"}, {IPC::MakeHeader(0x0016, 0, 0), &NIM_U::GetNumAutoTitleDownloadTasks, "GetNumAutoTitleDownloadTasks"},
{0x00160000, &NIM_U::GetNumAutoTitleDownloadTasks, "GetNumAutoTitleDownloadTasks"}, {IPC::MakeHeader(0x0017, 1, 2), &NIM_U::GetAutoTitleDownloadTaskInfos, "GetAutoTitleDownloadTaskInfos"},
{0x00170042, &NIM_U::GetAutoTitleDownloadTaskInfos, "GetAutoTitleDownloadTaskInfos"}, {IPC::MakeHeader(0x0018, 2, 0), &NIM_U::CancelAutoTitleDownloadTask, "CancelAutoTitleDownloadTask"},
{0x00180080, &NIM_U::CancelAutoTitleDownloadTask, "CancelAutoTitleDownloadTask"}, {IPC::MakeHeader(0x0019, 0, 2), &NIM_U::SetAutoDbgDat, "SetAutoDbgDat"},
{0x00190002, &NIM_U::SetAutoDbgDat, "SetAutoDbgDat"}, {IPC::MakeHeader(0x001A, 0, 2), &NIM_U::GetAutoDbgDat, "GetAutoDbgDat"},
{0x001A0002, &NIM_U::GetAutoDbgDat, "GetAutoDbgDat"}, {IPC::MakeHeader(0x001B, 1, 2), &NIM_U::SetDbgTasks, "SetDbgTasks"},
{0x001B0042, &NIM_U::SetDbgTasks, "SetDbgTasks"}, {IPC::MakeHeader(0x001C, 1, 2), &NIM_U::GetDbgTasks, "GetDbgTasks"},
{0x001C0042, &NIM_U::GetDbgTasks, "GetDbgTasks"}, {IPC::MakeHeader(0x001D, 0, 0), &NIM_U::DeleteDbgData, "DeleteDbgData"},
{0x001D0000, &NIM_U::DeleteDbgData, "DeleteDbgData"}, {IPC::MakeHeader(0x001E, 1, 2), &NIM_U::SetTslXml, "SetTslXml"},
{0x001E0042, &NIM_U::SetTslXml, "SetTslXml"}, {IPC::MakeHeader(0x001F, 0, 0), &NIM_U::GetTslXmlSize, "GetTslXmlSize"},
{0x001F0000, &NIM_U::GetTslXmlSize, "GetTslXmlSize"}, {IPC::MakeHeader(0x0020, 1, 2), &NIM_U::GetTslXml, "GetTslXml"},
{0x00200042, &NIM_U::GetTslXml, "GetTslXml"}, {IPC::MakeHeader(0x0021, 0, 0), &NIM_U::DeleteTslXml, "DeleteTslXml"},
{0x00210000, &NIM_U::DeleteTslXml, "DeleteTslXml"}, {IPC::MakeHeader(0x0022, 1, 2), &NIM_U::SetDtlXml, "SetDtlXml"},
{0x00220042, &NIM_U::SetDtlXml, "SetDtlXml"}, {IPC::MakeHeader(0x0023, 0, 0), &NIM_U::GetDtlXmlSize, "GetDtlXmlSize"},
{0x00230000, &NIM_U::GetDtlXmlSize, "GetDtlXmlSize"}, {IPC::MakeHeader(0x0024, 1, 2), &NIM_U::GetDtlXml, "GetDtlXml"},
{0x00240042, &NIM_U::GetDtlXml, "GetDtlXml"}, {IPC::MakeHeader(0x0025, 0, 0), &NIM_U::UpdateAccountStatus, "UpdateAccountStatus"},
{0x00250000, &NIM_U::UpdateAccountStatus, "UpdateAccountStatus"}, {IPC::MakeHeader(0x0026, 6, 0), &NIM_U::StartTitleDownload, "StartTitleDownload"},
{0x00260180, &NIM_U::StartTitleDownload, "StartTitleDownload"}, {IPC::MakeHeader(0x0027, 0, 0), &NIM_U::StopTitleDownload, "StopTitleDownload"},
{0x00270000, &NIM_U::StopTitleDownload, "StopTitleDownload"}, {IPC::MakeHeader(0x0028, 0, 0), &NIM_U::GetTitleDownloadProgress, "GetTitleDownloadProgress"},
{0x00280000, &NIM_U::GetTitleDownloadProgress, "GetTitleDownloadProgress"}, {IPC::MakeHeader(0x0029, 9, 6), &NIM_U::RegisterTask, "RegisterTask"},
{0x00290246, &NIM_U::RegisterTask, "RegisterTask"}, {IPC::MakeHeader(0x002A, 0, 0), &NIM_U::IsSystemUpdateAvailable, "IsSystemUpdateAvailable"},
{0x002A0000, &NIM_U::IsSystemUpdateAvailable, "IsSystemUpdateAvailable"}, {IPC::MakeHeader(0x002B, 0, 0), &NIM_U::Unknown2B, "Unknown2B"},
{0x002B0000, &NIM_U::Unknown2B, "Unknown2B"}, {IPC::MakeHeader(0x002C, 0, 0), &NIM_U::UpdateTickets, "UpdateTickets"},
{0x002C0000, &NIM_U::UpdateTickets, "UpdateTickets"}, {IPC::MakeHeader(0x002D, 3, 0), &NIM_U::DownloadTitleSeedAsync, "DownloadTitleSeedAsync"},
{0x002D00C0, &NIM_U::DownloadTitleSeedAsync, "DownloadTitleSeedAsync"}, {IPC::MakeHeader(0x002E, 0, 0), &NIM_U::DownloadMissingTitleSeedsAsync, "DownloadMissingTitleSeedsAsync"},
{0x002E0000, &NIM_U::DownloadMissingTitleSeedsAsync, "DownloadMissingTitleSeedsAsync"}, // clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
nim_system_update_event_for_menu = nim_system_update_event_for_menu =

4
src/core/hle/service/nwm/nwm_cec.cpp
View File

@@ -11,7 +11,9 @@ namespace Service::NWM {
NWM_CEC::NWM_CEC() : ServiceFramework("nwm::CEC") { NWM_CEC::NWM_CEC() : ServiceFramework("nwm::CEC") {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x000D0082, nullptr, "SendProbeRequest"}, // clang-format off
{IPC::MakeHeader(0x000D, 2, 2), nullptr, "SendProbeRequest"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

4
src/core/hle/service/nwm/nwm_ext.cpp
View File

@@ -11,7 +11,9 @@ namespace Service::NWM {
NWM_EXT::NWM_EXT() : ServiceFramework("nwm::EXT") { NWM_EXT::NWM_EXT() : ServiceFramework("nwm::EXT") {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x00080040, nullptr, "ControlWirelessEnabled"}, // clang-format off
{IPC::MakeHeader(0x0008, 1, 0), nullptr, "ControlWirelessEnabled"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

8
src/core/hle/service/nwm/nwm_inf.cpp
View File

@@ -11,9 +11,11 @@ namespace Service::NWM {
NWM_INF::NWM_INF() : ServiceFramework("nwm::INF") { NWM_INF::NWM_INF() : ServiceFramework("nwm::INF") {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x000603C4, nullptr, "RecvBeaconBroadcastData"}, // clang-format off
{0x00070742, nullptr, "ConnectToEncryptedAP"}, {IPC::MakeHeader(0x0006, 15, 4), nullptr, "RecvBeaconBroadcastData"},
{0x00080302, nullptr, "ConnectToAP"}, {IPC::MakeHeader(0x0007, 29, 2), nullptr, "ConnectToEncryptedAP"},
{IPC::MakeHeader(0x0008, 12, 2), nullptr, "ConnectToAP"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

60
src/core/hle/service/nwm/nwm_uds.cpp
View File

@@ -1467,35 +1467,37 @@ void NWM_UDS::BeaconBroadcastCallback(std::uintptr_t user_data, s64 cycles_late)
NWM_UDS::NWM_UDS(Core::System& system) : ServiceFramework("nwm::UDS"), system(system) { NWM_UDS::NWM_UDS(Core::System& system) : ServiceFramework("nwm::UDS"), system(system) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x000102C2, &NWM_UDS::InitializeDeprecated, "Initialize (deprecated)"}, // clang-format off
{0x00020000, nullptr, "Scrap"}, {IPC::MakeHeader(0x0001, 11, 2), &NWM_UDS::InitializeDeprecated, "Initialize (deprecated)"},
{0x00030000, &NWM_UDS::Shutdown, "Shutdown"}, {IPC::MakeHeader(0x0002, 0, 0), nullptr, "Scrap"},
{0x00040402, &NWM_UDS::BeginHostingNetworkDeprecated, "BeginHostingNetwork (deprecated)"}, {IPC::MakeHeader(0x0003, 0, 0), &NWM_UDS::Shutdown, "Shutdown"},
{0x00050040, &NWM_UDS::EjectClient, "EjectClient"}, {IPC::MakeHeader(0x0004, 16, 2), &NWM_UDS::BeginHostingNetworkDeprecated, "BeginHostingNetwork (deprecated)"},
{0x00060000, nullptr, "EjectSpectator"}, {IPC::MakeHeader(0x0005, 1, 0), &NWM_UDS::EjectClient, "EjectClient"},
{0x00070080, &NWM_UDS::UpdateNetworkAttribute, "UpdateNetworkAttribute"}, {IPC::MakeHeader(0x0006, 0, 0), nullptr, "EjectSpectator"},
{0x00080000, &NWM_UDS::DestroyNetwork, "DestroyNetwork"}, {IPC::MakeHeader(0x0007, 2, 0), &NWM_UDS::UpdateNetworkAttribute, "UpdateNetworkAttribute"},
{0x00090442, &NWM_UDS::ConnectToNetworkDeprecated, "ConnectToNetwork (deprecated)"}, {IPC::MakeHeader(0x0008, 0, 0), &NWM_UDS::DestroyNetwork, "DestroyNetwork"},
{0x000A0000, &NWM_UDS::DisconnectNetwork, "DisconnectNetwork"}, {IPC::MakeHeader(0x0009, 17, 2), &NWM_UDS::ConnectToNetworkDeprecated, "ConnectToNetwork (deprecated)"},
{0x000B0000, &NWM_UDS::GetConnectionStatus, "GetConnectionStatus"}, {IPC::MakeHeader(0x000A, 0, 0), &NWM_UDS::DisconnectNetwork, "DisconnectNetwork"},
{0x000D0040, &NWM_UDS::GetNodeInformation, "GetNodeInformation"}, {IPC::MakeHeader(0x000B, 0, 0), &NWM_UDS::GetConnectionStatus, "GetConnectionStatus"},
{0x000E0006, &NWM_UDS::DecryptBeaconData<0x0E>, "DecryptBeaconData (deprecated)"}, {IPC::MakeHeader(0x000D, 1, 0), &NWM_UDS::GetNodeInformation, "GetNodeInformation"},
{0x000F0404, &NWM_UDS::RecvBeaconBroadcastData, "RecvBeaconBroadcastData"}, {IPC::MakeHeader(0x000E, 0, 6), &NWM_UDS::DecryptBeaconData<0x0E>, "DecryptBeaconData (deprecated)"},
{0x00100042, &NWM_UDS::SetApplicationData, "SetApplicationData"}, {IPC::MakeHeader(0x000F, 16, 4), &NWM_UDS::RecvBeaconBroadcastData, "RecvBeaconBroadcastData"},
{0x00110040, &NWM_UDS::GetApplicationData, "GetApplicationData"}, {IPC::MakeHeader(0x0010, 1, 2), &NWM_UDS::SetApplicationData, "SetApplicationData"},
{0x00120100, &NWM_UDS::Bind, "Bind"}, {IPC::MakeHeader(0x0011, 1, 0), &NWM_UDS::GetApplicationData, "GetApplicationData"},
{0x00130040, &NWM_UDS::Unbind, "Unbind"}, {IPC::MakeHeader(0x0012, 4, 0), &NWM_UDS::Bind, "Bind"},
{0x001400C0, &NWM_UDS::PullPacket, "PullPacket"}, {IPC::MakeHeader(0x0013, 1, 0), &NWM_UDS::Unbind, "Unbind"},
{0x00150080, nullptr, "SetMaxSendDelay"}, {IPC::MakeHeader(0x0014, 3, 0), &NWM_UDS::PullPacket, "PullPacket"},
{0x00170182, &NWM_UDS::SendTo, "SendTo"}, {IPC::MakeHeader(0x0015, 2, 0), nullptr, "SetMaxSendDelay"},
{0x001A0000, &NWM_UDS::GetChannel, "GetChannel"}, {IPC::MakeHeader(0x0017, 6, 2), &NWM_UDS::SendTo, "SendTo"},
{0x001B0302, &NWM_UDS::InitializeWithVersion, "InitializeWithVersion"}, {IPC::MakeHeader(0x001A, 0, 0), &NWM_UDS::GetChannel, "GetChannel"},
{0x001D0044, &NWM_UDS::BeginHostingNetwork, "BeginHostingNetwork"}, {IPC::MakeHeader(0x001B, 12, 2), &NWM_UDS::InitializeWithVersion, "InitializeWithVersion"},
{0x001E0084, &NWM_UDS::ConnectToNetwork, "ConnectToNetwork"}, {IPC::MakeHeader(0x001D, 1, 4), &NWM_UDS::BeginHostingNetwork, "BeginHostingNetwork"},
{0x001F0006, &NWM_UDS::DecryptBeaconData<0x1F>, "DecryptBeaconData"}, {IPC::MakeHeader(0x001E, 2, 4), &NWM_UDS::ConnectToNetwork, "ConnectToNetwork"},
{0x00200040, nullptr, "Flush"}, {IPC::MakeHeader(0x001F, 0, 6), &NWM_UDS::DecryptBeaconData<0x1F>, "DecryptBeaconData"},
{0x00210080, nullptr, "SetProbeResponseParam"}, {IPC::MakeHeader(0x0020, 1, 0), nullptr, "Flush"},
{0x00220402, nullptr, "ScanOnConnection"}, {IPC::MakeHeader(0x0021, 2, 0), nullptr, "SetProbeResponseParam"},
{IPC::MakeHeader(0x0022, 16, 2), nullptr, "ScanOnConnection"},
// clang-format on
}; };
connection_status_event = connection_status_event =
system.Kernel().CreateEvent(Kernel::ResetType::OneShot, "NWM::connection_status_event"); system.Kernel().CreateEvent(Kernel::ResetType::OneShot, "NWM::connection_status_event");

28
src/core/hle/service/plgldr/plgldr.cpp
View File

@@ -47,19 +47,21 @@ PAddr PLG_LDR::plugin_fb_addr = 0;
PLG_LDR::PLG_LDR() : ServiceFramework{"plg:ldr", 1} { PLG_LDR::PLG_LDR() : ServiceFramework{"plg:ldr", 1} {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{IPC::MakeHeader(1, 0, 2), nullptr, "LoadPlugin"}, // clang-format off
{IPC::MakeHeader(2, 0, 0), &PLG_LDR::IsEnabled, "IsEnabled"}, {IPC::MakeHeader(0x0001, 0, 2), nullptr, "LoadPlugin"},
{IPC::MakeHeader(3, 1, 0), &PLG_LDR::SetEnabled, "SetEnabled"}, {IPC::MakeHeader(0x0002, 0, 0), &PLG_LDR::IsEnabled, "IsEnabled"},
{IPC::MakeHeader(4, 2, 4), &PLG_LDR::SetLoadSettings, "SetLoadSettings"}, {IPC::MakeHeader(0x0003, 1, 0), &PLG_LDR::SetEnabled, "SetEnabled"},
{IPC::MakeHeader(5, 1, 8), nullptr, "DisplayMenu"}, {IPC::MakeHeader(0x0004, 2, 4), &PLG_LDR::SetLoadSettings, "SetLoadSettings"},
{IPC::MakeHeader(6, 0, 4), nullptr, "DisplayMessage"}, {IPC::MakeHeader(0x0005, 1, 8), nullptr, "DisplayMenu"},
{IPC::MakeHeader(7, 1, 4), &PLG_LDR::DisplayErrorMessage, "DisplayErrorMessage"}, {IPC::MakeHeader(0x0006, 0, 4), nullptr, "DisplayMessage"},
{IPC::MakeHeader(8, 0, 0), &PLG_LDR::GetPLGLDRVersion, "GetPLGLDRVersion"}, {IPC::MakeHeader(0x0007, 1, 4), &PLG_LDR::DisplayErrorMessage, "DisplayErrorMessage"},
{IPC::MakeHeader(9, 0, 0), &PLG_LDR::GetArbiter, "GetArbiter"}, {IPC::MakeHeader(0x0008, 0, 0), &PLG_LDR::GetPLGLDRVersion, "GetPLGLDRVersion"},
{IPC::MakeHeader(10, 0, 2), &PLG_LDR::GetPluginPath, "GetPluginPath"}, {IPC::MakeHeader(0x0009, 0, 0), &PLG_LDR::GetArbiter, "GetArbiter"},
{IPC::MakeHeader(11, 1, 0), nullptr, "SetRosalinaMenuBlock"}, {IPC::MakeHeader(0x000A, 0, 2), &PLG_LDR::GetPluginPath, "GetPluginPath"},
{IPC::MakeHeader(12, 2, 4), nullptr, "SetSwapParam"}, {IPC::MakeHeader(0x000B, 1, 0), nullptr, "SetRosalinaMenuBlock"},
{IPC::MakeHeader(13, 1, 2), nullptr, "SetLoadExeParam"}, {IPC::MakeHeader(0x000C, 2, 4), nullptr, "SetSwapParam"},
{IPC::MakeHeader(0x000D, 1, 2), nullptr, "SetLoadExeParam"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
plgldr_context.memory_changed_handle = 0; plgldr_context.memory_changed_handle = 0;

26
src/core/hle/service/pm/pm_app.cpp
View File

@@ -13,19 +13,19 @@ namespace Service::PM {
PM_APP::PM_APP() : ServiceFramework("pm:app", 3) { PM_APP::PM_APP() : ServiceFramework("pm:app", 3) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
// clang-format off // clang-format off
{0x00010140, nullptr, "LaunchTitle"}, {IPC::MakeHeader(0x0001, 5, 0), nullptr, "LaunchTitle"},
{0x00020082, nullptr, "LaunchFIRM"}, {IPC::MakeHeader(0x0002, 2, 2), nullptr, "LaunchFIRM"},
{0x00030080, nullptr, "TerminateApplication"}, {IPC::MakeHeader(0x0003, 2, 0), nullptr, "TerminateApplication"},
{0x00040100, nullptr, "TerminateTitle"}, {IPC::MakeHeader(0x0004, 4, 0), nullptr, "TerminateTitle"},
{0x000500C0, nullptr, "TerminateProcess"}, {IPC::MakeHeader(0x0005, 3, 0), nullptr, "TerminateProcess"},
{0x00060082, nullptr, "PrepareForReboot"}, {IPC::MakeHeader(0x0006, 2, 2), nullptr, "PrepareForReboot"},
{0x00070042, nullptr, "GetFIRMLaunchParams"}, {IPC::MakeHeader(0x0007, 1, 2), nullptr, "GetFIRMLaunchParams"},
{0x00080100, nullptr, "GetTitleExheaderFlags"}, {IPC::MakeHeader(0x0008, 4, 0), nullptr, "GetTitleExheaderFlags"},
{0x00090042, nullptr, "SetFIRMLaunchParams"}, {IPC::MakeHeader(0x0009, 1, 2), nullptr, "SetFIRMLaunchParams"},
{0x000A0140, nullptr, "SetAppResourceLimit"}, {IPC::MakeHeader(0x000A, 5, 0), nullptr, "SetAppResourceLimit"},
{0x000B0140, nullptr, "GetAppResourceLimit"}, {IPC::MakeHeader(0x000B, 5, 0), nullptr, "GetAppResourceLimit"},
{0x000C0080, nullptr, "UnregisterProcess"}, {IPC::MakeHeader(0x000C, 2, 0), nullptr, "UnregisterProcess"},
{0x000D0240, nullptr, "LaunchTitleUpdate"}, {IPC::MakeHeader(0x000D, 9, 0), nullptr, "LaunchTitleUpdate"},
// clang-format on // clang-format on
}; };

6
src/core/hle/service/pm/pm_dbg.cpp
View File

@@ -13,9 +13,9 @@ namespace Service::PM {
PM_DBG::PM_DBG() : ServiceFramework("pm:dbg", 3) { PM_DBG::PM_DBG() : ServiceFramework("pm:dbg", 3) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
// clang-format off // clang-format off
{0x00010140, nullptr, "LaunchAppDebug"}, {IPC::MakeHeader(0x0001, 5, 0), nullptr, "LaunchAppDebug"},
{0x00020140, nullptr, "LaunchApp"}, {IPC::MakeHeader(0x0002, 5, 0), nullptr, "LaunchApp"},
{0x00030000, nullptr, "RunQueuedProcess"}, {IPC::MakeHeader(0x0003, 0, 0), nullptr, "RunQueuedProcess"},
// clang-format on // clang-format on
}; };

32
src/core/hle/service/ps/ps_ps.cpp
View File

@@ -149,22 +149,22 @@ void PS_PS::EncryptDecryptAes(Kernel::HLERequestContext& ctx) {
PS_PS::PS_PS() : ServiceFramework("ps:ps", DefaultMaxSessions) { PS_PS::PS_PS() : ServiceFramework("ps:ps", DefaultMaxSessions) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
// clang-format off // clang-format off
{0x00010244, nullptr, "SignRsaSha256"}, {IPC::MakeHeader(0x0001, 9, 4), nullptr, "SignRsaSha256"},
{0x00020244, nullptr, "VerifyRsaSha256"}, {IPC::MakeHeader(0x0002, 9, 4), nullptr, "VerifyRsaSha256"},
{0x00040204, &PS_PS::EncryptDecryptAes, "EncryptDecryptAes"}, {IPC::MakeHeader(0x0004, 8, 4), &PS_PS::EncryptDecryptAes, "EncryptDecryptAes"},
{0x00050284, nullptr, "EncryptSignDecryptVerifyAesCcm"}, {IPC::MakeHeader(0x0005, 10, 4), nullptr, "EncryptSignDecryptVerifyAesCcm"},
{0x00060040, nullptr, "GetRomId"}, {IPC::MakeHeader(0x0006, 1, 0), nullptr, "GetRomId"},
{0x00070040, nullptr, "GetRomId2"}, {IPC::MakeHeader(0x0007, 1, 0), nullptr, "GetRomId2"},
{0x00080040, nullptr, "GetRomMakerCode"}, {IPC::MakeHeader(0x0008, 1, 0), nullptr, "GetRomMakerCode"},
{0x00090000, nullptr, "GetCTRCardAutoStartupBit"}, {IPC::MakeHeader(0x0009, 0, 0), nullptr, "GetCTRCardAutoStartupBit"},
{0x000A0000, nullptr, "GetLocalFriendCodeSeed"}, {IPC::MakeHeader(0x000A, 0, 0), nullptr, "GetLocalFriendCodeSeed"},
{0x000B0000, nullptr, "GetDeviceId"}, {IPC::MakeHeader(0x000B, 0, 0), nullptr, "GetDeviceId"},
{0x000C0000, nullptr, "SeedRNG"}, {IPC::MakeHeader(0x000C, 0, 0), nullptr, "SeedRNG"},
{0x000D0042, nullptr, "GenerateRandomBytes"}, {IPC::MakeHeader(0x000D, 1, 2), nullptr, "GenerateRandomBytes"},
{0x000E0082, nullptr, "InterfaceForPXI_0x04010084"}, {IPC::MakeHeader(0x000E, 2, 2), nullptr, "InterfaceForPXI_0x04010084"},
{0x000F0082, nullptr, "InterfaceForPXI_0x04020082"}, {IPC::MakeHeader(0x000F, 2, 2), nullptr, "InterfaceForPXI_0x04020082"},
{0x00100042, nullptr, "InterfaceForPXI_0x04030044"}, {IPC::MakeHeader(0x0010, 1, 2), nullptr, "InterfaceForPXI_0x04030044"},
{0x00110042, nullptr, "InterfaceForPXI_0x04040044"}, {IPC::MakeHeader(0x0011, 1, 2), nullptr, "InterfaceForPXI_0x04040044"},
// clang-format on // clang-format on
}; };

34
src/core/hle/service/ptm/ptm_gets.cpp
View File

@@ -13,23 +13,25 @@ PTM_Gets::PTM_Gets(std::shared_ptr<Module> ptm)
: Module::Interface(std::move(ptm), "ptm:gets", 26) { : Module::Interface(std::move(ptm), "ptm:gets", 26) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
// ptm:u common commands // ptm:u common commands
{0x00010002, nullptr, "RegisterAlarmClient"}, // clang-format off
{0x00020080, nullptr, "SetRtcAlarm"}, {IPC::MakeHeader(0x0001, 0, 2), nullptr, "RegisterAlarmClient"},
{0x00030000, nullptr, "GetRtcAlarm"}, {IPC::MakeHeader(0x0002, 2, 0), nullptr, "SetRtcAlarm"},
{0x00040000, nullptr, "CancelRtcAlarm"}, {IPC::MakeHeader(0x0003, 0, 0), nullptr, "GetRtcAlarm"},
{0x00050000, &PTM_Gets::GetAdapterState, "GetAdapterState"}, {IPC::MakeHeader(0x0004, 0, 0), nullptr, "CancelRtcAlarm"},
{0x00060000, &PTM_Gets::GetShellState, "GetShellState"}, {IPC::MakeHeader(0x0005, 0, 0), &PTM_Gets::GetAdapterState, "GetAdapterState"},
{0x00070000, &PTM_Gets::GetBatteryLevel, "GetBatteryLevel"}, {IPC::MakeHeader(0x0006, 0, 0), &PTM_Gets::GetShellState, "GetShellState"},
{0x00080000, &PTM_Gets::GetBatteryChargeState, "GetBatteryChargeState"}, {IPC::MakeHeader(0x0007, 0, 0), &PTM_Gets::GetBatteryLevel, "GetBatteryLevel"},
{0x00090000, nullptr, "GetPedometerState"}, {IPC::MakeHeader(0x0008, 0, 0), &PTM_Gets::GetBatteryChargeState, "GetBatteryChargeState"},
{0x000A0042, nullptr, "GetStepHistoryEntry"}, {IPC::MakeHeader(0x0009, 0, 0), nullptr, "GetPedometerState"},
{0x000B00C2, &PTM_Gets::GetStepHistory, "GetStepHistory"}, {IPC::MakeHeader(0x000A, 1, 2), nullptr, "GetStepHistoryEntry"},
{0x000C0000, &PTM_Gets::GetTotalStepCount, "GetTotalStepCount"}, {IPC::MakeHeader(0x000B, 3, 2), &PTM_Gets::GetStepHistory, "GetStepHistory"},
{0x000D0040, nullptr, "SetPedometerRecordingMode"}, {IPC::MakeHeader(0x000C, 0, 0), &PTM_Gets::GetTotalStepCount, "GetTotalStepCount"},
{0x000E0000, nullptr, "GetPedometerRecordingMode"}, {IPC::MakeHeader(0x000D, 1, 0), nullptr, "SetPedometerRecordingMode"},
{0x000F0084, nullptr, "GetStepHistoryAll"}, {IPC::MakeHeader(0x000E, 0, 0), nullptr, "GetPedometerRecordingMode"},
{IPC::MakeHeader(0x000F, 2, 4), nullptr, "GetStepHistoryAll"},
// ptm:gets // ptm:gets
{0x04010000, nullptr, "GetSystemTime"}, {IPC::MakeHeader(0x0401, 0, 0), nullptr, "GetSystemTime"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

40
src/core/hle/service/ptm/ptm_play.cpp
View File

@@ -13,26 +13,28 @@ PTM_Play::PTM_Play(std::shared_ptr<Module> ptm)
: Module::Interface(std::move(ptm), "ptm:play", 26) { : Module::Interface(std::move(ptm), "ptm:play", 26) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
// ptm:u common commands // ptm:u common commands
{0x00010002, nullptr, "RegisterAlarmClient"}, // clang-format off
{0x00020080, nullptr, "SetRtcAlarm"}, {IPC::MakeHeader(0x0001, 0, 2), nullptr, "RegisterAlarmClient"},
{0x00030000, nullptr, "GetRtcAlarm"}, {IPC::MakeHeader(0x0002, 2, 0), nullptr, "SetRtcAlarm"},
{0x00040000, nullptr, "CancelRtcAlarm"}, {IPC::MakeHeader(0x0003, 0, 0), nullptr, "GetRtcAlarm"},
{0x00050000, &PTM_Play::GetAdapterState, "GetAdapterState"}, {IPC::MakeHeader(0x0004, 0, 0), nullptr, "CancelRtcAlarm"},
{0x00060000, &PTM_Play::GetShellState, "GetShellState"}, {IPC::MakeHeader(0x0005, 0, 0), &PTM_Play::GetAdapterState, "GetAdapterState"},
{0x00070000, &PTM_Play::GetBatteryLevel, "GetBatteryLevel"}, {IPC::MakeHeader(0x0006, 0, 0), &PTM_Play::GetShellState, "GetShellState"},
{0x00080000, &PTM_Play::GetBatteryChargeState, "GetBatteryChargeState"}, {IPC::MakeHeader(0x0007, 0, 0), &PTM_Play::GetBatteryLevel, "GetBatteryLevel"},
{0x00090000, nullptr, "GetPedometerState"}, {IPC::MakeHeader(0x0008, 0, 0), &PTM_Play::GetBatteryChargeState, "GetBatteryChargeState"},
{0x000A0042, nullptr, "GetStepHistoryEntry"}, {IPC::MakeHeader(0x0009, 0, 0), nullptr, "GetPedometerState"},
{0x000B00C2, &PTM_Play::GetStepHistory, "GetStepHistory"}, {IPC::MakeHeader(0x000A, 1, 2), nullptr, "GetStepHistoryEntry"},
{0x000C0000, &PTM_Play::GetTotalStepCount, "GetTotalStepCount"}, {IPC::MakeHeader(0x000B, 3, 2), &PTM_Play::GetStepHistory, "GetStepHistory"},
{0x000D0040, nullptr, "SetPedometerRecordingMode"}, {IPC::MakeHeader(0x000C, 0, 0), &PTM_Play::GetTotalStepCount, "GetTotalStepCount"},
{0x000E0000, nullptr, "GetPedometerRecordingMode"}, {IPC::MakeHeader(0x000D, 1, 0), nullptr, "SetPedometerRecordingMode"},
{0x000F0084, nullptr, "GetStepHistoryAll"}, {IPC::MakeHeader(0x000E, 0, 0), nullptr, "GetPedometerRecordingMode"},
{IPC::MakeHeader(0x000F, 2, 4), nullptr, "GetStepHistoryAll"},
// ptm:play // ptm:play
{0x08070082, nullptr, "GetPlayHistory"}, {IPC::MakeHeader(0x0807, 2, 2), nullptr, "GetPlayHistory"},
{0x08080000, nullptr, "GetPlayHistoryStart"}, {IPC::MakeHeader(0x0808, 0, 0), nullptr, "GetPlayHistoryStart"},
{0x08090000, nullptr, "GetPlayHistoryLength"}, {IPC::MakeHeader(0x0809, 0, 0), nullptr, "GetPlayHistoryLength"},
{0x080B0080, nullptr, "CalcPlayHistoryStart"}, {IPC::MakeHeader(0x080B, 2, 0), nullptr, "CalcPlayHistoryStart"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

4
src/core/hle/service/ptm/ptm_sets.cpp
View File

@@ -12,7 +12,9 @@ namespace Service::PTM {
PTM_Sets::PTM_Sets(std::shared_ptr<Module> ptm) : Module::Interface(std::move(ptm), "ptm:sets", 1) { PTM_Sets::PTM_Sets(std::shared_ptr<Module> ptm) : Module::Interface(std::move(ptm), "ptm:sets", 1) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
// Note that this service does not have access to ptm:u's common commands // Note that this service does not have access to ptm:u's common commands
{0x00010080, nullptr, "SetSystemTime"}, // clang-format off
{IPC::MakeHeader(0x0001, 2, 0), nullptr, "SetSystemTime"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

94
src/core/hle/service/ptm/ptm_sysm.cpp
View File

@@ -14,53 +14,55 @@ PTM_S_Common::PTM_S_Common(std::shared_ptr<Module> ptm, const char* name)
: Module::Interface(std::move(ptm), name, 26) { : Module::Interface(std::move(ptm), name, 26) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
// ptm:u common commands // ptm:u common commands
{0x00010002, nullptr, "RegisterAlarmClient"}, // clang-format off
{0x00020080, nullptr, "SetRtcAlarm"}, {IPC::MakeHeader(0x0001, 0, 2), nullptr, "RegisterAlarmClient"},
{0x00030000, nullptr, "GetRtcAlarm"}, {IPC::MakeHeader(0x0002, 2, 0), nullptr, "SetRtcAlarm"},
{0x00040000, nullptr, "CancelRtcAlarm"}, {IPC::MakeHeader(0x0003, 0, 0), nullptr, "GetRtcAlarm"},
{0x00050000, &PTM_S_Common::GetAdapterState, "GetAdapterState"}, {IPC::MakeHeader(0x0004, 0, 0), nullptr, "CancelRtcAlarm"},
{0x00060000, &PTM_S_Common::GetShellState, "GetShellState"}, {IPC::MakeHeader(0x0005, 0, 0), &PTM_S_Common::GetAdapterState, "GetAdapterState"},
{0x00070000, &PTM_S_Common::GetBatteryLevel, "GetBatteryLevel"}, {IPC::MakeHeader(0x0006, 0, 0), &PTM_S_Common::GetShellState, "GetShellState"},
{0x00080000, &PTM_S_Common::GetBatteryChargeState, "GetBatteryChargeState"}, {IPC::MakeHeader(0x0007, 0, 0), &PTM_S_Common::GetBatteryLevel, "GetBatteryLevel"},
{0x00090000, nullptr, "GetPedometerState"}, {IPC::MakeHeader(0x0008, 0, 0), &PTM_S_Common::GetBatteryChargeState, "GetBatteryChargeState"},
{0x000A0042, nullptr, "GetStepHistoryEntry"}, {IPC::MakeHeader(0x0009, 0, 0), nullptr, "GetPedometerState"},
{0x000B00C2, &PTM_S_Common::GetStepHistory, "GetStepHistory"}, {IPC::MakeHeader(0x000A, 1, 2), nullptr, "GetStepHistoryEntry"},
{0x000C0000, &PTM_S_Common::GetTotalStepCount, "GetTotalStepCount"}, {IPC::MakeHeader(0x000B, 3, 2), &PTM_S_Common::GetStepHistory, "GetStepHistory"},
{0x000D0040, nullptr, "SetPedometerRecordingMode"}, {IPC::MakeHeader(0x000C, 0, 0), &PTM_S_Common::GetTotalStepCount, "GetTotalStepCount"},
{0x000E0000, nullptr, "GetPedometerRecordingMode"}, {IPC::MakeHeader(0x000D, 1, 0), nullptr, "SetPedometerRecordingMode"},
{0x000F0084, nullptr, "GetStepHistoryAll"}, {IPC::MakeHeader(0x000E, 0, 0), nullptr, "GetPedometerRecordingMode"},
{IPC::MakeHeader(0x000F, 2, 4), nullptr, "GetStepHistoryAll"},
// ptm:sysm & ptm:s // ptm:sysm & ptm:s
{0x040100C0, nullptr, "SetRtcAlarmEx"}, {IPC::MakeHeader(0x0401, 3, 0), nullptr, "SetRtcAlarmEx"},
{0x04020042, nullptr, "ReplySleepQuery"}, {IPC::MakeHeader(0x0402, 1, 2), nullptr, "ReplySleepQuery"},
{0x04030042, nullptr, "NotifySleepPreparationComplete"}, {IPC::MakeHeader(0x0403, 1, 2), nullptr, "NotifySleepPreparationComplete"},
{0x04040102, nullptr, "SetWakeupTrigger"}, {IPC::MakeHeader(0x0404, 4, 2), nullptr, "SetWakeupTrigger"},
{0x04050000, nullptr, "GetAwakeReason"}, {IPC::MakeHeader(0x0405, 0, 0), nullptr, "GetAwakeReason"},
{0x04060000, nullptr, "RequestSleep"}, {IPC::MakeHeader(0x0406, 0, 0), nullptr, "RequestSleep"},
{0x040700C0, nullptr, "ShutdownAsync"}, {IPC::MakeHeader(0x0407, 3, 0), nullptr, "ShutdownAsync"},
{0x04080000, nullptr, "Awake"}, {IPC::MakeHeader(0x0408, 0, 0), nullptr, "Awake"},
{0x04090080, nullptr, "RebootAsync"}, {IPC::MakeHeader(0x0409, 2, 0), nullptr, "RebootAsync"},
{0x040A0000, &PTM_S_Common::CheckNew3DS, "CheckNew3DS"}, {IPC::MakeHeader(0x040A, 0, 0), &PTM_S_Common::CheckNew3DS, "CheckNew3DS"},
{0x08010640, nullptr, "SetInfoLEDPattern"}, {IPC::MakeHeader(0x0801, 25, 0), nullptr, "SetInfoLEDPattern"},
{0x08020040, nullptr, "SetInfoLEDPatternHeader"}, {IPC::MakeHeader(0x0802, 1, 0), nullptr, "SetInfoLEDPatternHeader"},
{0x08030000, nullptr, "GetInfoLEDStatus"}, {IPC::MakeHeader(0x0803, 0, 0), nullptr, "GetInfoLEDStatus"},
{0x08040040, nullptr, "SetBatteryEmptyLEDPattern"}, {IPC::MakeHeader(0x0804, 1, 0), nullptr, "SetBatteryEmptyLEDPattern"},
{0x08050000, nullptr, "ClearStepHistory"}, {IPC::MakeHeader(0x0805, 0, 0), nullptr, "ClearStepHistory"},
{0x080600C2, nullptr, "SetStepHistory"}, {IPC::MakeHeader(0x0806, 3, 2), nullptr, "SetStepHistory"},
{0x08070082, nullptr, "GetPlayHistory"}, {IPC::MakeHeader(0x0807, 2, 2), nullptr, "GetPlayHistory"},
{0x08080000, nullptr, "GetPlayHistoryStart"}, {IPC::MakeHeader(0x0808, 0, 0), nullptr, "GetPlayHistoryStart"},
{0x08090000, nullptr, "GetPlayHistoryLength"}, {IPC::MakeHeader(0x0809, 0, 0), nullptr, "GetPlayHistoryLength"},
{0x080A0000, nullptr, "ClearPlayHistory"}, {IPC::MakeHeader(0x080A, 0, 0), nullptr, "ClearPlayHistory"},
{0x080B0080, nullptr, "CalcPlayHistoryStart"}, {IPC::MakeHeader(0x080B, 2, 0), nullptr, "CalcPlayHistoryStart"},
{0x080C0080, nullptr, "SetUserTime"}, {IPC::MakeHeader(0x080C, 2, 0), nullptr, "SetUserTime"},
{0x080D0000, nullptr, "InvalidateSystemTime"}, {IPC::MakeHeader(0x080D, 0, 0), nullptr, "InvalidateSystemTime"},
{0x080E0140, nullptr, "NotifyPlayEvent"}, {IPC::MakeHeader(0x080E, 5, 0), nullptr, "NotifyPlayEvent"},
{0x080F0000, &PTM_S_Common::GetSoftwareClosedFlag, "GetSoftwareClosedFlag"}, {IPC::MakeHeader(0x080F, 0, 0), &PTM_S_Common::GetSoftwareClosedFlag, "GetSoftwareClosedFlag"},
{0x08100000, nullptr, "ClearSoftwareClosedFlag"}, {IPC::MakeHeader(0x0810, 0, 0), nullptr, "ClearSoftwareClosedFlag"},
{0x08110000, &PTM_S_Common::GetShellState, "GetShellState"}, {IPC::MakeHeader(0x0811, 0, 0), &PTM_S_Common::GetShellState, "GetShellState"},
{0x08120000, nullptr, "IsShutdownByBatteryEmpty"}, {IPC::MakeHeader(0x0812, 0, 0), nullptr, "IsShutdownByBatteryEmpty"},
{0x08130000, nullptr, "FormatSavedata"}, {IPC::MakeHeader(0x0813, 0, 0), nullptr, "FormatSavedata"},
{0x08140000, nullptr, "GetLegacyJumpProhibitedFlag"}, {IPC::MakeHeader(0x0814, 0, 0), nullptr, "GetLegacyJumpProhibitedFlag"},
{0x08180040, nullptr, "ConfigureNew3DSCPU"}, {IPC::MakeHeader(0x0818, 1, 0), nullptr, "ConfigureNew3DSCPU"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

32
src/core/hle/service/ptm/ptm_u.cpp
View File

@@ -11,21 +11,23 @@ namespace Service::PTM {
PTM_U::PTM_U(std::shared_ptr<Module> ptm) : Module::Interface(std::move(ptm), "ptm:u", 26) { PTM_U::PTM_U(std::shared_ptr<Module> ptm) : Module::Interface(std::move(ptm), "ptm:u", 26) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x00010002, nullptr, "RegisterAlarmClient"}, // clang-format off
{0x00020080, nullptr, "SetRtcAlarm"}, {IPC::MakeHeader(0x0001, 0, 2), nullptr, "RegisterAlarmClient"},
{0x00030000, nullptr, "GetRtcAlarm"}, {IPC::MakeHeader(0x0002, 2, 0), nullptr, "SetRtcAlarm"},
{0x00040000, nullptr, "CancelRtcAlarm"}, {IPC::MakeHeader(0x0003, 0, 0), nullptr, "GetRtcAlarm"},
{0x00050000, &PTM_U::GetAdapterState, "GetAdapterState"}, {IPC::MakeHeader(0x0004, 0, 0), nullptr, "CancelRtcAlarm"},
{0x00060000, &PTM_U::GetShellState, "GetShellState"}, {IPC::MakeHeader(0x0005, 0, 0), &PTM_U::GetAdapterState, "GetAdapterState"},
{0x00070000, &PTM_U::GetBatteryLevel, "GetBatteryLevel"}, {IPC::MakeHeader(0x0006, 0, 0), &PTM_U::GetShellState, "GetShellState"},
{0x00080000, &PTM_U::GetBatteryChargeState, "GetBatteryChargeState"}, {IPC::MakeHeader(0x0007, 0, 0), &PTM_U::GetBatteryLevel, "GetBatteryLevel"},
{0x00090000, &PTM_U::GetPedometerState, "GetPedometerState"}, {IPC::MakeHeader(0x0008, 0, 0), &PTM_U::GetBatteryChargeState, "GetBatteryChargeState"},
{0x000A0042, nullptr, "GetStepHistoryEntry"}, {IPC::MakeHeader(0x0009, 0, 0), &PTM_U::GetPedometerState, "GetPedometerState"},
{0x000B00C2, &PTM_U::GetStepHistory, "GetStepHistory"}, {IPC::MakeHeader(0x000A, 1, 2), nullptr, "GetStepHistoryEntry"},
{0x000C0000, &PTM_U::GetTotalStepCount, "GetTotalStepCount"}, {IPC::MakeHeader(0x000B, 3, 2), &PTM_U::GetStepHistory, "GetStepHistory"},
{0x000D0040, nullptr, "SetPedometerRecordingMode"}, {IPC::MakeHeader(0x000C, 0, 0), &PTM_U::GetTotalStepCount, "GetTotalStepCount"},
{0x000E0000, nullptr, "GetPedometerRecordingMode"}, {IPC::MakeHeader(0x000D, 1, 0), nullptr, "SetPedometerRecordingMode"},
{0x000F0084, nullptr, "GetStepHistoryAll"}, {IPC::MakeHeader(0x000E, 0, 0), nullptr, "GetPedometerRecordingMode"},
{IPC::MakeHeader(0x000F, 2, 4), nullptr, "GetStepHistoryAll"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

32
src/core/hle/service/pxi/dev.cpp
View File

@@ -12,21 +12,23 @@ namespace Service::PXI {
DEV::DEV() : ServiceFramework("pxi:dev", 1) { DEV::DEV() : ServiceFramework("pxi:dev", 1) {
// clang-format off // clang-format off
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x000101C2, nullptr, "ReadHostIO"}, // clang-format off
{0x000201C2, nullptr, "WriteHostIO"}, {IPC::MakeHeader(0x0001, 7, 2), nullptr, "ReadHostIO"},
{0x00030102, nullptr, "ReadHostEx"}, {IPC::MakeHeader(0x0002, 7, 2), nullptr, "WriteHostIO"},
{0x00040102, nullptr, "WriteHostEx"}, {IPC::MakeHeader(0x0003, 4, 2), nullptr, "ReadHostEx"},
{0x00050102, nullptr, "WriteHostExStart"}, {IPC::MakeHeader(0x0004, 4, 2), nullptr, "WriteHostEx"},
{0x00060102, nullptr, "WriteHostExChunk"}, {IPC::MakeHeader(0x0005, 4, 2), nullptr, "WriteHostExStart"},
{0x00070000, nullptr, "WriteHostExEnd"}, {IPC::MakeHeader(0x0006, 4, 2), nullptr, "WriteHostExChunk"},
{0x00080000, nullptr, "InitializeMIDI"}, {IPC::MakeHeader(0x0007, 0, 0), nullptr, "WriteHostExEnd"},
{0x00090000, nullptr, "FinalizeMIDI"}, {IPC::MakeHeader(0x0008, 0, 0), nullptr, "InitializeMIDI"},
{0x000A0000, nullptr, "GetMIDIInfo"}, {IPC::MakeHeader(0x0009, 0, 0), nullptr, "FinalizeMIDI"},
{0x000B0000, nullptr, "GetMIDIBufferSize"}, {IPC::MakeHeader(0x000A, 0, 0), nullptr, "GetMIDIInfo"},
{0x000C0042, nullptr, "ReadMIDI"}, {IPC::MakeHeader(0x000B, 0, 0), nullptr, "GetMIDIBufferSize"},
{0x000D0688, nullptr, "SPIMultiWriteRead"}, {IPC::MakeHeader(0x000C, 1, 2), nullptr, "ReadMIDI"},
{0x000E0284, nullptr, "SPIWriteRead"}, {IPC::MakeHeader(0x000D, 26, 8), nullptr, "SPIMultiWriteRead"},
{0x000F0000, nullptr, "GetCardDevice"}, {IPC::MakeHeader(0x000E, 10, 4), nullptr, "SPIWriteRead"},
{IPC::MakeHeader(0x000F, 0, 0), nullptr, "GetCardDevice"},
// clang-format on
}; };
// clang-format on // clang-format on
RegisterHandlers(functions); RegisterHandlers(functions);

6
src/core/hle/service/qtm/qtm_c.cpp
View File

@@ -12,10 +12,10 @@ namespace Service::QTM {
QTM_C::QTM_C() : ServiceFramework("qtm:c", 2) { QTM_C::QTM_C() : ServiceFramework("qtm:c", 2) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
// clang-format off
// qtm calibration commands // qtm calibration commands
{0x00010000, nullptr, "InitializeHardwareCheck"}, // clang-format off
{0x00050040, nullptr, "SetIrLedCheck"}, {IPC::MakeHeader(0x0001, 0, 0), nullptr, "InitializeHardwareCheck"},
{IPC::MakeHeader(0x0005, 1, 0), nullptr, "SetIrLedCheck"},
// clang-format on // clang-format on
}; };

6
src/core/hle/service/qtm/qtm_s.cpp
View File

@@ -12,10 +12,10 @@ namespace Service::QTM {
QTM_S::QTM_S() : ServiceFramework("qtm:s", 2) { QTM_S::QTM_S() : ServiceFramework("qtm:s", 2) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
// clang-format off
// qtm common commands // qtm common commands
{0x00010080, nullptr, "GetHeadtrackingInfoRaw"}, // clang-format off
{0x00020080, nullptr, "GetHeadtrackingInfo"}, {IPC::MakeHeader(0x0001, 2, 0), nullptr, "GetHeadtrackingInfoRaw"},
{IPC::MakeHeader(0x0002, 2, 0), nullptr, "GetHeadtrackingInfo"},
// clang-format on // clang-format on
}; };

6
src/core/hle/service/qtm/qtm_sp.cpp
View File

@@ -12,10 +12,10 @@ namespace Service::QTM {
QTM_SP::QTM_SP() : ServiceFramework("qtm:sp", 2) { QTM_SP::QTM_SP() : ServiceFramework("qtm:sp", 2) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
// clang-format off
// qtm common commands // qtm common commands
{0x00010080, nullptr, "GetHeadtrackingInfoRaw"}, // clang-format off
{0x00020080, nullptr, "GetHeadtrackingInfo"}, {IPC::MakeHeader(0x0001, 2, 0), nullptr, "GetHeadtrackingInfoRaw"},
{IPC::MakeHeader(0x0002, 2, 0), nullptr, "GetHeadtrackingInfo"},
// clang-format on // clang-format on
}; };

6
src/core/hle/service/qtm/qtm_u.cpp
View File

@@ -12,10 +12,10 @@ namespace Service::QTM {
QTM_U::QTM_U() : ServiceFramework("qtm:u", 2) { QTM_U::QTM_U() : ServiceFramework("qtm:u", 2) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
// clang-format off
// qtm common commands // qtm common commands
{0x00010080, nullptr, "GetHeadtrackingInfoRaw"}, // clang-format off
{0x00020080, nullptr, "GetHeadtrackingInfo"}, {IPC::MakeHeader(0x0001, 2, 0), nullptr, "GetHeadtrackingInfoRaw"},
{IPC::MakeHeader(0x0002, 2, 0), nullptr, "GetHeadtrackingInfo"},
// clang-format on // clang-format on
}; };

6
src/core/hle/service/service.cpp
View File

@@ -152,8 +152,10 @@ void ServiceFrameworkBase::ReportUnimplementedFunction(u32* cmd_buf, const Funct
int num_params = header.normal_params_size + header.translate_params_size; int num_params = header.normal_params_size + header.translate_params_size;
std::string function_name = info == nullptr ? fmt::format("{:#08x}", cmd_buf[0]) : info->name; std::string function_name = info == nullptr ? fmt::format("{:#08x}", cmd_buf[0]) : info->name;
std::string result = fmt::format("function '{}': port='{}' cmd_buf={{[0]={:#x}", function_name, std::string result =
service_name, cmd_buf[0]); fmt::format("function '{}': port='{}' cmd_buf={{[0]={:#x} (0x{:04X}, {}, {})",
function_name, service_name, header.raw, header.command_id,
header.normal_params_size, header.translate_params_size);
for (int i = 1; i <= num_params; ++i) { for (int i = 1; i <= num_params; ++i) {
result += fmt::format(", [{}]={:#x}", i, cmd_buf[i]); result += fmt::format(", [{}]={:#x}", i, cmd_buf[i]);
} }

30
src/core/hle/service/sm/srv.cpp
View File

@@ -288,20 +288,22 @@ void SRV::RegisterService(Kernel::HLERequestContext& ctx) {
SRV::SRV(Core::System& system) : ServiceFramework("srv:", 4), system(system) { SRV::SRV(Core::System& system) : ServiceFramework("srv:", 4), system(system) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x00010002, &SRV::RegisterClient, "RegisterClient"}, // clang-format off
{0x00020000, &SRV::EnableNotification, "EnableNotification"}, {IPC::MakeHeader(0x0001, 0, 2), &SRV::RegisterClient, "RegisterClient"},
{0x00030100, &SRV::RegisterService, "RegisterService"}, {IPC::MakeHeader(0x0002, 0, 0), &SRV::EnableNotification, "EnableNotification"},
{0x000400C0, nullptr, "UnregisterService"}, {IPC::MakeHeader(0x0003, 4, 0), &SRV::RegisterService, "RegisterService"},
{0x00050100, &SRV::GetServiceHandle, "GetServiceHandle"}, {IPC::MakeHeader(0x0004, 3, 0), nullptr, "UnregisterService"},
{0x000600C2, nullptr, "RegisterPort"}, {IPC::MakeHeader(0x0005, 4, 0), &SRV::GetServiceHandle, "GetServiceHandle"},
{0x000700C0, nullptr, "UnregisterPort"}, {IPC::MakeHeader(0x0006, 3, 2), nullptr, "RegisterPort"},
{0x00080100, nullptr, "GetPort"}, {IPC::MakeHeader(0x0007, 3, 0), nullptr, "UnregisterPort"},
{0x00090040, &SRV::Subscribe, "Subscribe"}, {IPC::MakeHeader(0x0008, 4, 0), nullptr, "GetPort"},
{0x000A0040, &SRV::Unsubscribe, "Unsubscribe"}, {IPC::MakeHeader(0x0009, 1, 0), &SRV::Subscribe, "Subscribe"},
{0x000B0000, nullptr, "ReceiveNotification"}, {IPC::MakeHeader(0x000A, 1, 0), &SRV::Unsubscribe, "Unsubscribe"},
{0x000C0080, &SRV::PublishToSubscriber, "PublishToSubscriber"}, {IPC::MakeHeader(0x000B, 0, 0), nullptr, "ReceiveNotification"},
{0x000D0040, nullptr, "PublishAndGetSubscriber"}, {IPC::MakeHeader(0x000C, 2, 0), &SRV::PublishToSubscriber, "PublishToSubscriber"},
{0x000E00C0, nullptr, "IsServiceRegistered"}, {IPC::MakeHeader(0x000D, 1, 0), nullptr, "PublishAndGetSubscriber"},
{IPC::MakeHeader(0x000E, 3, 0), nullptr, "IsServiceRegistered"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }

48
src/core/hle/service/ssl_c.cpp
View File

@@ -61,29 +61,31 @@ void SSL_C::GenerateRandomData(Kernel::HLERequestContext& ctx) {
SSL_C::SSL_C() : ServiceFramework("ssl:C") { SSL_C::SSL_C() : ServiceFramework("ssl:C") {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x00010002, &SSL_C::Initialize, "Initialize"}, // clang-format off
{0x000200C2, nullptr, "CreateContext"}, {IPC::MakeHeader(0x0001, 0, 2), &SSL_C::Initialize, "Initialize"},
{0x00030000, nullptr, "CreateRootCertChain"}, {IPC::MakeHeader(0x0002, 3, 2), nullptr, "CreateContext"},
{0x00040040, nullptr, "DestroyRootCertChain"}, {IPC::MakeHeader(0x0003, 0, 0), nullptr, "CreateRootCertChain"},
{0x00050082, nullptr, "AddTrustedRootCA"}, {IPC::MakeHeader(0x0004, 1, 0), nullptr, "DestroyRootCertChain"},
{0x00060080, nullptr, "RootCertChainAddDefaultCert"}, {IPC::MakeHeader(0x0005, 2, 2), nullptr, "AddTrustedRootCA"},
{0x00070080, nullptr, "RootCertChainRemoveCert"}, {IPC::MakeHeader(0x0006, 2, 0), nullptr, "RootCertChainAddDefaultCert"},
{0x000D0084, nullptr, "OpenClientCertContext"}, {IPC::MakeHeader(0x0007, 2, 0), nullptr, "RootCertChainRemoveCert"},
{0x000E0040, nullptr, "OpenDefaultClientCertContext"}, {IPC::MakeHeader(0x000D, 2, 4), nullptr, "OpenClientCertContext"},
{0x000F0040, nullptr, "CloseClientCertContext"}, {IPC::MakeHeader(0x000E, 1, 0), nullptr, "OpenDefaultClientCertContext"},
{0x00110042, &SSL_C::GenerateRandomData, "GenerateRandomData"}, {IPC::MakeHeader(0x000F, 1, 0), nullptr, "CloseClientCertContext"},
{0x00120042, nullptr, "InitializeConnectionSession"}, {IPC::MakeHeader(0x0011, 1, 2), &SSL_C::GenerateRandomData, "GenerateRandomData"},
{0x00130040, nullptr, "StartConnection"}, {IPC::MakeHeader(0x0012, 1, 2), nullptr, "InitializeConnectionSession"},
{0x00140040, nullptr, "StartConnectionGetOut"}, {IPC::MakeHeader(0x0013, 1, 0), nullptr, "StartConnection"},
{0x00150082, nullptr, "Read"}, {IPC::MakeHeader(0x0014, 1, 0), nullptr, "StartConnectionGetOut"},
{0x00160082, nullptr, "ReadPeek"}, {IPC::MakeHeader(0x0015, 2, 2), nullptr, "Read"},
{0x00170082, nullptr, "Write"}, {IPC::MakeHeader(0x0016, 2, 2), nullptr, "ReadPeek"},
{0x00180080, nullptr, "ContextSetRootCertChain"}, {IPC::MakeHeader(0x0017, 2, 2), nullptr, "Write"},
{0x00190080, nullptr, "ContextSetClientCert"}, {IPC::MakeHeader(0x0018, 2, 0), nullptr, "ContextSetRootCertChain"},
{0x001B0080, nullptr, "ContextClearOpt"}, {IPC::MakeHeader(0x0019, 2, 0), nullptr, "ContextSetClientCert"},
{0x001C00C4, nullptr, "ContextGetProtocolCipher"}, {IPC::MakeHeader(0x001B, 2, 0), nullptr, "ContextClearOpt"},
{0x001E0040, nullptr, "DestroyContext"}, {IPC::MakeHeader(0x001C, 3, 4), nullptr, "ContextGetProtocolCipher"},
{0x001F0082, nullptr, "ContextInitSharedmem"}, {IPC::MakeHeader(0x001E, 1, 0), nullptr, "DestroyContext"},
{IPC::MakeHeader(0x001F, 2, 2), nullptr, "ContextInitSharedmem"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);

92
src/core/hle/service/y2r_u.cpp
View File

@@ -647,51 +647,53 @@ void Y2R_U::GetPackageParameter(Kernel::HLERequestContext& ctx) {
Y2R_U::Y2R_U(Core::System& system) : ServiceFramework("y2r:u", 1), system(system) { Y2R_U::Y2R_U(Core::System& system) : ServiceFramework("y2r:u", 1), system(system) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0x00010040, &Y2R_U::SetInputFormat, "SetInputFormat"}, // clang-format off
{0x00020000, &Y2R_U::GetInputFormat, "GetInputFormat"}, {IPC::MakeHeader(0x0001, 1, 0), &Y2R_U::SetInputFormat, "SetInputFormat"},
{0x00030040, &Y2R_U::SetOutputFormat, "SetOutputFormat"}, {IPC::MakeHeader(0x0002, 0, 0), &Y2R_U::GetInputFormat, "GetInputFormat"},
{0x00040000, &Y2R_U::GetOutputFormat, "GetOutputFormat"}, {IPC::MakeHeader(0x0003, 1, 0), &Y2R_U::SetOutputFormat, "SetOutputFormat"},
{0x00050040, &Y2R_U::SetRotation, "SetRotation"}, {IPC::MakeHeader(0x0004, 0, 0), &Y2R_U::GetOutputFormat, "GetOutputFormat"},
{0x00060000, &Y2R_U::GetRotation, "GetRotation"}, {IPC::MakeHeader(0x0005, 1, 0), &Y2R_U::SetRotation, "SetRotation"},
{0x00070040, &Y2R_U::SetBlockAlignment, "SetBlockAlignment"}, {IPC::MakeHeader(0x0006, 0, 0), &Y2R_U::GetRotation, "GetRotation"},
{0x00080000, &Y2R_U::GetBlockAlignment, "GetBlockAlignment"}, {IPC::MakeHeader(0x0007, 1, 0), &Y2R_U::SetBlockAlignment, "SetBlockAlignment"},
{0x00090040, &Y2R_U::SetSpacialDithering, "SetSpacialDithering"}, {IPC::MakeHeader(0x0008, 0, 0), &Y2R_U::GetBlockAlignment, "GetBlockAlignment"},
{0x000A0000, &Y2R_U::GetSpacialDithering, "GetSpacialDithering"}, {IPC::MakeHeader(0x0009, 1, 0), &Y2R_U::SetSpacialDithering, "SetSpacialDithering"},
{0x000B0040, &Y2R_U::SetTemporalDithering, "SetTemporalDithering"}, {IPC::MakeHeader(0x000A, 0, 0), &Y2R_U::GetSpacialDithering, "GetSpacialDithering"},
{0x000C0000, &Y2R_U::GetTemporalDithering, "GetTemporalDithering"}, {IPC::MakeHeader(0x000B, 1, 0), &Y2R_U::SetTemporalDithering, "SetTemporalDithering"},
{0x000D0040, &Y2R_U::SetTransferEndInterrupt, "SetTransferEndInterrupt"}, {IPC::MakeHeader(0x000C, 0, 0), &Y2R_U::GetTemporalDithering, "GetTemporalDithering"},
{0x000E0000, &Y2R_U::GetTransferEndInterrupt, "GetTransferEndInterrupt"}, {IPC::MakeHeader(0x000D, 1, 0), &Y2R_U::SetTransferEndInterrupt, "SetTransferEndInterrupt"},
{0x000F0000, &Y2R_U::GetTransferEndEvent, "GetTransferEndEvent"}, {IPC::MakeHeader(0x000E, 0, 0), &Y2R_U::GetTransferEndInterrupt, "GetTransferEndInterrupt"},
{0x00100102, &Y2R_U::SetSendingY, "SetSendingY"}, {IPC::MakeHeader(0x000F, 0, 0), &Y2R_U::GetTransferEndEvent, "GetTransferEndEvent"},
{0x00110102, &Y2R_U::SetSendingU, "SetSendingU"}, {IPC::MakeHeader(0x0010, 4, 2), &Y2R_U::SetSendingY, "SetSendingY"},
{0x00120102, &Y2R_U::SetSendingV, "SetSendingV"}, {IPC::MakeHeader(0x0011, 4, 2), &Y2R_U::SetSendingU, "SetSendingU"},
{0x00130102, &Y2R_U::SetSendingYUYV, "SetSendingYUYV"}, {IPC::MakeHeader(0x0012, 4, 2), &Y2R_U::SetSendingV, "SetSendingV"},
{0x00140000, &Y2R_U::IsFinishedSendingYuv, "IsFinishedSendingYuv"}, {IPC::MakeHeader(0x0013, 4, 2), &Y2R_U::SetSendingYUYV, "SetSendingYUYV"},
{0x00150000, &Y2R_U::IsFinishedSendingY, "IsFinishedSendingY"}, {IPC::MakeHeader(0x0014, 0, 0), &Y2R_U::IsFinishedSendingYuv, "IsFinishedSendingYuv"},
{0x00160000, &Y2R_U::IsFinishedSendingU, "IsFinishedSendingU"}, {IPC::MakeHeader(0x0015, 0, 0), &Y2R_U::IsFinishedSendingY, "IsFinishedSendingY"},
{0x00170000, &Y2R_U::IsFinishedSendingV, "IsFinishedSendingV"}, {IPC::MakeHeader(0x0016, 0, 0), &Y2R_U::IsFinishedSendingU, "IsFinishedSendingU"},
{0x00180102, &Y2R_U::SetReceiving, "SetReceiving"}, {IPC::MakeHeader(0x0017, 0, 0), &Y2R_U::IsFinishedSendingV, "IsFinishedSendingV"},
{0x00190000, &Y2R_U::IsFinishedReceiving, "IsFinishedReceiving"}, {IPC::MakeHeader(0x0018, 4, 2), &Y2R_U::SetReceiving, "SetReceiving"},
{0x001A0040, &Y2R_U::SetInputLineWidth, "SetInputLineWidth"}, {IPC::MakeHeader(0x0019, 0, 0), &Y2R_U::IsFinishedReceiving, "IsFinishedReceiving"},
{0x001B0000, &Y2R_U::GetInputLineWidth, "GetInputLineWidth"}, {IPC::MakeHeader(0x001A, 1, 0), &Y2R_U::SetInputLineWidth, "SetInputLineWidth"},
{0x001C0040, &Y2R_U::SetInputLines, "SetInputLines"}, {IPC::MakeHeader(0x001B, 0, 0), &Y2R_U::GetInputLineWidth, "GetInputLineWidth"},
{0x001D0000, &Y2R_U::GetInputLines, "GetInputLines"}, {IPC::MakeHeader(0x001C, 1, 0), &Y2R_U::SetInputLines, "SetInputLines"},
{0x001E0100, &Y2R_U::SetCoefficient, "SetCoefficient"}, {IPC::MakeHeader(0x001D, 0, 0), &Y2R_U::GetInputLines, "GetInputLines"},
{0x001F0000, &Y2R_U::GetCoefficient, "GetCoefficient"}, {IPC::MakeHeader(0x001E, 4, 0), &Y2R_U::SetCoefficient, "SetCoefficient"},
{0x00200040, &Y2R_U::SetStandardCoefficient, "SetStandardCoefficient"}, {IPC::MakeHeader(0x001F, 0, 0), &Y2R_U::GetCoefficient, "GetCoefficient"},
{0x00210040, &Y2R_U::GetStandardCoefficient, "GetStandardCoefficient"}, {IPC::MakeHeader(0x0020, 1, 0), &Y2R_U::SetStandardCoefficient, "SetStandardCoefficient"},
{0x00220040, &Y2R_U::SetAlpha, "SetAlpha"}, {IPC::MakeHeader(0x0021, 1, 0), &Y2R_U::GetStandardCoefficient, "GetStandardCoefficient"},
{0x00230000, &Y2R_U::GetAlpha, "GetAlpha"}, {IPC::MakeHeader(0x0022, 1, 0), &Y2R_U::SetAlpha, "SetAlpha"},
{0x00240200, &Y2R_U::SetDitheringWeightParams, "SetDitheringWeightParams"}, {IPC::MakeHeader(0x0023, 0, 0), &Y2R_U::GetAlpha, "GetAlpha"},
{0x00250000, &Y2R_U::GetDitheringWeightParams, "GetDitheringWeightParams"}, {IPC::MakeHeader(0x0024, 8, 0), &Y2R_U::SetDitheringWeightParams, "SetDitheringWeightParams"},
{0x00260000, &Y2R_U::StartConversion, "StartConversion"}, {IPC::MakeHeader(0x0025, 0, 0), &Y2R_U::GetDitheringWeightParams, "GetDitheringWeightParams"},
{0x00270000, &Y2R_U::StopConversion, "StopConversion"}, {IPC::MakeHeader(0x0026, 0, 0), &Y2R_U::StartConversion, "StartConversion"},
{0x00280000, &Y2R_U::IsBusyConversion, "IsBusyConversion"}, {IPC::MakeHeader(0x0027, 0, 0), &Y2R_U::StopConversion, "StopConversion"},
{0x002901C0, &Y2R_U::SetPackageParameter, "SetPackageParameter"}, {IPC::MakeHeader(0x0028, 0, 0), &Y2R_U::IsBusyConversion, "IsBusyConversion"},
{0x002A0000, &Y2R_U::PingProcess, "PingProcess"}, {IPC::MakeHeader(0x0029, 7, 0), &Y2R_U::SetPackageParameter, "SetPackageParameter"},
{0x002B0000, &Y2R_U::DriverInitialize, "DriverInitialize"}, {IPC::MakeHeader(0x002A, 0, 0), &Y2R_U::PingProcess, "PingProcess"},
{0x002C0000, &Y2R_U::DriverFinalize, "DriverFinalize"}, {IPC::MakeHeader(0x002B, 0, 0), &Y2R_U::DriverInitialize, "DriverInitialize"},
{0x002D0000, &Y2R_U::GetPackageParameter, "GetPackageParameter"}, {IPC::MakeHeader(0x002C, 0, 0), &Y2R_U::DriverFinalize, "DriverFinalize"},
{IPC::MakeHeader(0x002D, 0, 0), &Y2R_U::GetPackageParameter, "GetPackageParameter"},
// clang-format on
}; };
RegisterHandlers(functions); RegisterHandlers(functions);