early-access version 1255

src/core/hle/service/set/set.cpp

@@ -0,0 +1,214 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <algorithm>
+#include <array>
+#include <chrono>
+#include "common/logging/log.h"
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/service/set/set.h"
+#include "core/settings.h"
+
+namespace Service::Set {
+namespace {
+constexpr std::array<LanguageCode, 17> available_language_codes = {{
+    LanguageCode::JA,
+    LanguageCode::EN_US,
+    LanguageCode::FR,
+    LanguageCode::DE,
+    LanguageCode::IT,
+    LanguageCode::ES,
+    LanguageCode::ZH_CN,
+    LanguageCode::KO,
+    LanguageCode::NL,
+    LanguageCode::PT,
+    LanguageCode::RU,
+    LanguageCode::ZH_TW,
+    LanguageCode::EN_GB,
+    LanguageCode::FR_CA,
+    LanguageCode::ES_419,
+    LanguageCode::ZH_HANS,
+    LanguageCode::ZH_HANT,
+}};
+
+enum class KeyboardLayout : u64 {
+    Japanese = 0,
+    EnglishUs = 1,
+    EnglishUsInternational = 2,
+    EnglishUk = 3,
+    French = 4,
+    FrenchCa = 5,
+    Spanish = 6,
+    SpanishLatin = 7,
+    German = 8,
+    Italian = 9,
+    Portuguese = 10,
+    Russian = 11,
+    Korean = 12,
+    ChineseSimplified = 13,
+    ChineseTraditional = 14,
+};
+
+constexpr std::array<std::pair<LanguageCode, KeyboardLayout>, 17> language_to_layout{{
+    {LanguageCode::JA, KeyboardLayout::Japanese},
+    {LanguageCode::EN_US, KeyboardLayout::EnglishUs},
+    {LanguageCode::FR, KeyboardLayout::French},
+    {LanguageCode::DE, KeyboardLayout::German},
+    {LanguageCode::IT, KeyboardLayout::Italian},
+    {LanguageCode::ES, KeyboardLayout::Spanish},
+    {LanguageCode::ZH_CN, KeyboardLayout::ChineseSimplified},
+    {LanguageCode::KO, KeyboardLayout::Korean},
+    {LanguageCode::NL, KeyboardLayout::EnglishUsInternational},
+    {LanguageCode::PT, KeyboardLayout::Portuguese},
+    {LanguageCode::RU, KeyboardLayout::Russian},
+    {LanguageCode::ZH_TW, KeyboardLayout::ChineseTraditional},
+    {LanguageCode::EN_GB, KeyboardLayout::EnglishUk},
+    {LanguageCode::FR_CA, KeyboardLayout::FrenchCa},
+    {LanguageCode::ES_419, KeyboardLayout::SpanishLatin},
+    {LanguageCode::ZH_HANS, KeyboardLayout::ChineseSimplified},
+    {LanguageCode::ZH_HANT, KeyboardLayout::ChineseTraditional},
+}};
+
+constexpr std::size_t pre4_0_0_max_entries = 15;
+constexpr std::size_t post4_0_0_max_entries = 17;
+
+constexpr ResultCode ERR_INVALID_LANGUAGE{ErrorModule::Settings, 625};
+
+void PushResponseLanguageCode(Kernel::HLERequestContext& ctx, std::size_t num_language_codes) {
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(RESULT_SUCCESS);
+    rb.Push(static_cast<u32>(num_language_codes));
+}
+
+void GetAvailableLanguageCodesImpl(Kernel::HLERequestContext& ctx, std::size_t max_size) {
+    const std::size_t requested_amount = ctx.GetWriteBufferSize() / sizeof(LanguageCode);
+    const std::size_t copy_amount = std::min(requested_amount, max_size);
+    const std::size_t copy_size = copy_amount * sizeof(LanguageCode);
+
+    ctx.WriteBuffer(available_language_codes.data(), copy_size);
+    PushResponseLanguageCode(ctx, copy_amount);
+}
+
+void GetKeyCodeMapImpl(Kernel::HLERequestContext& ctx) {
+    const auto language_code = available_language_codes[Settings::values.language_index.GetValue()];
+    const auto key_code =
+        std::find_if(language_to_layout.cbegin(), language_to_layout.cend(),
+                     [=](const auto& element) { return element.first == language_code; });
+    KeyboardLayout layout = KeyboardLayout::EnglishUs;
+    if (key_code == language_to_layout.cend()) {
+        LOG_ERROR(Service_SET,
+                  "Could not find keyboard layout for language index {}, defaulting to English us",
+                  Settings::values.language_index.GetValue());
+    } else {
+        layout = key_code->second;
+    }
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+    ctx.WriteBuffer(layout);
+}
+} // Anonymous namespace
+
+LanguageCode GetLanguageCodeFromIndex(std::size_t index) {
+    return available_language_codes.at(index);
+}
+
+void SET::GetAvailableLanguageCodes(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_SET, "called");
+
+    GetAvailableLanguageCodesImpl(ctx, pre4_0_0_max_entries);
+}
+
+void SET::MakeLanguageCode(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto index = rp.Pop<u32>();
+
+    if (index >= available_language_codes.size()) {
+        LOG_ERROR(Service_SET, "Invalid language code index! index={}", index);
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ERR_INVALID_LANGUAGE);
+        return;
+    }
+
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushEnum(available_language_codes[index]);
+}
+
+void SET::GetAvailableLanguageCodes2(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_SET, "called");
+
+    GetAvailableLanguageCodesImpl(ctx, post4_0_0_max_entries);
+}
+
+void SET::GetAvailableLanguageCodeCount(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_SET, "called");
+
+    PushResponseLanguageCode(ctx, pre4_0_0_max_entries);
+}
+
+void SET::GetAvailableLanguageCodeCount2(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_SET, "called");
+
+    PushResponseLanguageCode(ctx, post4_0_0_max_entries);
+}
+
+void SET::GetQuestFlag(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_SET, "called");
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(RESULT_SUCCESS);
+    rb.Push(static_cast<u32>(Settings::values.quest_flag));
+}
+
+void SET::GetLanguageCode(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_SET, "called {}", Settings::values.language_index.GetValue());
+
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushEnum(available_language_codes[Settings::values.language_index.GetValue()]);
+}
+
+void SET::GetRegionCode(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_SET, "called");
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(RESULT_SUCCESS);
+    rb.Push(Settings::values.region_index.GetValue());
+}
+
+void SET::GetKeyCodeMap(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_SET, "Called {}", ctx.Description());
+    GetKeyCodeMapImpl(ctx);
+}
+
+void SET::GetKeyCodeMap2(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_SET, "Called {}", ctx.Description());
+    GetKeyCodeMapImpl(ctx);
+}
+
+SET::SET(Core::System& system_) : ServiceFramework{system_, "set"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, &SET::GetLanguageCode, "GetLanguageCode"},
+        {1, &SET::GetAvailableLanguageCodes, "GetAvailableLanguageCodes"},
+        {2, &SET::MakeLanguageCode, "MakeLanguageCode"},
+        {3, &SET::GetAvailableLanguageCodeCount, "GetAvailableLanguageCodeCount"},
+        {4, &SET::GetRegionCode, "GetRegionCode"},
+        {5, &SET::GetAvailableLanguageCodes2, "GetAvailableLanguageCodes2"},
+        {6, &SET::GetAvailableLanguageCodeCount2, "GetAvailableLanguageCodeCount2"},
+        {7, &SET::GetKeyCodeMap, "GetKeyCodeMap"},
+        {8, &SET::GetQuestFlag, "GetQuestFlag"},
+        {9, &SET::GetKeyCodeMap2, "GetKeyCodeMap2"},
+        {10, nullptr, "GetFirmwareVersionForDebug"},
+        {11, nullptr, "GetDeviceNickName"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+SET::~SET() = default;
+
+} // namespace Service::Set

src/core/hle/service/set/set.h

@@ -0,0 +1,55 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/hle/service/service.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::Set {
+
+/// This is "nn::settings::LanguageCode", which is a NUL-terminated string stored in a u64.
+enum class LanguageCode : u64 {
+    JA = 0x000000000000616A,
+    EN_US = 0x00000053552D6E65,
+    FR = 0x0000000000007266,
+    DE = 0x0000000000006564,
+    IT = 0x0000000000007469,
+    ES = 0x0000000000007365,
+    ZH_CN = 0x0000004E432D687A,
+    KO = 0x0000000000006F6B,
+    NL = 0x0000000000006C6E,
+    PT = 0x0000000000007470,
+    RU = 0x0000000000007572,
+    ZH_TW = 0x00000057542D687A,
+    EN_GB = 0x00000042472D6E65,
+    FR_CA = 0x00000041432D7266,
+    ES_419 = 0x00003931342D7365,
+    ZH_HANS = 0x00736E61482D687A,
+    ZH_HANT = 0x00746E61482D687A,
+};
+LanguageCode GetLanguageCodeFromIndex(std::size_t idx);
+
+class SET final : public ServiceFramework<SET> {
+public:
+    explicit SET(Core::System& system_);
+    ~SET() override;
+
+private:
+    void GetLanguageCode(Kernel::HLERequestContext& ctx);
+    void GetAvailableLanguageCodes(Kernel::HLERequestContext& ctx);
+    void MakeLanguageCode(Kernel::HLERequestContext& ctx);
+    void GetAvailableLanguageCodes2(Kernel::HLERequestContext& ctx);
+    void GetAvailableLanguageCodeCount(Kernel::HLERequestContext& ctx);
+    void GetAvailableLanguageCodeCount2(Kernel::HLERequestContext& ctx);
+    void GetQuestFlag(Kernel::HLERequestContext& ctx);
+    void GetRegionCode(Kernel::HLERequestContext& ctx);
+    void GetKeyCodeMap(Kernel::HLERequestContext& ctx);
+    void GetKeyCodeMap2(Kernel::HLERequestContext& ctx);
+};
+
+} // namespace Service::Set

src/core/hle/service/set/set_cal.cpp

@@ -0,0 +1,63 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/service/set/set_cal.h"
+
+namespace Service::Set {
+
+SET_CAL::SET_CAL(Core::System& system_) : ServiceFramework{system_, "set:cal"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "GetBluetoothBdAddress"},
+        {1, nullptr, "GetConfigurationId1"},
+        {2, nullptr, "GetAccelerometerOffset"},
+        {3, nullptr, "GetAccelerometerScale"},
+        {4, nullptr, "GetGyroscopeOffset"},
+        {5, nullptr, "GetGyroscopeScale"},
+        {6, nullptr, "GetWirelessLanMacAddress"},
+        {7, nullptr, "GetWirelessLanCountryCodeCount"},
+        {8, nullptr, "GetWirelessLanCountryCodes"},
+        {9, nullptr, "GetSerialNumber"},
+        {10, nullptr, "SetInitialSystemAppletProgramId"},
+        {11, nullptr, "SetOverlayDispProgramId"},
+        {12, nullptr, "GetBatteryLot"},
+        {14, nullptr, "GetEciDeviceCertificate"},
+        {15, nullptr, "GetEticketDeviceCertificate"},
+        {16, nullptr, "GetSslKey"},
+        {17, nullptr, "GetSslCertificate"},
+        {18, nullptr, "GetGameCardKey"},
+        {19, nullptr, "GetGameCardCertificate"},
+        {20, nullptr, "GetEciDeviceKey"},
+        {21, nullptr, "GetEticketDeviceKey"},
+        {22, nullptr, "GetSpeakerParameter"},
+        {23, nullptr, "GetLcdVendorId"},
+        {24, nullptr, "GetEciDeviceCertificate2"},
+        {25, nullptr, "GetEciDeviceKey2"},
+        {26, nullptr, "GetAmiiboKey"},
+        {27, nullptr, "GetAmiiboEcqvCertificate"},
+        {28, nullptr, "GetAmiiboEcdsaCertificate"},
+        {29, nullptr, "GetAmiiboEcqvBlsKey"},
+        {30, nullptr, "GetAmiiboEcqvBlsCertificate"},
+        {31, nullptr, "GetAmiiboEcqvBlsRootCertificate"},
+        {32, nullptr, "GetUsbTypeCPowerSourceCircuitVersion"},
+        {33, nullptr, "GetAnalogStickModuleTypeL"},
+        {34, nullptr, "GetAnalogStickModelParameterL"},
+        {35, nullptr, "GetAnalogStickFactoryCalibrationL"},
+        {36, nullptr, "GetAnalogStickModuleTypeR"},
+        {37, nullptr, "GetAnalogStickModelParameterR"},
+        {38, nullptr, "GetAnalogStickFactoryCalibrationR"},
+        {39, nullptr, "GetConsoleSixAxisSensorModuleType"},
+        {40, nullptr, "GetConsoleSixAxisSensorHorizontalOffset"},
+        {41, nullptr, "GetBatteryVersion"},
+        {42, nullptr, "GetDeviceId"},
+        {43, nullptr, "GetConsoleSixAxisSensorMountType"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+SET_CAL::~SET_CAL() = default;
+
+} // namespace Service::Set

src/core/hle/service/set/set_cal.h

@@ -0,0 +1,21 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/hle/service/service.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::Set {
+
+class SET_CAL final : public ServiceFramework<SET_CAL> {
+public:
+    explicit SET_CAL(Core::System& system_);
+    ~SET_CAL() override;
+};
+
+} // namespace Service::Set

src/core/hle/service/set/set_fd.cpp

@@ -0,0 +1,29 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/service/set/set_fd.h"
+
+namespace Service::Set {
+
+SET_FD::SET_FD(Core::System& system_) : ServiceFramework{system_, "set:fd"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {2, nullptr, "SetSettingsItemValue"},
+        {3, nullptr, "ResetSettingsItemValue"},
+        {4, nullptr, "CreateSettingsItemKeyIterator"},
+        {10, nullptr, "ReadSettings"},
+        {11, nullptr, "ResetSettings"},
+        {20, nullptr, "SetWebInspectorFlag"},
+        {21, nullptr, "SetAllowedSslHosts"},
+        {22, nullptr, "SetHostFsMountPoint"},
+        {23, nullptr, "SetMemoryUsageRateFlag"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+SET_FD::~SET_FD() = default;
+
+} // namespace Service::Set

src/core/hle/service/set/set_fd.h

@@ -0,0 +1,21 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/hle/service/service.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::Set {
+
+class SET_FD final : public ServiceFramework<SET_FD> {
+public:
+    explicit SET_FD(Core::System& system_);
+    ~SET_FD() override;
+};
+
+} // namespace Service::Set

src/core/hle/service/set/set_sys.cpp

@@ -0,0 +1,313 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/assert.h"
+#include "common/logging/log.h"
+#include "core/file_sys/errors.h"
+#include "core/file_sys/system_archive/system_version.h"
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/client_port.h"
+#include "core/hle/service/filesystem/filesystem.h"
+#include "core/hle/service/set/set_sys.h"
+
+namespace Service::Set {
+
+namespace {
+constexpr u64 SYSTEM_VERSION_FILE_MINOR_REVISION_OFFSET = 0x05;
+
+enum class GetFirmwareVersionType {
+    Version1,
+    Version2,
+};
+
+void GetFirmwareVersionImpl(Kernel::HLERequestContext& ctx, GetFirmwareVersionType type) {
+    LOG_WARNING(Service_SET, "called - Using hardcoded firmware version '{}'",
+                FileSys::SystemArchive::GetLongDisplayVersion());
+
+    ASSERT_MSG(ctx.GetWriteBufferSize() == 0x100,
+               "FirmwareVersion output buffer must be 0x100 bytes in size!");
+
+    // Instead of using the normal procedure of checking for the real system archive and if it
+    // doesn't exist, synthesizing one, I feel that that would lead to strange bugs because a
+    // used is using a really old or really new SystemVersion title. The synthesized one ensures
+    // consistence (currently reports as 5.1.0-0.0)
+    const auto archive = FileSys::SystemArchive::SystemVersion();
+
+    const auto early_exit_failure = [&ctx](std::string_view desc, ResultCode code) {
+        LOG_ERROR(Service_SET, "General failure while attempting to resolve firmware version ({}).",
+                  desc);
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(code);
+    };
+
+    if (archive == nullptr) {
+        early_exit_failure("The system version archive couldn't be synthesized.",
+                           FileSys::ERROR_FAILED_MOUNT_ARCHIVE);
+        return;
+    }
+
+    const auto ver_file = archive->GetFile("file");
+    if (ver_file == nullptr) {
+        early_exit_failure("The system version archive didn't contain the file 'file'.",
+                           FileSys::ERROR_INVALID_ARGUMENT);
+        return;
+    }
+
+    auto data = ver_file->ReadAllBytes();
+    if (data.size() != 0x100) {
+        early_exit_failure("The system version file 'file' was not the correct size.",
+                           FileSys::ERROR_OUT_OF_BOUNDS);
+        return;
+    }
+
+    // If the command is GetFirmwareVersion (as opposed to GetFirmwareVersion2), hardware will
+    // zero out the REVISION_MINOR field.
+    if (type == GetFirmwareVersionType::Version1) {
+        data[SYSTEM_VERSION_FILE_MINOR_REVISION_OFFSET] = 0;
+    }
+
+    ctx.WriteBuffer(data);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
+} // Anonymous namespace
+
+void SET_SYS::GetFirmwareVersion(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_SET, "called");
+    GetFirmwareVersionImpl(ctx, GetFirmwareVersionType::Version1);
+}
+
+void SET_SYS::GetFirmwareVersion2(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_SET, "called");
+    GetFirmwareVersionImpl(ctx, GetFirmwareVersionType::Version2);
+}
+
+void SET_SYS::GetColorSetId(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_SET, "called");
+
+    IPC::ResponseBuilder rb{ctx, 3};
+
+    rb.Push(RESULT_SUCCESS);
+    rb.PushEnum(color_set);
+}
+
+void SET_SYS::SetColorSetId(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_SET, "called");
+
+    IPC::RequestParser rp{ctx};
+    color_set = rp.PopEnum<ColorSet>();
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
+
+SET_SYS::SET_SYS(Core::System& system_) : ServiceFramework{system_, "set:sys"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "SetLanguageCode"},
+        {1, nullptr, "SetNetworkSettings"},
+        {2, nullptr, "GetNetworkSettings"},
+        {3, &SET_SYS::GetFirmwareVersion, "GetFirmwareVersion"},
+        {4, &SET_SYS::GetFirmwareVersion2, "GetFirmwareVersion2"},
+        {5, nullptr, "GetFirmwareVersionDigest"},
+        {7, nullptr, "GetLockScreenFlag"},
+        {8, nullptr, "SetLockScreenFlag"},
+        {9, nullptr, "GetBacklightSettings"},
+        {10, nullptr, "SetBacklightSettings"},
+        {11, nullptr, "SetBluetoothDevicesSettings"},
+        {12, nullptr, "GetBluetoothDevicesSettings"},
+        {13, nullptr, "GetExternalSteadyClockSourceId"},
+        {14, nullptr, "SetExternalSteadyClockSourceId"},
+        {15, nullptr, "GetUserSystemClockContext"},
+        {16, nullptr, "SetUserSystemClockContext"},
+        {17, nullptr, "GetAccountSettings"},
+        {18, nullptr, "SetAccountSettings"},
+        {19, nullptr, "GetAudioVolume"},
+        {20, nullptr, "SetAudioVolume"},
+        {21, nullptr, "GetEulaVersions"},
+        {22, nullptr, "SetEulaVersions"},
+        {23, &SET_SYS::GetColorSetId, "GetColorSetId"},
+        {24, &SET_SYS::SetColorSetId, "SetColorSetId"},
+        {25, nullptr, "GetConsoleInformationUploadFlag"},
+        {26, nullptr, "SetConsoleInformationUploadFlag"},
+        {27, nullptr, "GetAutomaticApplicationDownloadFlag"},
+        {28, nullptr, "SetAutomaticApplicationDownloadFlag"},
+        {29, nullptr, "GetNotificationSettings"},
+        {30, nullptr, "SetNotificationSettings"},
+        {31, nullptr, "GetAccountNotificationSettings"},
+        {32, nullptr, "SetAccountNotificationSettings"},
+        {35, nullptr, "GetVibrationMasterVolume"},
+        {36, nullptr, "SetVibrationMasterVolume"},
+        {37, nullptr, "GetSettingsItemValueSize"},
+        {38, nullptr, "GetSettingsItemValue"},
+        {39, nullptr, "GetTvSettings"},
+        {40, nullptr, "SetTvSettings"},
+        {41, nullptr, "GetEdid"},
+        {42, nullptr, "SetEdid"},
+        {43, nullptr, "GetAudioOutputMode"},
+        {44, nullptr, "SetAudioOutputMode"},
+        {45, nullptr, "IsForceMuteOnHeadphoneRemoved"},
+        {46, nullptr, "SetForceMuteOnHeadphoneRemoved"},
+        {47, nullptr, "GetQuestFlag"},
+        {48, nullptr, "SetQuestFlag"},
+        {49, nullptr, "GetDataDeletionSettings"},
+        {50, nullptr, "SetDataDeletionSettings"},
+        {51, nullptr, "GetInitialSystemAppletProgramId"},
+        {52, nullptr, "GetOverlayDispProgramId"},
+        {53, nullptr, "GetDeviceTimeZoneLocationName"},
+        {54, nullptr, "SetDeviceTimeZoneLocationName"},
+        {55, nullptr, "GetWirelessCertificationFileSize"},
+        {56, nullptr, "GetWirelessCertificationFile"},
+        {57, nullptr, "SetRegionCode"},
+        {58, nullptr, "GetNetworkSystemClockContext"},
+        {59, nullptr, "SetNetworkSystemClockContext"},
+        {60, nullptr, "IsUserSystemClockAutomaticCorrectionEnabled"},
+        {61, nullptr, "SetUserSystemClockAutomaticCorrectionEnabled"},
+        {62, nullptr, "GetDebugModeFlag"},
+        {63, nullptr, "GetPrimaryAlbumStorage"},
+        {64, nullptr, "SetPrimaryAlbumStorage"},
+        {65, nullptr, "GetUsb30EnableFlag"},
+        {66, nullptr, "SetUsb30EnableFlag"},
+        {67, nullptr, "GetBatteryLot"},
+        {68, nullptr, "GetSerialNumber"},
+        {69, nullptr, "GetNfcEnableFlag"},
+        {70, nullptr, "SetNfcEnableFlag"},
+        {71, nullptr, "GetSleepSettings"},
+        {72, nullptr, "SetSleepSettings"},
+        {73, nullptr, "GetWirelessLanEnableFlag"},
+        {74, nullptr, "SetWirelessLanEnableFlag"},
+        {75, nullptr, "GetInitialLaunchSettings"},
+        {76, nullptr, "SetInitialLaunchSettings"},
+        {77, nullptr, "GetDeviceNickName"},
+        {78, nullptr, "SetDeviceNickName"},
+        {79, nullptr, "GetProductModel"},
+        {80, nullptr, "GetLdnChannel"},
+        {81, nullptr, "SetLdnChannel"},
+        {82, nullptr, "AcquireTelemetryDirtyFlagEventHandle"},
+        {83, nullptr, "GetTelemetryDirtyFlags"},
+        {84, nullptr, "GetPtmBatteryLot"},
+        {85, nullptr, "SetPtmBatteryLot"},
+        {86, nullptr, "GetPtmFuelGaugeParameter"},
+        {87, nullptr, "SetPtmFuelGaugeParameter"},
+        {88, nullptr, "GetBluetoothEnableFlag"},
+        {89, nullptr, "SetBluetoothEnableFlag"},
+        {90, nullptr, "GetMiiAuthorId"},
+        {91, nullptr, "SetShutdownRtcValue"},
+        {92, nullptr, "GetShutdownRtcValue"},
+        {93, nullptr, "AcquireFatalDirtyFlagEventHandle"},
+        {94, nullptr, "GetFatalDirtyFlags"},
+        {95, nullptr, "GetAutoUpdateEnableFlag"},
+        {96, nullptr, "SetAutoUpdateEnableFlag"},
+        {97, nullptr, "GetNxControllerSettings"},
+        {98, nullptr, "SetNxControllerSettings"},
+        {99, nullptr, "GetBatteryPercentageFlag"},
+        {100, nullptr, "SetBatteryPercentageFlag"},
+        {101, nullptr, "GetExternalRtcResetFlag"},
+        {102, nullptr, "SetExternalRtcResetFlag"},
+        {103, nullptr, "GetUsbFullKeyEnableFlag"},
+        {104, nullptr, "SetUsbFullKeyEnableFlag"},
+        {105, nullptr, "SetExternalSteadyClockInternalOffset"},
+        {106, nullptr, "GetExternalSteadyClockInternalOffset"},
+        {107, nullptr, "GetBacklightSettingsEx"},
+        {108, nullptr, "SetBacklightSettingsEx"},
+        {109, nullptr, "GetHeadphoneVolumeWarningCount"},
+        {110, nullptr, "SetHeadphoneVolumeWarningCount"},
+        {111, nullptr, "GetBluetoothAfhEnableFlag"},
+        {112, nullptr, "SetBluetoothAfhEnableFlag"},
+        {113, nullptr, "GetBluetoothBoostEnableFlag"},
+        {114, nullptr, "SetBluetoothBoostEnableFlag"},
+        {115, nullptr, "GetInRepairProcessEnableFlag"},
+        {116, nullptr, "SetInRepairProcessEnableFlag"},
+        {117, nullptr, "GetHeadphoneVolumeUpdateFlag"},
+        {118, nullptr, "SetHeadphoneVolumeUpdateFlag"},
+        {119, nullptr, "NeedsToUpdateHeadphoneVolume"},
+        {120, nullptr, "GetPushNotificationActivityModeOnSleep"},
+        {121, nullptr, "SetPushNotificationActivityModeOnSleep"},
+        {122, nullptr, "GetServiceDiscoveryControlSettings"},
+        {123, nullptr, "SetServiceDiscoveryControlSettings"},
+        {124, nullptr, "GetErrorReportSharePermission"},
+        {125, nullptr, "SetErrorReportSharePermission"},
+        {126, nullptr, "GetAppletLaunchFlags"},
+        {127, nullptr, "SetAppletLaunchFlags"},
+        {128, nullptr, "GetConsoleSixAxisSensorAccelerationBias"},
+        {129, nullptr, "SetConsoleSixAxisSensorAccelerationBias"},
+        {130, nullptr, "GetConsoleSixAxisSensorAngularVelocityBias"},
+        {131, nullptr, "SetConsoleSixAxisSensorAngularVelocityBias"},
+        {132, nullptr, "GetConsoleSixAxisSensorAccelerationGain"},
+        {133, nullptr, "SetConsoleSixAxisSensorAccelerationGain"},
+        {134, nullptr, "GetConsoleSixAxisSensorAngularVelocityGain"},
+        {135, nullptr, "SetConsoleSixAxisSensorAngularVelocityGain"},
+        {136, nullptr, "GetKeyboardLayout"},
+        {137, nullptr, "SetKeyboardLayout"},
+        {138, nullptr, "GetWebInspectorFlag"},
+        {139, nullptr, "GetAllowedSslHosts"},
+        {140, nullptr, "GetHostFsMountPoint"},
+        {141, nullptr, "GetRequiresRunRepairTimeReviser"},
+        {142, nullptr, "SetRequiresRunRepairTimeReviser"},
+        {143, nullptr, "SetBlePairingSettings"},
+        {144, nullptr, "GetBlePairingSettings"},
+        {145, nullptr, "GetConsoleSixAxisSensorAngularVelocityTimeBias"},
+        {146, nullptr, "SetConsoleSixAxisSensorAngularVelocityTimeBias"},
+        {147, nullptr, "GetConsoleSixAxisSensorAngularAcceleration"},
+        {148, nullptr, "SetConsoleSixAxisSensorAngularAcceleration"},
+        {149, nullptr, "GetRebootlessSystemUpdateVersion"},
+        {150, nullptr, "GetDeviceTimeZoneLocationUpdatedTime"},
+        {151, nullptr, "SetDeviceTimeZoneLocationUpdatedTime"},
+        {152, nullptr, "GetUserSystemClockAutomaticCorrectionUpdatedTime"},
+        {153, nullptr, "SetUserSystemClockAutomaticCorrectionUpdatedTime"},
+        {154, nullptr, "GetAccountOnlineStorageSettings"},
+        {155, nullptr, "SetAccountOnlineStorageSettings"},
+        {156, nullptr, "GetPctlReadyFlag"},
+        {157, nullptr, "SetPctlReadyFlag"},
+        {162, nullptr, "GetPtmBatteryVersion"},
+        {163, nullptr, "SetPtmBatteryVersion"},
+        {164, nullptr, "GetUsb30HostEnableFlag"},
+        {165, nullptr, "SetUsb30HostEnableFlag"},
+        {166, nullptr, "GetUsb30DeviceEnableFlag"},
+        {167, nullptr, "SetUsb30DeviceEnableFlag"},
+        {168, nullptr, "GetThemeId"},
+        {169, nullptr, "SetThemeId"},
+        {170, nullptr, "GetChineseTraditionalInputMethod"},
+        {171, nullptr, "SetChineseTraditionalInputMethod"},
+        {172, nullptr, "GetPtmCycleCountReliability"},
+        {173, nullptr, "SetPtmCycleCountReliability"},
+        {174, nullptr, "GetHomeMenuScheme"},
+        {175, nullptr, "GetThemeSettings"},
+        {176, nullptr, "SetThemeSettings"},
+        {177, nullptr, "GetThemeKey"},
+        {178, nullptr, "SetThemeKey"},
+        {179, nullptr, "GetZoomFlag"},
+        {180, nullptr, "SetZoomFlag"},
+        {181, nullptr, "GetT"},
+        {182, nullptr, "SetT"},
+        {183, nullptr, "GetPlatformRegion"},
+        {184, nullptr, "SetPlatformRegion"},
+        {185, nullptr, "GetHomeMenuSchemeModel"},
+        {186, nullptr, "GetMemoryUsageRateFlag"},
+        {187, nullptr, "GetTouchScreenMode"},
+        {188, nullptr, "SetTouchScreenMode"},
+        {189, nullptr, "GetButtonConfigSettingsFull"},
+        {190, nullptr, "SetButtonConfigSettingsFull"},
+        {191, nullptr, "GetButtonConfigSettingsEmbedded"},
+        {192, nullptr, "SetButtonConfigSettingsEmbedded"},
+        {193, nullptr, "GetButtonConfigSettingsLeft"},
+        {194, nullptr, "SetButtonConfigSettingsLeft"},
+        {195, nullptr, "GetButtonConfigSettingsRight"},
+        {196, nullptr, "SetButtonConfigSettingsRight"},
+        {197, nullptr, "GetButtonConfigRegisteredSettingsEmbedded"},
+        {198, nullptr, "SetButtonConfigRegisteredSettingsEmbedded"},
+        {199, nullptr, "GetButtonConfigRegisteredSettings"},
+        {200, nullptr, "SetButtonConfigRegisteredSettings"},
+        {201, nullptr, "GetFieldTestingFlag"},
+        {202, nullptr, "SetFieldTestingFlag"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+SET_SYS::~SET_SYS() = default;
+
+} // namespace Service::Set

src/core/hle/service/set/set_sys.h

@@ -0,0 +1,35 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/hle/service/service.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::Set {
+
+class SET_SYS final : public ServiceFramework<SET_SYS> {
+public:
+    explicit SET_SYS(Core::System& system_);
+    ~SET_SYS() override;
+
+private:
+    /// Indicates the current theme set by the system settings
+    enum class ColorSet : u32 {
+        BasicWhite = 0,
+        BasicBlack = 1,
+    };
+
+    void GetFirmwareVersion(Kernel::HLERequestContext& ctx);
+    void GetFirmwareVersion2(Kernel::HLERequestContext& ctx);
+    void GetColorSetId(Kernel::HLERequestContext& ctx);
+    void SetColorSetId(Kernel::HLERequestContext& ctx);
+
+    ColorSet color_set = ColorSet::BasicWhite;
+};
+
+} // namespace Service::Set

src/core/hle/service/set/settings.cpp

@@ -0,0 +1,21 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/service/set/set.h"
+#include "core/hle/service/set/set_cal.h"
+#include "core/hle/service/set/set_fd.h"
+#include "core/hle/service/set/set_sys.h"
+#include "core/hle/service/set/settings.h"
+#include "core/hle/service/sm/sm.h"
+
+namespace Service::Set {
+
+void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
+    std::make_shared<SET>(system)->InstallAsService(service_manager);
+    std::make_shared<SET_CAL>(system)->InstallAsService(service_manager);
+    std::make_shared<SET_FD>(system)->InstallAsService(service_manager);
+    std::make_shared<SET_SYS>(system)->InstallAsService(service_manager);
+}
+
+} // namespace Service::Set

src/core/hle/service/set/settings.h

@@ -0,0 +1,20 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+namespace Core {
+class System;
+}
+
+namespace Service::SM {
+class ServiceManager;
+}
+
+namespace Service::Set {
+
+/// Registers all Settings services with the specified service manager.
+void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system);
+
+} // namespace Service::Set