Fix typos in src/core (#12625)

* Fix typos in src/core * Fix typo correction * Fix indentation of MemoryStateNames * Fix indent
2 years ago · cff668e1c4
28 changed files with 116 additions and 116 deletions
--- a/src/core/cpu_manager.h
+++ b/src/core/cpu_manager.h
@ -64,7 +64,7 @@ public:
        return [this] { ShutdownThreadFunction(); };
    }

-    void PreemptSingleCore(bool from_running_enviroment = true);
+    void PreemptSingleCore(bool from_running_environment = true);

    std::size_t CurrentCore() const {
        return current_core.load();
--- a/src/core/debugger/gdbstub.cpp
+++ b/src/core/debugger/gdbstub.cpp
@ -559,28 +559,28 @@ void GDBStub::HandleVCont(std::string_view command, std::vector<DebuggerAction>&
 }

 constexpr std::array<std::pair<const char*, Kernel::Svc::MemoryState>, 22> MemoryStateNames{{
-    {"----- Free -----", Kernel::Svc::MemoryState::Free},
-    {"Io              ", Kernel::Svc::MemoryState::Io},
-    {"Static          ", Kernel::Svc::MemoryState::Static},
-    {"Code            ", Kernel::Svc::MemoryState::Code},
-    {"CodeData        ", Kernel::Svc::MemoryState::CodeData},
-    {"Normal          ", Kernel::Svc::MemoryState::Normal},
-    {"Shared          ", Kernel::Svc::MemoryState::Shared},
-    {"AliasCode       ", Kernel::Svc::MemoryState::AliasCode},
-    {"AliasCodeData   ", Kernel::Svc::MemoryState::AliasCodeData},
-    {"Ipc             ", Kernel::Svc::MemoryState::Ipc},
-    {"Stack           ", Kernel::Svc::MemoryState::Stack},
-    {"ThreadLocal     ", Kernel::Svc::MemoryState::ThreadLocal},
-    {"Transfered      ", Kernel::Svc::MemoryState::Transfered},
-    {"SharedTransfered", Kernel::Svc::MemoryState::SharedTransfered},
-    {"SharedCode      ", Kernel::Svc::MemoryState::SharedCode},
-    {"Inaccessible    ", Kernel::Svc::MemoryState::Inaccessible},
-    {"NonSecureIpc    ", Kernel::Svc::MemoryState::NonSecureIpc},
-    {"NonDeviceIpc    ", Kernel::Svc::MemoryState::NonDeviceIpc},
-    {"Kernel          ", Kernel::Svc::MemoryState::Kernel},
-    {"GeneratedCode   ", Kernel::Svc::MemoryState::GeneratedCode},
-    {"CodeOut         ", Kernel::Svc::MemoryState::CodeOut},
-    {"Coverage        ", Kernel::Svc::MemoryState::Coverage},
+    {"----- Free ------", Kernel::Svc::MemoryState::Free},
+    {"Io               ", Kernel::Svc::MemoryState::Io},
+    {"Static           ", Kernel::Svc::MemoryState::Static},
+    {"Code             ", Kernel::Svc::MemoryState::Code},
+    {"CodeData         ", Kernel::Svc::MemoryState::CodeData},
+    {"Normal           ", Kernel::Svc::MemoryState::Normal},
+    {"Shared           ", Kernel::Svc::MemoryState::Shared},
+    {"AliasCode        ", Kernel::Svc::MemoryState::AliasCode},
+    {"AliasCodeData    ", Kernel::Svc::MemoryState::AliasCodeData},
+    {"Ipc              ", Kernel::Svc::MemoryState::Ipc},
+    {"Stack            ", Kernel::Svc::MemoryState::Stack},
+    {"ThreadLocal      ", Kernel::Svc::MemoryState::ThreadLocal},
+    {"Transferred      ", Kernel::Svc::MemoryState::Transferred},
+    {"SharedTransferred", Kernel::Svc::MemoryState::SharedTransferred},
+    {"SharedCode       ", Kernel::Svc::MemoryState::SharedCode},
+    {"Inaccessible     ", Kernel::Svc::MemoryState::Inaccessible},
+    {"NonSecureIpc     ", Kernel::Svc::MemoryState::NonSecureIpc},
+    {"NonDeviceIpc     ", Kernel::Svc::MemoryState::NonDeviceIpc},
+    {"Kernel           ", Kernel::Svc::MemoryState::Kernel},
+    {"GeneratedCode    ", Kernel::Svc::MemoryState::GeneratedCode},
+    {"CodeOut          ", Kernel::Svc::MemoryState::CodeOut},
+    {"Coverage         ", Kernel::Svc::MemoryState::Coverage},
 }};

 static constexpr const char* GetMemoryStateName(Kernel::Svc::MemoryState state) {
--- a/src/core/hle/kernel/k_memory_block.h
+++ b/src/core/hle/kernel/k_memory_block.h
@ -81,12 +81,12 @@ enum class KMemoryState : u32 {

    ThreadLocal = static_cast<u32>(Svc::MemoryState::ThreadLocal) | FlagLinearMapped,

-    Transfered = static_cast<u32>(Svc::MemoryState::Transfered) | FlagsMisc |
-                 FlagCanAlignedDeviceMap | FlagCanChangeAttribute | FlagCanUseIpc |
-                 FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc,
+    Transferred = static_cast<u32>(Svc::MemoryState::Transferred) | FlagsMisc |
+                  FlagCanAlignedDeviceMap | FlagCanChangeAttribute | FlagCanUseIpc |
+                  FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc,

-    SharedTransfered = static_cast<u32>(Svc::MemoryState::SharedTransfered) | FlagsMisc |
-                       FlagCanAlignedDeviceMap | FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc,
+    SharedTransferred = static_cast<u32>(Svc::MemoryState::SharedTransferred) | FlagsMisc |
+                        FlagCanAlignedDeviceMap | FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc,

    SharedCode = static_cast<u32>(Svc::MemoryState::SharedCode) | FlagMapped |
                 FlagReferenceCounted | FlagLinearMapped | FlagCanUseNonSecureIpc |
@ -130,8 +130,8 @@ static_assert(static_cast<u32>(KMemoryState::AliasCodeData) == 0x0FFFBD09);
 static_assert(static_cast<u32>(KMemoryState::Ipc) == 0x045C3C0A);
 static_assert(static_cast<u32>(KMemoryState::Stack) == 0x045C3C0B);
 static_assert(static_cast<u32>(KMemoryState::ThreadLocal) == 0x0400000C);
-static_assert(static_cast<u32>(KMemoryState::Transfered) == 0x055C3C0D);
-static_assert(static_cast<u32>(KMemoryState::SharedTransfered) == 0x045C380E);
+static_assert(static_cast<u32>(KMemoryState::Transferred) == 0x055C3C0D);
+static_assert(static_cast<u32>(KMemoryState::SharedTransferred) == 0x045C380E);
 static_assert(static_cast<u32>(KMemoryState::SharedCode) == 0x0440380F);
 static_assert(static_cast<u32>(KMemoryState::Inaccessible) == 0x00000010);
 static_assert(static_cast<u32>(KMemoryState::NonSecureIpc) == 0x045C3811);
--- a/src/core/hle/kernel/k_page_table_base.cpp
+++ b/src/core/hle/kernel/k_page_table_base.cpp
@ -486,8 +486,8 @@ KProcessAddress KPageTableBase::GetRegionAddress(Svc::MemoryState state) const {
    case Svc::MemoryState::Shared:
    case Svc::MemoryState::AliasCode:
    case Svc::MemoryState::AliasCodeData:
-    case Svc::MemoryState::Transfered:
-    case Svc::MemoryState::SharedTransfered:
+    case Svc::MemoryState::Transferred:
+    case Svc::MemoryState::SharedTransferred:
    case Svc::MemoryState::SharedCode:
    case Svc::MemoryState::GeneratedCode:
    case Svc::MemoryState::CodeOut:
@ -522,8 +522,8 @@ size_t KPageTableBase::GetRegionSize(Svc::MemoryState state) const {
    case Svc::MemoryState::Shared:
    case Svc::MemoryState::AliasCode:
    case Svc::MemoryState::AliasCodeData:
-    case Svc::MemoryState::Transfered:
-    case Svc::MemoryState::SharedTransfered:
+    case Svc::MemoryState::Transferred:
+    case Svc::MemoryState::SharedTransferred:
    case Svc::MemoryState::SharedCode:
    case Svc::MemoryState::GeneratedCode:
    case Svc::MemoryState::CodeOut:
@ -564,8 +564,8 @@ bool KPageTableBase::CanContain(KProcessAddress addr, size_t size, Svc::MemorySt
    case Svc::MemoryState::AliasCodeData:
    case Svc::MemoryState::Stack:
    case Svc::MemoryState::ThreadLocal:
-    case Svc::MemoryState::Transfered:
-    case Svc::MemoryState::SharedTransfered:
+    case Svc::MemoryState::Transferred:
+    case Svc::MemoryState::SharedTransferred:
    case Svc::MemoryState::SharedCode:
    case Svc::MemoryState::GeneratedCode:
    case Svc::MemoryState::CodeOut:
--- a/src/core/hle/kernel/k_transfer_memory.cpp
+++ b/src/core/hle/kernel/k_transfer_memory.cpp
@ -76,8 +76,8 @@ Result KTransferMemory::Map(KProcessAddress address, size_t size, Svc::MemoryPer

    // Map the memory.
    const KMemoryState state = (m_owner_perm == Svc::MemoryPermission::None)
-                                   ? KMemoryState::Transfered
-                                   : KMemoryState::SharedTransfered;
+                                   ? KMemoryState::Transferred
+                                   : KMemoryState::SharedTransferred;
    R_TRY(GetCurrentProcess(m_kernel).GetPageTable().MapPageGroup(
        address, *m_page_group, state, KMemoryPermission::UserReadWrite));

@ -96,8 +96,8 @@ Result KTransferMemory::Unmap(KProcessAddress address, size_t size) {

    // Unmap the memory.
    const KMemoryState state = (m_owner_perm == Svc::MemoryPermission::None)
-                                   ? KMemoryState::Transfered
-                                   : KMemoryState::SharedTransfered;
+                                   ? KMemoryState::Transferred
+                                   : KMemoryState::SharedTransferred;
    R_TRY(GetCurrentProcess(m_kernel).GetPageTable().UnmapPageGroup(address, *m_page_group, state));

    // Mark ourselves as unmapped.
--- a/src/core/hle/kernel/svc/svc_transfer_memory.cpp
+++ b/src/core/hle/kernel/svc/svc_transfer_memory.cpp
@ -90,7 +90,7 @@ Result MapTransferMemory(Core::System& system, Handle trmem_handle, uint64_t add
    // Verify that the mapping is in range.
    R_UNLESS(GetCurrentProcess(system.Kernel())
                 .GetPageTable()
-                 .CanContain(address, size, KMemoryState::Transfered),
+                 .CanContain(address, size, KMemoryState::Transferred),
             ResultInvalidMemoryRegion);

    // Map the transfer memory.
@ -117,7 +117,7 @@ Result UnmapTransferMemory(Core::System& system, Handle trmem_handle, uint64_t a
    // Verify that the mapping is in range.
    R_UNLESS(GetCurrentProcess(system.Kernel())
                 .GetPageTable()
-                 .CanContain(address, size, KMemoryState::Transfered),
+                 .CanContain(address, size, KMemoryState::Transferred),
             ResultInvalidMemoryRegion);

    // Unmap the transfer memory.
--- a/src/core/hle/kernel/svc_types.h
+++ b/src/core/hle/kernel/svc_types.h
@ -27,8 +27,8 @@ enum class MemoryState : u32 {
    Ipc = 0x0A,
    Stack = 0x0B,
    ThreadLocal = 0x0C,
-    Transfered = 0x0D,
-    SharedTransfered = 0x0E,
+    Transferred = 0x0D,
+    SharedTransferred = 0x0E,
    SharedCode = 0x0F,
    Inaccessible = 0x10,
    NonSecureIpc = 0x11,
--- a/src/core/hle/service/am/applets/applet_profile_select.h
+++ b/src/core/hle/service/am/applets/applet_profile_select.h
@ -76,7 +76,7 @@ struct UiSettingsDisplayOptions {
    bool is_system_or_launcher;
    bool is_registration_permitted;
    bool show_skip_button;
-    bool aditional_select;
+    bool additional_select;
    bool show_user_selector;
    bool is_unqualified_user_selectable;
 };
--- a/src/core/hle/service/caps/caps_manager.cpp
+++ b/src/core/hle/service/caps/caps_manager.cpp
@ -85,7 +85,7 @@ Result AlbumManager::GetAlbumFileList(std::vector<AlbumEntry>& out_entries, Albu
 }

 Result AlbumManager::GetAlbumFileList(std::vector<ApplicationAlbumFileEntry>& out_entries,
-                                      ContentType contex_type, s64 start_posix_time,
+                                      ContentType content_type, s64 start_posix_time,
                                      s64 end_posix_time, u64 aruid) const {
    if (!is_mounted) {
        return ResultIsNotMounted;
@ -94,7 +94,7 @@ Result AlbumManager::GetAlbumFileList(std::vector<ApplicationAlbumFileEntry>& ou
    std::vector<ApplicationAlbumEntry> album_entries;
    const auto start_date = ConvertToAlbumDateTime(start_posix_time);
    const auto end_date = ConvertToAlbumDateTime(end_posix_time);
-    const auto result = GetAlbumFileList(album_entries, contex_type, start_date, end_date, aruid);
+    const auto result = GetAlbumFileList(album_entries, content_type, start_date, end_date, aruid);

    if (result.IsError()) {
        return result;
@ -113,14 +113,14 @@ Result AlbumManager::GetAlbumFileList(std::vector<ApplicationAlbumFileEntry>& ou
 }

 Result AlbumManager::GetAlbumFileList(std::vector<ApplicationAlbumEntry>& out_entries,
-                                      ContentType contex_type, AlbumFileDateTime start_date,
+                                      ContentType content_type, AlbumFileDateTime start_date,
                                      AlbumFileDateTime end_date, u64 aruid) const {
    if (!is_mounted) {
        return ResultIsNotMounted;
    }

    for (auto& [file_id, path] : album_files) {
-        if (file_id.type != contex_type) {
+        if (file_id.type != content_type) {
            continue;
        }
        if (file_id.date > start_date) {
@ -139,7 +139,7 @@ Result AlbumManager::GetAlbumFileList(std::vector<ApplicationAlbumEntry>& out_en
            .hash{},
            .datetime = file_id.date,
            .storage = file_id.storage,
-            .content = contex_type,
+            .content = content_type,
            .unknown = 1,
        };
        out_entries.push_back(entry);
--- a/src/core/hle/service/caps/caps_manager.h
+++ b/src/core/hle/service/caps/caps_manager.h
@ -45,10 +45,10 @@ public:
    Result GetAlbumFileList(std::vector<AlbumEntry>& out_entries, AlbumStorage storage,
                            u8 flags) const;
    Result GetAlbumFileList(std::vector<ApplicationAlbumFileEntry>& out_entries,
-                            ContentType contex_type, s64 start_posix_time, s64 end_posix_time,
+                            ContentType content_type, s64 start_posix_time, s64 end_posix_time,
                            u64 aruid) const;
    Result GetAlbumFileList(std::vector<ApplicationAlbumEntry>& out_entries,
-                            ContentType contex_type, AlbumFileDateTime start_date,
+                            ContentType content_type, AlbumFileDateTime start_date,
                            AlbumFileDateTime end_date, u64 aruid) const;
    Result GetAutoSavingStorage(bool& out_is_autosaving) const;
    Result LoadAlbumScreenShotImage(LoadAlbumScreenShotImageOutput& out_image_output,
--- a/src/core/hle/service/caps/caps_result.h
+++ b/src/core/hle/service/caps/caps_result.h
@ -12,7 +12,7 @@ constexpr Result ResultUnknown5(ErrorModule::Capture, 5);
 constexpr Result ResultUnknown6(ErrorModule::Capture, 6);
 constexpr Result ResultUnknown7(ErrorModule::Capture, 7);
 constexpr Result ResultOutOfRange(ErrorModule::Capture, 8);
-constexpr Result ResulInvalidTimestamp(ErrorModule::Capture, 12);
+constexpr Result ResultInvalidTimestamp(ErrorModule::Capture, 12);
 constexpr Result ResultInvalidStorage(ErrorModule::Capture, 13);
 constexpr Result ResultInvalidFileContents(ErrorModule::Capture, 14);
 constexpr Result ResultIsNotMounted(ErrorModule::Capture, 21);
--- a/src/core/hle/service/friend/friend.cpp
+++ b/src/core/hle/service/friend/friend.cpp
@ -131,7 +131,7 @@ private:
        u8 is_favorite;
        u8 same_app;
        u8 same_app_played;
-        u8 arbitary_app_played;
+        u8 arbitrary_app_played;
        u64 group_id;
    };
    static_assert(sizeof(SizedFriendFilter) == 0x10, "SizedFriendFilter is an invalid size");
--- a/src/core/hle/service/hid/hid.cpp
+++ b/src/core/hle/service/hid/hid.cpp
@ -18,23 +18,23 @@ namespace Service::HID {

 void LoopProcess(Core::System& system) {
    auto server_manager = std::make_unique<ServerManager>(system);
-    std::shared_ptr<ResourceManager> resouce_manager = std::make_shared<ResourceManager>(system);
+    std::shared_ptr<ResourceManager> resource_manager = std::make_shared<ResourceManager>(system);
    std::shared_ptr<HidFirmwareSettings> firmware_settings =
        std::make_shared<HidFirmwareSettings>();

    // TODO: Remove this hack until this service is emulated properly.
    const auto process_list = system.Kernel().GetProcessList();
    if (!process_list.empty()) {
-        resouce_manager->Initialize();
-        resouce_manager->RegisterAppletResourceUserId(process_list[0]->GetId(), true);
+        resource_manager->Initialize();
+        resource_manager->RegisterAppletResourceUserId(process_list[0]->GetId(), true);
    }

    server_manager->RegisterNamedService(
-        "hid", std::make_shared<IHidServer>(system, resouce_manager, firmware_settings));
+        "hid", std::make_shared<IHidServer>(system, resource_manager, firmware_settings));
    server_manager->RegisterNamedService(
-        "hid:dbg", std::make_shared<IHidDebugServer>(system, resouce_manager));
+        "hid:dbg", std::make_shared<IHidDebugServer>(system, resource_manager));
    server_manager->RegisterNamedService(
-        "hid:sys", std::make_shared<IHidSystemServer>(system, resouce_manager));
+        "hid:sys", std::make_shared<IHidSystemServer>(system, resource_manager));

    server_manager->RegisterNamedService("hidbus", std::make_shared<HidBus>(system));

--- a/src/core/hle/service/hid/hidbus.cpp
+++ b/src/core/hle/service/hid/hidbus.cpp
@ -67,7 +67,7 @@ HidBus::~HidBus() {
 void HidBus::UpdateHidbus(std::chrono::nanoseconds ns_late) {
    if (is_hidbus_enabled) {
        for (std::size_t i = 0; i < devices.size(); ++i) {
-            if (!devices[i].is_device_initializated) {
+            if (!devices[i].is_device_initialized) {
                continue;
            }
            auto& device = devices[i].device;
@ -213,7 +213,7 @@ void HidBus::Initialize(HLERequestContext& ctx) {

        if (bus_handle_.internal_index == 0 && Settings::values.enable_ring_controller) {
            MakeDevice<RingController>(bus_handle_);
-            devices[device_index.value()].is_device_initializated = true;
+            devices[device_index.value()].is_device_initialized = true;
            devices[device_index.value()].device->ActivateDevice();
            cur_entry.is_in_focus = true;
            cur_entry.is_connected = true;
@ -222,7 +222,7 @@ void HidBus::Initialize(HLERequestContext& ctx) {
            cur_entry.is_polling_mode = false;
        } else {
            MakeDevice<HidbusStubbed>(bus_handle_);
-            devices[device_index.value()].is_device_initializated = true;
+            devices[device_index.value()].is_device_initialized = true;
            cur_entry.is_in_focus = true;
            cur_entry.is_connected = false;
            cur_entry.is_connected_result = ResultSuccess;
@ -261,7 +261,7 @@ void HidBus::Finalize(HLERequestContext& ctx) {
        const auto entry_index = devices[device_index.value()].handle.internal_index;
        auto& cur_entry = hidbus_status.entries[entry_index];
        auto& device = devices[device_index.value()].device;
-        devices[device_index.value()].is_device_initializated = false;
+        devices[device_index.value()].is_device_initialized = false;
        device->DeactivateDevice();

        cur_entry.is_in_focus = true;
--- a/src/core/hle/service/hid/hidbus.h
+++ b/src/core/hle/service/hid/hidbus.h
@ -89,7 +89,7 @@ private:
    static_assert(sizeof(HidbusStatusManager) <= 0x1000, "HidbusStatusManager is an invalid size");

    struct HidbusDevice {
-        bool is_device_initializated{};
+        bool is_device_initialized{};
        BusHandle handle{};
        std::unique_ptr<HidbusBase> device{nullptr};
    };
--- a/src/core/hle/service/hle_ipc.cpp
+++ b/src/core/hle/service/hle_ipc.cpp
@ -181,22 +181,22 @@ void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
        }
    }

-    buffer_x_desciptors.reserve(command_header->num_buf_x_descriptors);
-    buffer_a_desciptors.reserve(command_header->num_buf_a_descriptors);
-    buffer_b_desciptors.reserve(command_header->num_buf_b_descriptors);
-    buffer_w_desciptors.reserve(command_header->num_buf_w_descriptors);
+    buffer_x_descriptors.reserve(command_header->num_buf_x_descriptors);
+    buffer_a_descriptors.reserve(command_header->num_buf_a_descriptors);
+    buffer_b_descriptors.reserve(command_header->num_buf_b_descriptors);
+    buffer_w_descriptors.reserve(command_header->num_buf_w_descriptors);

    for (u32 i = 0; i < command_header->num_buf_x_descriptors; ++i) {
-        buffer_x_desciptors.push_back(rp.PopRaw<IPC::BufferDescriptorX>());
+        buffer_x_descriptors.push_back(rp.PopRaw<IPC::BufferDescriptorX>());
    }
    for (u32 i = 0; i < command_header->num_buf_a_descriptors; ++i) {
-        buffer_a_desciptors.push_back(rp.PopRaw<IPC::BufferDescriptorABW>());
+        buffer_a_descriptors.push_back(rp.PopRaw<IPC::BufferDescriptorABW>());
    }
    for (u32 i = 0; i < command_header->num_buf_b_descriptors; ++i) {
-        buffer_b_desciptors.push_back(rp.PopRaw<IPC::BufferDescriptorABW>());
+        buffer_b_descriptors.push_back(rp.PopRaw<IPC::BufferDescriptorABW>());
    }
    for (u32 i = 0; i < command_header->num_buf_w_descriptors; ++i) {
-        buffer_w_desciptors.push_back(rp.PopRaw<IPC::BufferDescriptorABW>());
+        buffer_w_descriptors.push_back(rp.PopRaw<IPC::BufferDescriptorABW>());
    }

    const auto buffer_c_offset = rp.GetCurrentOffset() + command_header->data_size;
@ -246,7 +246,7 @@ void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
        IPC::CommandHeader::BufferDescriptorCFlag::InlineDescriptor) {
        if (command_header->buf_c_descriptor_flags ==
            IPC::CommandHeader::BufferDescriptorCFlag::OneDescriptor) {
-            buffer_c_desciptors.push_back(rp.PopRaw<IPC::BufferDescriptorC>());
+            buffer_c_descriptors.push_back(rp.PopRaw<IPC::BufferDescriptorC>());
        } else {
            u32 num_buf_c_descriptors =
                static_cast<u32>(command_header->buf_c_descriptor_flags.Value()) - 2;
@ -256,7 +256,7 @@ void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
            ASSERT(num_buf_c_descriptors < 14);

            for (u32 i = 0; i < num_buf_c_descriptors; ++i) {
-                buffer_c_desciptors.push_back(rp.PopRaw<IPC::BufferDescriptorC>());
+                buffer_c_descriptors.push_back(rp.PopRaw<IPC::BufferDescriptorC>());
            }
        }
    }
--- a/src/core/hle/service/hle_ipc.h
+++ b/src/core/hle/service/hle_ipc.h
@ -232,19 +232,19 @@ public:
    }

    [[nodiscard]] const std::vector<IPC::BufferDescriptorX>& BufferDescriptorX() const {
-        return buffer_x_desciptors;
+        return buffer_x_descriptors;
    }

    [[nodiscard]] const std::vector<IPC::BufferDescriptorABW>& BufferDescriptorA() const {
-        return buffer_a_desciptors;
+        return buffer_a_descriptors;
    }

    [[nodiscard]] const std::vector<IPC::BufferDescriptorABW>& BufferDescriptorB() const {
-        return buffer_b_desciptors;
+        return buffer_b_descriptors;
    }

    [[nodiscard]] const std::vector<IPC::BufferDescriptorC>& BufferDescriptorC() const {
-        return buffer_c_desciptors;
+        return buffer_c_descriptors;
    }

    [[nodiscard]] const IPC::DomainMessageHeader& GetDomainMessageHeader() const {
@ -406,11 +406,11 @@ private:
    std::optional<IPC::HandleDescriptorHeader> handle_descriptor_header;
    std::optional<IPC::DataPayloadHeader> data_payload_header;
    std::optional<IPC::DomainMessageHeader> domain_message_header;
-    std::vector<IPC::BufferDescriptorX> buffer_x_desciptors;
-    std::vector<IPC::BufferDescriptorABW> buffer_a_desciptors;
-    std::vector<IPC::BufferDescriptorABW> buffer_b_desciptors;
-    std::vector<IPC::BufferDescriptorABW> buffer_w_desciptors;
-    std::vector<IPC::BufferDescriptorC> buffer_c_desciptors;
+    std::vector<IPC::BufferDescriptorX> buffer_x_descriptors;
+    std::vector<IPC::BufferDescriptorABW> buffer_a_descriptors;
+    std::vector<IPC::BufferDescriptorABW> buffer_b_descriptors;
+    std::vector<IPC::BufferDescriptorABW> buffer_w_descriptors;
+    std::vector<IPC::BufferDescriptorC> buffer_c_descriptors;

    u32_le command{};
    u64 pid{};
--- a/src/core/hle/service/nfc/common/amiibo_crypto.cpp
+++ b/src/core/hle/service/nfc/common/amiibo_crypto.cpp
@ -19,7 +19,7 @@ namespace Service::NFP::AmiiboCrypto {
 bool IsAmiiboValid(const EncryptedNTAG215File& ntag_file) {
    const auto& amiibo_data = ntag_file.user_memory;
    LOG_DEBUG(Service_NFP, "uuid_lock=0x{0:x}", ntag_file.static_lock);
-    LOG_DEBUG(Service_NFP, "compability_container=0x{0:x}", ntag_file.compability_container);
+    LOG_DEBUG(Service_NFP, "compatibility_container=0x{0:x}", ntag_file.compatibility_container);
    LOG_DEBUG(Service_NFP, "write_count={}", static_cast<u16>(amiibo_data.write_counter));

    LOG_DEBUG(Service_NFP, "character_id=0x{0:x}", amiibo_data.model_info.character_id);
@ -49,7 +49,7 @@ bool IsAmiiboValid(const EncryptedNTAG215File& ntag_file) {
    if (ntag_file.static_lock != 0xE00F) {
        return false;
    }
-    if (ntag_file.compability_container != 0xEEFF10F1U) {
+    if (ntag_file.compatibility_container != 0xEEFF10F1U) {
        return false;
    }
    if (amiibo_data.model_info.tag_type != NFC::PackedTagType::Type2) {
@ -78,7 +78,7 @@ NTAG215File NfcDataToEncodedData(const EncryptedNTAG215File& nfc_data) {
    encoded_data.uid_crc_check2 = nfc_data.uuid_crc_check2;
    encoded_data.internal_number = nfc_data.internal_number;
    encoded_data.static_lock = nfc_data.static_lock;
-    encoded_data.compability_container = nfc_data.compability_container;
+    encoded_data.compatibility_container = nfc_data.compatibility_container;
    encoded_data.hmac_data = nfc_data.user_memory.hmac_data;
    encoded_data.constant_value = nfc_data.user_memory.constant_value;
    encoded_data.write_counter = nfc_data.user_memory.write_counter;
@ -112,7 +112,7 @@ EncryptedNTAG215File EncodedDataToNfcData(const NTAG215File& encoded_data) {
    nfc_data.uuid_crc_check2 = encoded_data.uid_crc_check2;
    nfc_data.internal_number = encoded_data.internal_number;
    nfc_data.static_lock = encoded_data.static_lock;
-    nfc_data.compability_container = encoded_data.compability_container;
+    nfc_data.compatibility_container = encoded_data.compatibility_container;
    nfc_data.user_memory.hmac_data = encoded_data.hmac_data;
    nfc_data.user_memory.constant_value = encoded_data.constant_value;
    nfc_data.user_memory.write_counter = encoded_data.write_counter;
@ -257,7 +257,7 @@ void Cipher(const DerivedKeys& keys, const NTAG215File& in_data, NTAG215File& ou
    out_data.uid_crc_check2 = in_data.uid_crc_check2;
    out_data.internal_number = in_data.internal_number;
    out_data.static_lock = in_data.static_lock;
-    out_data.compability_container = in_data.compability_container;
+    out_data.compatibility_container = in_data.compatibility_container;

    out_data.constant_value = in_data.constant_value;
    out_data.write_counter = in_data.write_counter;
--- a/src/core/hle/service/nfc/common/device.cpp
+++ b/src/core/hle/service/nfc/common/device.cpp
@ -75,7 +75,7 @@ void NfcDevice::NpadUpdate(Core::HID::ControllerTriggerType type) {
        return;
    }

-    if (!is_initalized) {
+    if (!is_initialized) {
        return;
    }

@ -207,7 +207,7 @@ void NfcDevice::Initialize() {
        return;
    }

-    is_initalized = npad_device->AddNfcHandle();
+    is_initialized = npad_device->AddNfcHandle();
 }

 void NfcDevice::Finalize() {
@ -226,7 +226,7 @@ void NfcDevice::Finalize() {
    }

    device_state = DeviceState::Unavailable;
-    is_initalized = false;
+    is_initialized = false;
 }

 Result NfcDevice::StartDetection(NfcProtocol allowed_protocol) {
--- a/src/core/hle/service/nfc/common/device.h
+++ b/src/core/hle/service/nfc/common/device.h
@ -126,7 +126,7 @@ private:
    Kernel::KEvent* deactivate_event = nullptr;
    Kernel::KEvent* availability_change_event = nullptr;

-    bool is_initalized{};
+    bool is_initialized{};
    NfcProtocol allowed_protocols{};
    DeviceState device_state{DeviceState::Unavailable};

--- a/src/core/hle/service/nfp/nfp_types.h
+++ b/src/core/hle/service/nfp/nfp_types.h
@ -243,12 +243,12 @@ static_assert(sizeof(EncryptedAmiiboFile) == 0x1F8, "AmiiboFile is an invalid si
 struct NTAG215File {
    u8 uid_crc_check2;
    u8 internal_number;
-    u16 static_lock;           // Set defined pages as read only
-    u32 compability_container; // Defines available memory
-    HashData hmac_data;        // Hash
-    u8 constant_value;         // Must be A5
-    u16_be write_counter;      // Number of times the amiibo has been written?
-    u8 amiibo_version;         // Amiibo file version
+    u16 static_lock;             // Set defined pages as read only
+    u32 compatibility_container; // Defines available memory
+    HashData hmac_data;          // Hash
+    u8 constant_value;           // Must be A5
+    u16_be write_counter;        // Number of times the amiibo has been written?
+    u8 amiibo_version;           // Amiibo file version
    AmiiboSettings settings;
    Service::Mii::Ver3StoreData owner_mii; // Mii data
    u64_be application_id;                 // Game id
@ -278,7 +278,7 @@ struct EncryptedNTAG215File {
    u8 uuid_crc_check2;
    u8 internal_number;
    u16 static_lock;                 // Set defined pages as read only
-    u32 compability_container;       // Defines available memory
+    u32 compatibility_container;     // Defines available memory
    EncryptedAmiiboFile user_memory; // Writable data
    u32 dynamic_lock;                // Dynamic lock
    u32 CFG0;                        // Defines memory protected by password
--- a/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.h
+++ b/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.h
@ -90,7 +90,7 @@ private:
            u64_le align;
        };
    };
-    static_assert(sizeof(IoctlAllocSpace) == 24, "IoctlInitalizeEx is incorrect size");
+    static_assert(sizeof(IoctlAllocSpace) == 24, "IoctlInitializeEx is incorrect size");

    struct IoctlFreeSpace {
        u64_le offset{};
--- a/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp
@ -15,7 +15,7 @@ namespace Service::Nvidia::Devices {
 nvhost_ctrl_gpu::nvhost_ctrl_gpu(Core::System& system_, EventInterface& events_interface_)
    : nvdevice{system_}, events_interface{events_interface_} {
    error_notifier_event = events_interface.CreateEvent("CtrlGpuErrorNotifier");
-    unknown_event = events_interface.CreateEvent("CtrlGpuUknownEvent");
+    unknown_event = events_interface.CreateEvent("CtrlGpuUnknownEvent");
 }
 nvhost_ctrl_gpu::~nvhost_ctrl_gpu() {
    events_interface.FreeEvent(error_notifier_event);
--- a/src/core/hle/service/nvdrv/nvdata.h
+++ b/src/core/hle/service/nvdrv/nvdata.h
@ -51,7 +51,7 @@ enum class NvResult : u32 {
    DispNoDisplaysAttached = 0x20003,
    DispModeNotSupported = 0x20004,
    DispNotFound = 0x20005,
-    DispAttachDissallowed = 0x20006,
+    DispAttachDisallowed = 0x20006,
    DispTypeNotSupported = 0x20007,
    DispAuthenticationFailed = 0x20008,
    DispNotAttached = 0x20009,
--- a/src/core/hle/service/pcv/pcv.cpp
+++ b/src/core/hle/service/pcv/pcv.cpp
@ -54,8 +54,8 @@ public:

 class IClkrstSession final : public ServiceFramework<IClkrstSession> {
 public:
-    explicit IClkrstSession(Core::System& system_, DeviceCode deivce_code_)
-        : ServiceFramework{system_, "IClkrstSession"}, deivce_code(deivce_code_) {
+    explicit IClkrstSession(Core::System& system_, DeviceCode device_code_)
+        : ServiceFramework{system_, "IClkrstSession"}, device_code(device_code_) {
        // clang-format off
        static const FunctionInfo functions[] = {
            {0, nullptr, "SetClockEnabled"},
@ -93,7 +93,7 @@ private:
        rb.Push<u32>(clock_rate);
    }

-    DeviceCode deivce_code;
+    DeviceCode device_code;
    u32 clock_rate{};
 };

@ -118,9 +118,9 @@ private:
    void OpenSession(HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        const auto device_code = static_cast<DeviceCode>(rp.Pop<u32>());
-        const auto unkonwn_input = rp.Pop<u32>();
+        const auto unknown_input = rp.Pop<u32>();

-        LOG_DEBUG(Service_PCV, "called, device_code={}, input={}", device_code, unkonwn_input);
+        LOG_DEBUG(Service_PCV, "called, device_code={}, input={}", device_code, unknown_input);

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(ResultSuccess);
--- a/src/core/hle/service/set/system_settings.cpp
+++ b/src/core/hle/service/set/system_settings.cpp
@ -28,7 +28,7 @@ SystemSettings DefaultSystemSettings() {
        .cmu_mode = CmuMode::None,
        .tv_underscan = {},
        .tv_gama = 1.0f,
-        .constrast_ratio = 0.5f,
+        .contrast_ratio = 0.5f,
    };

    settings.initial_launch_settings_packed = {
--- a/src/core/hle/service/set/system_settings.h
+++ b/src/core/hle/service/set/system_settings.h
@ -208,7 +208,7 @@ struct TvSettings {
    CmuMode cmu_mode;
    u32 tv_underscan;
    f32 tv_gama;
-    f32 constrast_ratio;
+    f32 contrast_ratio;
 };
 static_assert(sizeof(TvSettings) == 0x20, "TvSettings is an invalid size");

@ -341,7 +341,7 @@ struct SystemSettings {
    std::array<u8, 0x3C> reserved_09934;

    // nn::settings::system::ErrorReportSharePermission
-    ErrorReportSharePermission error_report_share_permssion;
+    ErrorReportSharePermission error_report_share_permission;

    std::array<u8, 0x3C> reserved_09974;

--- a/src/core/hle/service/set/system_settings_server.cpp
+++ b/src/core/hle/service/set/system_settings_server.cpp
@ -721,10 +721,10 @@ void ISystemSettingsServer::SetTvSettings(HLERequestContext& ctx) {
    SetSaveNeeded();

    LOG_INFO(Service_SET,
-             "called, flags={}, cmu_mode={}, constrast_ratio={}, hdmi_content_type={}, "
+             "called, flags={}, cmu_mode={}, contrast_ratio={}, hdmi_content_type={}, "
             "rgb_range={}, tv_gama={}, tv_resolution={}, tv_underscan={}",
             m_system_settings.tv_settings.flags.raw, m_system_settings.tv_settings.cmu_mode,
-             m_system_settings.tv_settings.constrast_ratio,
+             m_system_settings.tv_settings.contrast_ratio,
             m_system_settings.tv_settings.hdmi_content_type,
             m_system_settings.tv_settings.rgb_range, m_system_settings.tv_settings.tv_gama,
             m_system_settings.tv_settings.tv_resolution,
@ -870,10 +870,10 @@ void ISystemSettingsServer::GetInitialLaunchSettings(HLERequestContext& ctx) {

 void ISystemSettingsServer::SetInitialLaunchSettings(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
-    auto inital_launch_settings = rp.PopRaw<InitialLaunchSettings>();
+    auto initial_launch_settings = rp.PopRaw<InitialLaunchSettings>();

-    m_system_settings.initial_launch_settings_packed.flags = inital_launch_settings.flags;
-    m_system_settings.initial_launch_settings_packed.timestamp = inital_launch_settings.timestamp;
+    m_system_settings.initial_launch_settings_packed.flags = initial_launch_settings.flags;
+    m_system_settings.initial_launch_settings_packed.timestamp = initial_launch_settings.timestamp;
    SetSaveNeeded();

    LOG_INFO(Service_SET, "called, flags={}, timestamp={}",