yuzu-emu/yuzu-android
1
0
Fork 0
mirror of https://github.com/yuzu-emu/yuzu-android.git synced 2024-11-22 16:15:38 +01:00
Code Issues Packages Projects Releases Wiki Activity

Fix typos in src/core (#12625)

Browse Source 
* Fix typos in src/core

* Fix typo correction

* Fix indentation of MemoryStateNames

* Fix indent
This commit is contained in:
Viktor Szépe 2024-01-08 20:31:48 +01:00 committed by GitHub
parent 82b58668ed
commit f124461674
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
28 changed files with 116 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/core/cpu_manager.h
View File

@ -64,7 +64,7 @@ public:
return [this] { ShutdownThreadFunction(); }; return [this] { ShutdownThreadFunction(); };
} }
void PreemptSingleCore(bool from_running_enviroment = true); void PreemptSingleCore(bool from_running_environment = true);
std::size_t CurrentCore() const { std::size_t CurrentCore() const {
return current_core.load(); return current_core.load();

44
src/core/debugger/gdbstub.cpp
View File

@ -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{{ constexpr std::array<std::pair<const char*, Kernel::Svc::MemoryState>, 22> MemoryStateNames{{
{"----- Free -----", Kernel::Svc::MemoryState::Free}, {"----- Free ------", Kernel::Svc::MemoryState::Free},
{"Io ", Kernel::Svc::MemoryState::Io}, {"Io ", Kernel::Svc::MemoryState::Io},
{"Static ", Kernel::Svc::MemoryState::Static}, {"Static ", Kernel::Svc::MemoryState::Static},
{"Code ", Kernel::Svc::MemoryState::Code}, {"Code ", Kernel::Svc::MemoryState::Code},
{"CodeData ", Kernel::Svc::MemoryState::CodeData}, {"CodeData ", Kernel::Svc::MemoryState::CodeData},
{"Normal ", Kernel::Svc::MemoryState::Normal}, {"Normal ", Kernel::Svc::MemoryState::Normal},
{"Shared ", Kernel::Svc::MemoryState::Shared}, {"Shared ", Kernel::Svc::MemoryState::Shared},
{"AliasCode ", Kernel::Svc::MemoryState::AliasCode}, {"AliasCode ", Kernel::Svc::MemoryState::AliasCode},
{"AliasCodeData ", Kernel::Svc::MemoryState::AliasCodeData}, {"AliasCodeData ", Kernel::Svc::MemoryState::AliasCodeData},
{"Ipc ", Kernel::Svc::MemoryState::Ipc}, {"Ipc ", Kernel::Svc::MemoryState::Ipc},
{"Stack ", Kernel::Svc::MemoryState::Stack}, {"Stack ", Kernel::Svc::MemoryState::Stack},
{"ThreadLocal ", Kernel::Svc::MemoryState::ThreadLocal}, {"ThreadLocal ", Kernel::Svc::MemoryState::ThreadLocal},
{"Transfered ", Kernel::Svc::MemoryState::Transfered}, {"Transferred ", Kernel::Svc::MemoryState::Transferred},
{"SharedTransfered", Kernel::Svc::MemoryState::SharedTransfered}, {"SharedTransferred", Kernel::Svc::MemoryState::SharedTransferred},
{"SharedCode ", Kernel::Svc::MemoryState::SharedCode}, {"SharedCode ", Kernel::Svc::MemoryState::SharedCode},
{"Inaccessible ", Kernel::Svc::MemoryState::Inaccessible}, {"Inaccessible ", Kernel::Svc::MemoryState::Inaccessible},
{"NonSecureIpc ", Kernel::Svc::MemoryState::NonSecureIpc}, {"NonSecureIpc ", Kernel::Svc::MemoryState::NonSecureIpc},
{"NonDeviceIpc ", Kernel::Svc::MemoryState::NonDeviceIpc}, {"NonDeviceIpc ", Kernel::Svc::MemoryState::NonDeviceIpc},
{"Kernel ", Kernel::Svc::MemoryState::Kernel}, {"Kernel ", Kernel::Svc::MemoryState::Kernel},
{"GeneratedCode ", Kernel::Svc::MemoryState::GeneratedCode}, {"GeneratedCode ", Kernel::Svc::MemoryState::GeneratedCode},
{"CodeOut ", Kernel::Svc::MemoryState::CodeOut}, {"CodeOut ", Kernel::Svc::MemoryState::CodeOut},
{"Coverage ", Kernel::Svc::MemoryState::Coverage}, {"Coverage ", Kernel::Svc::MemoryState::Coverage},
}}; }};
static constexpr const char* GetMemoryStateName(Kernel::Svc::MemoryState state) { static constexpr const char* GetMemoryStateName(Kernel::Svc::MemoryState state) {

14
src/core/hle/kernel/k_memory_block.h
View File

@ -81,12 +81,12 @@ enum class KMemoryState : u32 {
ThreadLocal = static_cast<u32>(Svc::MemoryState::ThreadLocal) | FlagLinearMapped, ThreadLocal = static_cast<u32>(Svc::MemoryState::ThreadLocal) | FlagLinearMapped,
Transfered = static_cast<u32>(Svc::MemoryState::Transfered) | FlagsMisc | Transferred = static_cast<u32>(Svc::MemoryState::Transferred) | FlagsMisc |
FlagCanAlignedDeviceMap | FlagCanChangeAttribute | FlagCanUseIpc | FlagCanAlignedDeviceMap | FlagCanChangeAttribute | FlagCanUseIpc |
FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc, FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc,
SharedTransfered = static_cast<u32>(Svc::MemoryState::SharedTransfered) | FlagsMisc | SharedTransferred = static_cast<u32>(Svc::MemoryState::SharedTransferred) | FlagsMisc |
FlagCanAlignedDeviceMap | FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc, FlagCanAlignedDeviceMap | FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc,
SharedCode = static_cast<u32>(Svc::MemoryState::SharedCode) | FlagMapped | SharedCode = static_cast<u32>(Svc::MemoryState::SharedCode) | FlagMapped |
FlagReferenceCounted | FlagLinearMapped | FlagCanUseNonSecureIpc | 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::Ipc) == 0x045C3C0A);
static_assert(static_cast<u32>(KMemoryState::Stack) == 0x045C3C0B); static_assert(static_cast<u32>(KMemoryState::Stack) == 0x045C3C0B);
static_assert(static_cast<u32>(KMemoryState::ThreadLocal) == 0x0400000C); static_assert(static_cast<u32>(KMemoryState::ThreadLocal) == 0x0400000C);
static_assert(static_cast<u32>(KMemoryState::Transfered) == 0x055C3C0D); static_assert(static_cast<u32>(KMemoryState::Transferred) == 0x055C3C0D);
static_assert(static_cast<u32>(KMemoryState::SharedTransfered) == 0x045C380E); static_assert(static_cast<u32>(KMemoryState::SharedTransferred) == 0x045C380E);
static_assert(static_cast<u32>(KMemoryState::SharedCode) == 0x0440380F); static_assert(static_cast<u32>(KMemoryState::SharedCode) == 0x0440380F);
static_assert(static_cast<u32>(KMemoryState::Inaccessible) == 0x00000010); static_assert(static_cast<u32>(KMemoryState::Inaccessible) == 0x00000010);
static_assert(static_cast<u32>(KMemoryState::NonSecureIpc) == 0x045C3811); static_assert(static_cast<u32>(KMemoryState::NonSecureIpc) == 0x045C3811);

12
src/core/hle/kernel/k_page_table_base.cpp
View File

@ -486,8 +486,8 @@ KProcessAddress KPageTableBase::GetRegionAddress(Svc::MemoryState state) const {
case Svc::MemoryState::Shared: case Svc::MemoryState::Shared:
case Svc::MemoryState::AliasCode: case Svc::MemoryState::AliasCode:
case Svc::MemoryState::AliasCodeData: case Svc::MemoryState::AliasCodeData:
case Svc::MemoryState::Transfered: case Svc::MemoryState::Transferred:
case Svc::MemoryState::SharedTransfered: case Svc::MemoryState::SharedTransferred:
case Svc::MemoryState::SharedCode: case Svc::MemoryState::SharedCode:
case Svc::MemoryState::GeneratedCode: case Svc::MemoryState::GeneratedCode:
case Svc::MemoryState::CodeOut: case Svc::MemoryState::CodeOut:
@ -522,8 +522,8 @@ size_t KPageTableBase::GetRegionSize(Svc::MemoryState state) const {
case Svc::MemoryState::Shared: case Svc::MemoryState::Shared:
case Svc::MemoryState::AliasCode: case Svc::MemoryState::AliasCode:
case Svc::MemoryState::AliasCodeData: case Svc::MemoryState::AliasCodeData:
case Svc::MemoryState::Transfered: case Svc::MemoryState::Transferred:
case Svc::MemoryState::SharedTransfered: case Svc::MemoryState::SharedTransferred:
case Svc::MemoryState::SharedCode: case Svc::MemoryState::SharedCode:
case Svc::MemoryState::GeneratedCode: case Svc::MemoryState::GeneratedCode:
case Svc::MemoryState::CodeOut: 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::AliasCodeData:
case Svc::MemoryState::Stack: case Svc::MemoryState::Stack:
case Svc::MemoryState::ThreadLocal: case Svc::MemoryState::ThreadLocal:
case Svc::MemoryState::Transfered: case Svc::MemoryState::Transferred:
case Svc::MemoryState::SharedTransfered: case Svc::MemoryState::SharedTransferred:
case Svc::MemoryState::SharedCode: case Svc::MemoryState::SharedCode:
case Svc::MemoryState::GeneratedCode: case Svc::MemoryState::GeneratedCode:
case Svc::MemoryState::CodeOut: case Svc::MemoryState::CodeOut:

8
src/core/hle/kernel/k_transfer_memory.cpp
View File

@ -76,8 +76,8 @@ Result KTransferMemory::Map(KProcessAddress address, size_t size, Svc::MemoryPer
// Map the memory. // Map the memory.
const KMemoryState state = (m_owner_perm == Svc::MemoryPermission::None) const KMemoryState state = (m_owner_perm == Svc::MemoryPermission::None)
? KMemoryState::Transfered ? KMemoryState::Transferred
: KMemoryState::SharedTransfered; : KMemoryState::SharedTransferred;
R_TRY(GetCurrentProcess(m_kernel).GetPageTable().MapPageGroup( R_TRY(GetCurrentProcess(m_kernel).GetPageTable().MapPageGroup(
address, *m_page_group, state, KMemoryPermission::UserReadWrite)); address, *m_page_group, state, KMemoryPermission::UserReadWrite));
@ -96,8 +96,8 @@ Result KTransferMemory::Unmap(KProcessAddress address, size_t size) {
// Unmap the memory. // Unmap the memory.
const KMemoryState state = (m_owner_perm == Svc::MemoryPermission::None) const KMemoryState state = (m_owner_perm == Svc::MemoryPermission::None)
? KMemoryState::Transfered ? KMemoryState::Transferred
: KMemoryState::SharedTransfered; : KMemoryState::SharedTransferred;
R_TRY(GetCurrentProcess(m_kernel).GetPageTable().UnmapPageGroup(address, *m_page_group, state)); R_TRY(GetCurrentProcess(m_kernel).GetPageTable().UnmapPageGroup(address, *m_page_group, state));
// Mark ourselves as unmapped. // Mark ourselves as unmapped.

4
src/core/hle/kernel/svc/svc_transfer_memory.cpp
View File

@ -90,7 +90,7 @@ Result MapTransferMemory(Core::System& system, Handle trmem_handle, uint64_t add
// Verify that the mapping is in range. // Verify that the mapping is in range.
R_UNLESS(GetCurrentProcess(system.Kernel()) R_UNLESS(GetCurrentProcess(system.Kernel())
.GetPageTable() .GetPageTable()
.CanContain(address, size, KMemoryState::Transfered), .CanContain(address, size, KMemoryState::Transferred),
ResultInvalidMemoryRegion); ResultInvalidMemoryRegion);
// Map the transfer memory. // 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. // Verify that the mapping is in range.
R_UNLESS(GetCurrentProcess(system.Kernel()) R_UNLESS(GetCurrentProcess(system.Kernel())
.GetPageTable() .GetPageTable()
.CanContain(address, size, KMemoryState::Transfered), .CanContain(address, size, KMemoryState::Transferred),
ResultInvalidMemoryRegion); ResultInvalidMemoryRegion);
// Unmap the transfer memory. // Unmap the transfer memory.

4
src/core/hle/kernel/svc_types.h
View File

@ -27,8 +27,8 @@ enum class MemoryState : u32 {
Ipc = 0x0A, Ipc = 0x0A,
Stack = 0x0B, Stack = 0x0B,
ThreadLocal = 0x0C, ThreadLocal = 0x0C,
Transfered = 0x0D, Transferred = 0x0D,
SharedTransfered = 0x0E, SharedTransferred = 0x0E,
SharedCode = 0x0F, SharedCode = 0x0F,
Inaccessible = 0x10, Inaccessible = 0x10,
NonSecureIpc = 0x11, NonSecureIpc = 0x11,

2
src/core/hle/service/am/applets/applet_profile_select.h
View File

@ -76,7 +76,7 @@ struct UiSettingsDisplayOptions {
bool is_system_or_launcher; bool is_system_or_launcher;
bool is_registration_permitted; bool is_registration_permitted;
bool show_skip_button; bool show_skip_button;
bool aditional_select; bool additional_select;
bool show_user_selector; bool show_user_selector;
bool is_unqualified_user_selectable; bool is_unqualified_user_selectable;
}; };

10
src/core/hle/service/caps/caps_manager.cpp
View File

@ -85,7 +85,7 @@ Result AlbumManager::GetAlbumFileList(std::vector<AlbumEntry>& out_entries, Albu
} }
Result AlbumManager::GetAlbumFileList(std::vector<ApplicationAlbumFileEntry>& out_entries, 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 { s64 end_posix_time, u64 aruid) const {
if (!is_mounted) { if (!is_mounted) {
return ResultIsNotMounted; return ResultIsNotMounted;
@ -94,7 +94,7 @@ Result AlbumManager::GetAlbumFileList(std::vector<ApplicationAlbumFileEntry>& ou
std::vector<ApplicationAlbumEntry> album_entries; std::vector<ApplicationAlbumEntry> album_entries;
const auto start_date = ConvertToAlbumDateTime(start_posix_time); const auto start_date = ConvertToAlbumDateTime(start_posix_time);
const auto end_date = ConvertToAlbumDateTime(end_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()) { if (result.IsError()) {
return result; return result;
@ -113,14 +113,14 @@ Result AlbumManager::GetAlbumFileList(std::vector<ApplicationAlbumFileEntry>& ou
} }
Result AlbumManager::GetAlbumFileList(std::vector<ApplicationAlbumEntry>& out_entries, 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 { AlbumFileDateTime end_date, u64 aruid) const {
if (!is_mounted) { if (!is_mounted) {
return ResultIsNotMounted; return ResultIsNotMounted;
} }
for (auto& [file_id, path] : album_files) { for (auto& [file_id, path] : album_files) {
if (file_id.type != contex_type) { if (file_id.type != content_type) {
continue; continue;
} }
if (file_id.date > start_date) { if (file_id.date > start_date) {
@ -139,7 +139,7 @@ Result AlbumManager::GetAlbumFileList(std::vector<ApplicationAlbumEntry>& out_en
.hash{}, .hash{},
.datetime = file_id.date, .datetime = file_id.date,
.storage = file_id.storage, .storage = file_id.storage,
.content = contex_type, .content = content_type,
.unknown = 1, .unknown = 1,
}; };
out_entries.push_back(entry); out_entries.push_back(entry);

4
src/core/hle/service/caps/caps_manager.h
View File

@ -45,10 +45,10 @@ public:
Result GetAlbumFileList(std::vector<AlbumEntry>& out_entries, AlbumStorage storage, Result GetAlbumFileList(std::vector<AlbumEntry>& out_entries, AlbumStorage storage,
u8 flags) const; u8 flags) const;
Result GetAlbumFileList(std::vector<ApplicationAlbumFileEntry>& out_entries, 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; u64 aruid) const;
Result GetAlbumFileList(std::vector<ApplicationAlbumEntry>& out_entries, 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; AlbumFileDateTime end_date, u64 aruid) const;
Result GetAutoSavingStorage(bool& out_is_autosaving) const; Result GetAutoSavingStorage(bool& out_is_autosaving) const;
Result LoadAlbumScreenShotImage(LoadAlbumScreenShotImageOutput& out_image_output, Result LoadAlbumScreenShotImage(LoadAlbumScreenShotImageOutput& out_image_output,

2
src/core/hle/service/caps/caps_result.h
View File

@ -12,7 +12,7 @@ constexpr Result ResultUnknown5(ErrorModule::Capture, 5);
constexpr Result ResultUnknown6(ErrorModule::Capture, 6); constexpr Result ResultUnknown6(ErrorModule::Capture, 6);
constexpr Result ResultUnknown7(ErrorModule::Capture, 7); constexpr Result ResultUnknown7(ErrorModule::Capture, 7);
constexpr Result ResultOutOfRange(ErrorModule::Capture, 8); 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 ResultInvalidStorage(ErrorModule::Capture, 13);
constexpr Result ResultInvalidFileContents(ErrorModule::Capture, 14); constexpr Result ResultInvalidFileContents(ErrorModule::Capture, 14);
constexpr Result ResultIsNotMounted(ErrorModule::Capture, 21); constexpr Result ResultIsNotMounted(ErrorModule::Capture, 21);

2
src/core/hle/service/friend/friend.cpp
View File

@ -131,7 +131,7 @@ private:
u8 is_favorite; u8 is_favorite;
u8 same_app; u8 same_app;
u8 same_app_played; u8 same_app_played;
u8 arbitary_app_played; u8 arbitrary_app_played;
u64 group_id; u64 group_id;
}; };
static_assert(sizeof(SizedFriendFilter) == 0x10, "SizedFriendFilter is an invalid size"); static_assert(sizeof(SizedFriendFilter) == 0x10, "SizedFriendFilter is an invalid size");

12
src/core/hle/service/hid/hid.cpp
View File

@ -18,23 +18,23 @@ namespace Service::HID {
void LoopProcess(Core::System& system) { void LoopProcess(Core::System& system) {
auto server_manager = std::make_unique<ServerManager>(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::shared_ptr<HidFirmwareSettings> firmware_settings =
std::make_shared<HidFirmwareSettings>(); std::make_shared<HidFirmwareSettings>();
// TODO: Remove this hack until this service is emulated properly. // TODO: Remove this hack until this service is emulated properly.
const auto process_list = system.Kernel().GetProcessList(); const auto process_list = system.Kernel().GetProcessList();
if (!process_list.empty()) { if (!process_list.empty()) {
resouce_manager->Initialize(); resource_manager->Initialize();
resouce_manager->RegisterAppletResourceUserId(process_list[0]->GetId(), true); resource_manager->RegisterAppletResourceUserId(process_list[0]->GetId(), true);
} }
server_manager->RegisterNamedService( 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( server_manager->RegisterNamedService(
"hid:dbg", std::make_shared<IHidDebugServer>(system, resouce_manager)); "hid:dbg", std::make_shared<IHidDebugServer>(system, resource_manager));
server_manager->RegisterNamedService( 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)); server_manager->RegisterNamedService("hidbus", std::make_shared<HidBus>(system));

8
src/core/hle/service/hid/hidbus.cpp
View File

@ -67,7 +67,7 @@ HidBus::~HidBus() {
void HidBus::UpdateHidbus(std::chrono::nanoseconds ns_late) { void HidBus::UpdateHidbus(std::chrono::nanoseconds ns_late) {
if (is_hidbus_enabled) { if (is_hidbus_enabled) {
for (std::size_t i = 0; i < devices.size(); ++i) { for (std::size_t i = 0; i < devices.size(); ++i) {
if (!devices[i].is_device_initializated) { if (!devices[i].is_device_initialized) {
continue; continue;
} }
auto& device = devices[i].device; 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) { if (bus_handle_.internal_index == 0 && Settings::values.enable_ring_controller) {
MakeDevice<RingController>(bus_handle_); 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(); devices[device_index.value()].device->ActivateDevice();
cur_entry.is_in_focus = true; cur_entry.is_in_focus = true;
cur_entry.is_connected = true; cur_entry.is_connected = true;
@ -222,7 +222,7 @@ void HidBus::Initialize(HLERequestContext& ctx) {
cur_entry.is_polling_mode = false; cur_entry.is_polling_mode = false;
} else { } else {
MakeDevice<HidbusStubbed>(bus_handle_); 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_in_focus = true;
cur_entry.is_connected = false; cur_entry.is_connected = false;
cur_entry.is_connected_result = ResultSuccess; 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; const auto entry_index = devices[device_index.value()].handle.internal_index;
auto& cur_entry = hidbus_status.entries[entry_index]; auto& cur_entry = hidbus_status.entries[entry_index];
auto& device = devices[device_index.value()].device; 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(); device->DeactivateDevice();
cur_entry.is_in_focus = true; cur_entry.is_in_focus = true;

2
src/core/hle/service/hid/hidbus.h
View File

@ -89,7 +89,7 @@ private:
static_assert(sizeof(HidbusStatusManager) <= 0x1000, "HidbusStatusManager is an invalid size"); static_assert(sizeof(HidbusStatusManager) <= 0x1000, "HidbusStatusManager is an invalid size");
struct HidbusDevice { struct HidbusDevice {
bool is_device_initializated{}; bool is_device_initialized{};
BusHandle handle{}; BusHandle handle{};
std::unique_ptr<HidbusBase> device{nullptr}; std::unique_ptr<HidbusBase> device{nullptr};
}; };

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

@ -181,22 +181,22 @@ void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
} }
} }
buffer_x_desciptors.reserve(command_header->num_buf_x_descriptors); buffer_x_descriptors.reserve(command_header->num_buf_x_descriptors);
buffer_a_desciptors.reserve(command_header->num_buf_a_descriptors); buffer_a_descriptors.reserve(command_header->num_buf_a_descriptors);
buffer_b_desciptors.reserve(command_header->num_buf_b_descriptors); buffer_b_descriptors.reserve(command_header->num_buf_b_descriptors);
buffer_w_desciptors.reserve(command_header->num_buf_w_descriptors); buffer_w_descriptors.reserve(command_header->num_buf_w_descriptors);
for (u32 i = 0; i < command_header->num_buf_x_descriptors; ++i) { 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) { 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) { 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) { 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; 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) { IPC::CommandHeader::BufferDescriptorCFlag::InlineDescriptor) {
if (command_header->buf_c_descriptor_flags == if (command_header->buf_c_descriptor_flags ==
IPC::CommandHeader::BufferDescriptorCFlag::OneDescriptor) { IPC::CommandHeader::BufferDescriptorCFlag::OneDescriptor) {
buffer_c_desciptors.push_back(rp.PopRaw<IPC::BufferDescriptorC>()); buffer_c_descriptors.push_back(rp.PopRaw<IPC::BufferDescriptorC>());
} else { } else {
u32 num_buf_c_descriptors = u32 num_buf_c_descriptors =
static_cast<u32>(command_header->buf_c_descriptor_flags.Value()) - 2; 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); ASSERT(num_buf_c_descriptors < 14);
for (u32 i = 0; i < num_buf_c_descriptors; ++i) { 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>());
} }
} }
} }

18
src/core/hle/service/hle_ipc.h
View File

@ -232,19 +232,19 @@ public:
} }
[[nodiscard]] const std::vector<IPC::BufferDescriptorX>& BufferDescriptorX() const { [[nodiscard]] const std::vector<IPC::BufferDescriptorX>& BufferDescriptorX() const {
return buffer_x_desciptors; return buffer_x_descriptors;
} }
[[nodiscard]] const std::vector<IPC::BufferDescriptorABW>& BufferDescriptorA() const { [[nodiscard]] const std::vector<IPC::BufferDescriptorABW>& BufferDescriptorA() const {
return buffer_a_desciptors; return buffer_a_descriptors;
} }
[[nodiscard]] const std::vector<IPC::BufferDescriptorABW>& BufferDescriptorB() const { [[nodiscard]] const std::vector<IPC::BufferDescriptorABW>& BufferDescriptorB() const {
return buffer_b_desciptors; return buffer_b_descriptors;
} }
[[nodiscard]] const std::vector<IPC::BufferDescriptorC>& BufferDescriptorC() const { [[nodiscard]] const std::vector<IPC::BufferDescriptorC>& BufferDescriptorC() const {
return buffer_c_desciptors; return buffer_c_descriptors;
} }
[[nodiscard]] const IPC::DomainMessageHeader& GetDomainMessageHeader() const { [[nodiscard]] const IPC::DomainMessageHeader& GetDomainMessageHeader() const {
@ -406,11 +406,11 @@ private:
std::optional<IPC::HandleDescriptorHeader> handle_descriptor_header; std::optional<IPC::HandleDescriptorHeader> handle_descriptor_header;
std::optional<IPC::DataPayloadHeader> data_payload_header; std::optional<IPC::DataPayloadHeader> data_payload_header;
std::optional<IPC::DomainMessageHeader> domain_message_header; std::optional<IPC::DomainMessageHeader> domain_message_header;
std::vector<IPC::BufferDescriptorX> buffer_x_desciptors; std::vector<IPC::BufferDescriptorX> buffer_x_descriptors;
std::vector<IPC::BufferDescriptorABW> buffer_a_desciptors; std::vector<IPC::BufferDescriptorABW> buffer_a_descriptors;
std::vector<IPC::BufferDescriptorABW> buffer_b_desciptors; std::vector<IPC::BufferDescriptorABW> buffer_b_descriptors;
std::vector<IPC::BufferDescriptorABW> buffer_w_desciptors; std::vector<IPC::BufferDescriptorABW> buffer_w_descriptors;
std::vector<IPC::BufferDescriptorC> buffer_c_desciptors; std::vector<IPC::BufferDescriptorC> buffer_c_descriptors;
u32_le command{}; u32_le command{};
u64 pid{}; u64 pid{};

10
src/core/hle/service/nfc/common/amiibo_crypto.cpp
View File

@ -19,7 +19,7 @@ namespace Service::NFP::AmiiboCrypto {
bool IsAmiiboValid(const EncryptedNTAG215File& ntag_file) { bool IsAmiiboValid(const EncryptedNTAG215File& ntag_file) {
const auto& amiibo_data = ntag_file.user_memory; 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, "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, "write_count={}", static_cast<u16>(amiibo_data.write_counter));
LOG_DEBUG(Service_NFP, "character_id=0x{0:x}", amiibo_data.model_info.character_id); 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) { if (ntag_file.static_lock != 0xE00F) {
return false; return false;
} }
if (ntag_file.compability_container != 0xEEFF10F1U) { if (ntag_file.compatibility_container != 0xEEFF10F1U) {
return false; return false;
} }
if (amiibo_data.model_info.tag_type != NFC::PackedTagType::Type2) { 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.uid_crc_check2 = nfc_data.uuid_crc_check2;
encoded_data.internal_number = nfc_data.internal_number; encoded_data.internal_number = nfc_data.internal_number;
encoded_data.static_lock = nfc_data.static_lock; 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.hmac_data = nfc_data.user_memory.hmac_data;
encoded_data.constant_value = nfc_data.user_memory.constant_value; encoded_data.constant_value = nfc_data.user_memory.constant_value;
encoded_data.write_counter = nfc_data.user_memory.write_counter; 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.uuid_crc_check2 = encoded_data.uid_crc_check2;
nfc_data.internal_number = encoded_data.internal_number; nfc_data.internal_number = encoded_data.internal_number;
nfc_data.static_lock = encoded_data.static_lock; 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.hmac_data = encoded_data.hmac_data;
nfc_data.user_memory.constant_value = encoded_data.constant_value; nfc_data.user_memory.constant_value = encoded_data.constant_value;
nfc_data.user_memory.write_counter = encoded_data.write_counter; 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.uid_crc_check2 = in_data.uid_crc_check2;
out_data.internal_number = in_data.internal_number; out_data.internal_number = in_data.internal_number;
out_data.static_lock = in_data.static_lock; 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.constant_value = in_data.constant_value;
out_data.write_counter = in_data.write_counter; out_data.write_counter = in_data.write_counter;

6
src/core/hle/service/nfc/common/device.cpp
View File

@ -75,7 +75,7 @@ void NfcDevice::NpadUpdate(Core::HID::ControllerTriggerType type) {
return; return;
} }
if (!is_initalized) { if (!is_initialized) {
return; return;
} }
@ -207,7 +207,7 @@ void NfcDevice::Initialize() {
return; return;
} }
is_initalized = npad_device->AddNfcHandle(); is_initialized = npad_device->AddNfcHandle();
} }
void NfcDevice::Finalize() { void NfcDevice::Finalize() {
@ -226,7 +226,7 @@ void NfcDevice::Finalize() {
} }
device_state = DeviceState::Unavailable; device_state = DeviceState::Unavailable;
is_initalized = false; is_initialized = false;
} }
Result NfcDevice::StartDetection(NfcProtocol allowed_protocol) { Result NfcDevice::StartDetection(NfcProtocol allowed_protocol) {

2
src/core/hle/service/nfc/common/device.h
View File

@ -126,7 +126,7 @@ private:
Kernel::KEvent* deactivate_event = nullptr; Kernel::KEvent* deactivate_event = nullptr;
Kernel::KEvent* availability_change_event = nullptr; Kernel::KEvent* availability_change_event = nullptr;
bool is_initalized{}; bool is_initialized{};
NfcProtocol allowed_protocols{}; NfcProtocol allowed_protocols{};
DeviceState device_state{DeviceState::Unavailable}; DeviceState device_state{DeviceState::Unavailable};

14
src/core/hle/service/nfp/nfp_types.h
View File

@ -243,12 +243,12 @@ static_assert(sizeof(EncryptedAmiiboFile) == 0x1F8, "AmiiboFile is an invalid si
struct NTAG215File { struct NTAG215File {
u8 uid_crc_check2; u8 uid_crc_check2;
u8 internal_number; u8 internal_number;
u16 static_lock; // Set defined pages as read only u16 static_lock; // Set defined pages as read only
u32 compability_container; // Defines available memory u32 compatibility_container; // Defines available memory
HashData hmac_data; // Hash HashData hmac_data; // Hash
u8 constant_value; // Must be A5 u8 constant_value; // Must be A5
u16_be write_counter; // Number of times the amiibo has been written? u16_be write_counter; // Number of times the amiibo has been written?
u8 amiibo_version; // Amiibo file version u8 amiibo_version; // Amiibo file version
AmiiboSettings settings; AmiiboSettings settings;
Service::Mii::Ver3StoreData owner_mii; // Mii data Service::Mii::Ver3StoreData owner_mii; // Mii data
u64_be application_id; // Game id u64_be application_id; // Game id
@ -278,7 +278,7 @@ struct EncryptedNTAG215File {
u8 uuid_crc_check2; u8 uuid_crc_check2;
u8 internal_number; u8 internal_number;
u16 static_lock; // Set defined pages as read only 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 EncryptedAmiiboFile user_memory; // Writable data
u32 dynamic_lock; // Dynamic lock u32 dynamic_lock; // Dynamic lock
u32 CFG0; // Defines memory protected by password u32 CFG0; // Defines memory protected by password

2
src/core/hle/service/nvdrv/devices/nvhost_as_gpu.h
View File

@ -90,7 +90,7 @@ private:
u64_le align; u64_le align;
}; };
}; };
static_assert(sizeof(IoctlAllocSpace) == 24, "IoctlInitalizeEx is incorrect size"); static_assert(sizeof(IoctlAllocSpace) == 24, "IoctlInitializeEx is incorrect size");
struct IoctlFreeSpace { struct IoctlFreeSpace {
u64_le offset{}; u64_le offset{};

2
src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp
View File

@ -15,7 +15,7 @@ namespace Service::Nvidia::Devices {
nvhost_ctrl_gpu::nvhost_ctrl_gpu(Core::System& system_, EventInterface& events_interface_) nvhost_ctrl_gpu::nvhost_ctrl_gpu(Core::System& system_, EventInterface& events_interface_)
: nvdevice{system_}, events_interface{events_interface_} { : nvdevice{system_}, events_interface{events_interface_} {
error_notifier_event = events_interface.CreateEvent("CtrlGpuErrorNotifier"); 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() { nvhost_ctrl_gpu::~nvhost_ctrl_gpu() {
events_interface.FreeEvent(error_notifier_event); events_interface.FreeEvent(error_notifier_event);

2
src/core/hle/service/nvdrv/nvdata.h
View File

@ -51,7 +51,7 @@ enum class NvResult : u32 {
DispNoDisplaysAttached = 0x20003, DispNoDisplaysAttached = 0x20003,
DispModeNotSupported = 0x20004, DispModeNotSupported = 0x20004,
DispNotFound = 0x20005, DispNotFound = 0x20005,
DispAttachDissallowed = 0x20006, DispAttachDisallowed = 0x20006,
DispTypeNotSupported = 0x20007, DispTypeNotSupported = 0x20007,
DispAuthenticationFailed = 0x20008, DispAuthenticationFailed = 0x20008,
DispNotAttached = 0x20009, DispNotAttached = 0x20009,

10
src/core/hle/service/pcv/pcv.cpp
View File

@ -54,8 +54,8 @@ public:
class IClkrstSession final : public ServiceFramework<IClkrstSession> { class IClkrstSession final : public ServiceFramework<IClkrstSession> {
public: public:
explicit IClkrstSession(Core::System& system_, DeviceCode deivce_code_) explicit IClkrstSession(Core::System& system_, DeviceCode device_code_)
: ServiceFramework{system_, "IClkrstSession"}, deivce_code(deivce_code_) { : ServiceFramework{system_, "IClkrstSession"}, device_code(device_code_) {
// clang-format off // clang-format off
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, nullptr, "SetClockEnabled"}, {0, nullptr, "SetClockEnabled"},
@ -93,7 +93,7 @@ private:
rb.Push<u32>(clock_rate); rb.Push<u32>(clock_rate);
} }
DeviceCode deivce_code; DeviceCode device_code;
u32 clock_rate{}; u32 clock_rate{};
}; };
@ -118,9 +118,9 @@ private:
void OpenSession(HLERequestContext& ctx) { void OpenSession(HLERequestContext& ctx) {
IPC::RequestParser rp{ctx}; IPC::RequestParser rp{ctx};
const auto device_code = static_cast<DeviceCode>(rp.Pop<u32>()); 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}; IPC::ResponseBuilder rb{ctx, 2, 0, 1};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);

2
src/core/hle/service/set/system_settings.cpp
View File

@ -28,7 +28,7 @@ SystemSettings DefaultSystemSettings() {
.cmu_mode = CmuMode::None, .cmu_mode = CmuMode::None,
.tv_underscan = {}, .tv_underscan = {},
.tv_gama = 1.0f, .tv_gama = 1.0f,
.constrast_ratio = 0.5f, .contrast_ratio = 0.5f,
}; };
settings.initial_launch_settings_packed = { settings.initial_launch_settings_packed = {

4
src/core/hle/service/set/system_settings.h
View File

@ -208,7 +208,7 @@ struct TvSettings {
CmuMode cmu_mode; CmuMode cmu_mode;
u32 tv_underscan; u32 tv_underscan;
f32 tv_gama; f32 tv_gama;
f32 constrast_ratio; f32 contrast_ratio;
}; };
static_assert(sizeof(TvSettings) == 0x20, "TvSettings is an invalid size"); static_assert(sizeof(TvSettings) == 0x20, "TvSettings is an invalid size");
@ -341,7 +341,7 @@ struct SystemSettings {
std::array<u8, 0x3C> reserved_09934; std::array<u8, 0x3C> reserved_09934;
// nn::settings::system::ErrorReportSharePermission // nn::settings::system::ErrorReportSharePermission
ErrorReportSharePermission error_report_share_permssion; ErrorReportSharePermission error_report_share_permission;
std::array<u8, 0x3C> reserved_09974; std::array<u8, 0x3C> reserved_09974;

10
src/core/hle/service/set/system_settings_server.cpp
View File

@ -721,10 +721,10 @@ void ISystemSettingsServer::SetTvSettings(HLERequestContext& ctx) {
SetSaveNeeded(); SetSaveNeeded();
LOG_INFO(Service_SET, 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={}", "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.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.hdmi_content_type,
m_system_settings.tv_settings.rgb_range, m_system_settings.tv_settings.tv_gama, m_system_settings.tv_settings.rgb_range, m_system_settings.tv_settings.tv_gama,
m_system_settings.tv_settings.tv_resolution, m_system_settings.tv_settings.tv_resolution,
@ -870,10 +870,10 @@ void ISystemSettingsServer::GetInitialLaunchSettings(HLERequestContext& ctx) {
void ISystemSettingsServer::SetInitialLaunchSettings(HLERequestContext& ctx) { void ISystemSettingsServer::SetInitialLaunchSettings(HLERequestContext& ctx) {
IPC::RequestParser rp{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.flags = initial_launch_settings.flags;
m_system_settings.initial_launch_settings_packed.timestamp = inital_launch_settings.timestamp; m_system_settings.initial_launch_settings_packed.timestamp = initial_launch_settings.timestamp;
SetSaveNeeded(); SetSaveNeeded();
LOG_INFO(Service_SET, "called, flags={}, timestamp={}", LOG_INFO(Service_SET, "called, flags={}, timestamp={}",