From b4d88a7bb406c033c3cd5c6bca6ce913fac1bcdd Mon Sep 17 00:00:00 2001 From: Narr the Reg Date: Wed, 7 Feb 2024 16:43:28 -0600 Subject: service: hid: Migrate hidbus to new interface --- src/core/hle/service/hid/hid.cpp | 2 +- src/core/hle/service/hid/hidbus.cpp | 481 ++++++++++++------------------------ src/core/hle/service/hid/hidbus.h | 69 ++++-- 3 files changed, 206 insertions(+), 346 deletions(-) (limited to 'src/core') diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp index b60fb9139..1fa9cfbfb 100644 --- a/src/core/hle/service/hid/hid.cpp +++ b/src/core/hle/service/hid/hid.cpp @@ -36,7 +36,7 @@ void LoopProcess(Core::System& system) { server_manager->RegisterNamedService( "hid:sys", std::make_shared(system, resource_manager, firmware_settings)); - server_manager->RegisterNamedService("hidbus", std::make_shared(system)); + server_manager->RegisterNamedService("hidbus", std::make_shared(system)); server_manager->RegisterNamedService("irs", std::make_shared(system)); server_manager->RegisterNamedService("irs:sys", std::make_shared(system)); diff --git a/src/core/hle/service/hid/hidbus.cpp b/src/core/hle/service/hid/hidbus.cpp index c903ee8b8..4fb002bc4 100644 --- a/src/core/hle/service/hid/hidbus.cpp +++ b/src/core/hle/service/hid/hidbus.cpp @@ -9,6 +9,7 @@ #include "core/hle/kernel/k_readable_event.h" #include "core/hle/kernel/k_shared_memory.h" #include "core/hle/kernel/k_transfer_memory.h" +#include "core/hle/service/cmif_serialization.h" #include "core/hle/service/hid/hidbus.h" #include "core/hle/service/ipc_helpers.h" #include "core/hle/service/service.h" @@ -22,25 +23,25 @@ namespace Service::HID { // (15ms, 66Hz) constexpr auto hidbus_update_ns = std::chrono::nanoseconds{15 * 1000 * 1000}; -HidBus::HidBus(Core::System& system_) +Hidbus::Hidbus(Core::System& system_) : ServiceFramework{system_, "hidbus"}, service_context{system_, service_name} { // clang-format off static const FunctionInfo functions[] = { - {1, &HidBus::GetBusHandle, "GetBusHandle"}, - {2, &HidBus::IsExternalDeviceConnected, "IsExternalDeviceConnected"}, - {3, &HidBus::Initialize, "Initialize"}, - {4, &HidBus::Finalize, "Finalize"}, - {5, &HidBus::EnableExternalDevice, "EnableExternalDevice"}, - {6, &HidBus::GetExternalDeviceId, "GetExternalDeviceId"}, - {7, &HidBus::SendCommandAsync, "SendCommandAsync"}, - {8, &HidBus::GetSendCommandAsynceResult, "GetSendCommandAsynceResult"}, - {9, &HidBus::SetEventForSendCommandAsycResult, "SetEventForSendCommandAsycResult"}, - {10, &HidBus::GetSharedMemoryHandle, "GetSharedMemoryHandle"}, - {11, &HidBus::EnableJoyPollingReceiveMode, "EnableJoyPollingReceiveMode"}, - {12, &HidBus::DisableJoyPollingReceiveMode, "DisableJoyPollingReceiveMode"}, + {1, C<&Hidbus::GetBusHandle>, "GetBusHandle"}, + {2, C<&Hidbus::IsExternalDeviceConnected>, "IsExternalDeviceConnected"}, + {3, C<&Hidbus::Initialize>, "Initialize"}, + {4, C<&Hidbus::Finalize>, "Finalize"}, + {5, C<&Hidbus::EnableExternalDevice>, "EnableExternalDevice"}, + {6, C<&Hidbus::GetExternalDeviceId>, "GetExternalDeviceId"}, + {7, C<&Hidbus::SendCommandAsync>, "SendCommandAsync"}, + {8, C<&Hidbus::GetSendCommandAsynceResult>, "GetSendCommandAsynceResult"}, + {9, C<&Hidbus::SetEventForSendCommandAsycResult>, "SetEventForSendCommandAsycResult"}, + {10, C<&Hidbus::GetSharedMemoryHandle>, "GetSharedMemoryHandle"}, + {11, C<&Hidbus::EnableJoyPollingReceiveMode>, "EnableJoyPollingReceiveMode"}, + {12, C<&Hidbus::DisableJoyPollingReceiveMode>, "DisableJoyPollingReceiveMode"}, {13, nullptr, "GetPollingData"}, - {14, &HidBus::SetStatusManagerType, "SetStatusManagerType"}, + {14, C<&Hidbus::SetStatusManagerType>, "SetStatusManagerType"}, }; // clang-format on @@ -60,11 +61,11 @@ HidBus::HidBus(Core::System& system_) hidbus_update_event); } -HidBus::~HidBus() { +Hidbus::~Hidbus() { system.CoreTiming().UnscheduleEvent(hidbus_update_event); } -void HidBus::UpdateHidbus(std::chrono::nanoseconds ns_late) { +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_initialized) { @@ -84,7 +85,7 @@ void HidBus::UpdateHidbus(std::chrono::nanoseconds ns_late) { } } -std::optional HidBus::GetDeviceIndexFromHandle(BusHandle handle) const { +std::optional Hidbus::GetDeviceIndexFromHandle(BusHandle handle) const { for (std::size_t i = 0; i < devices.size(); ++i) { const auto& device_handle = devices[i].handle; if (handle.abstracted_pad_id == device_handle.abstracted_pad_id && @@ -98,20 +99,11 @@ std::optional HidBus::GetDeviceIndexFromHandle(BusHandle handle) co return std::nullopt; } -void HidBus::GetBusHandle(HLERequestContext& ctx) { - IPC::RequestParser rp{ctx}; - struct Parameters { - Core::HID::NpadIdType npad_id; - INSERT_PADDING_WORDS_NOINIT(1); - BusType bus_type; - u64 applet_resource_user_id; - }; - static_assert(sizeof(Parameters) == 0x18, "Parameters has incorrect size."); - - const auto parameters{rp.PopRaw()}; - - LOG_INFO(Service_HID, "called, npad_id={}, bus_type={}, applet_resource_user_id={}", - parameters.npad_id, parameters.bus_type, parameters.applet_resource_user_id); +Result Hidbus::GetBusHandle(Out out_is_valid, Out out_bus_handle, + Core::HID::NpadIdType npad_id, BusType bus_type, + AppletResourceUserId aruid) { + LOG_INFO(Service_HID, "called, npad_id={}, bus_type={}, applet_resource_user_id={}", npad_id, + bus_type, aruid.pid); bool is_handle_found = 0; std::size_t handle_index = 0; @@ -121,8 +113,8 @@ void HidBus::GetBusHandle(HLERequestContext& ctx) { if (!handle.is_valid) { continue; } - if (static_cast(handle.player_number) == parameters.npad_id && - handle.bus_type_id == static_cast(parameters.bus_type)) { + if (handle.player_number.As() == npad_id && + handle.bus_type_id == static_cast(bus_type)) { is_handle_found = true; handle_index = i; break; @@ -135,388 +127,231 @@ void HidBus::GetBusHandle(HLERequestContext& ctx) { if (devices[i].handle.is_valid) { continue; } - devices[i].handle = { - .abstracted_pad_id = static_cast(i), - .internal_index = static_cast(i), - .player_number = static_cast(parameters.npad_id), - .bus_type_id = static_cast(parameters.bus_type), - .is_valid = true, - }; + devices[i].handle.raw = 0; + devices[i].handle.abstracted_pad_id.Assign(i); + devices[i].handle.internal_index.Assign(i); + devices[i].handle.player_number.Assign(static_cast(npad_id)); + devices[i].handle.bus_type_id.Assign(static_cast(bus_type)); + devices[i].handle.is_valid.Assign(true); handle_index = i; break; } } - struct OutData { - bool is_valid; - INSERT_PADDING_BYTES(7); - BusHandle handle; - }; - static_assert(sizeof(OutData) == 0x10, "OutData has incorrect size."); - - const OutData out_data{ - .is_valid = true, - .handle = devices[handle_index].handle, - }; - - IPC::ResponseBuilder rb{ctx, 6}; - rb.Push(ResultSuccess); - rb.PushRaw(out_data); + *out_is_valid = true; + *out_bus_handle = devices[handle_index].handle; + R_SUCCEED(); } -void HidBus::IsExternalDeviceConnected(HLERequestContext& ctx) { - IPC::RequestParser rp{ctx}; - const auto bus_handle_{rp.PopRaw()}; - +Result Hidbus::IsExternalDeviceConnected(Out out_is_connected, BusHandle bus_handle) { LOG_INFO(Service_HID, "Called, abstracted_pad_id={}, bus_type={}, internal_index={}, " "player_number={}, is_valid={}", - bus_handle_.abstracted_pad_id, bus_handle_.bus_type_id, bus_handle_.internal_index, - bus_handle_.player_number, bus_handle_.is_valid); + bus_handle.abstracted_pad_id, bus_handle.bus_type_id, bus_handle.internal_index, + bus_handle.player_number, bus_handle.is_valid); - const auto device_index = GetDeviceIndexFromHandle(bus_handle_); + const auto device_index = GetDeviceIndexFromHandle(bus_handle); - if (device_index) { - const auto& device = devices[device_index.value()].device; - const bool is_attached = device->IsDeviceActivated(); + R_UNLESS(device_index.has_value(), ResultUnknown); - IPC::ResponseBuilder rb{ctx, 3}; - rb.Push(ResultSuccess); - rb.Push(is_attached); - return; - } - - LOG_ERROR(Service_HID, "Invalid handle"); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultUnknown); - return; + *out_is_connected = devices[device_index.value()].device->IsDeviceActivated(); + R_SUCCEED(); } -void HidBus::Initialize(HLERequestContext& ctx) { - IPC::RequestParser rp{ctx}; - const auto bus_handle_{rp.PopRaw()}; - const auto applet_resource_user_id{rp.Pop()}; - +Result Hidbus::Initialize(BusHandle bus_handle, AppletResourceUserId aruid) { LOG_INFO(Service_HID, "called, abstracted_pad_id={} bus_type={} internal_index={} " "player_number={} is_valid={}, applet_resource_user_id={}", - bus_handle_.abstracted_pad_id, bus_handle_.bus_type_id, bus_handle_.internal_index, - bus_handle_.player_number, bus_handle_.is_valid, applet_resource_user_id); + bus_handle.abstracted_pad_id, bus_handle.bus_type_id, bus_handle.internal_index, + bus_handle.player_number, bus_handle.is_valid, aruid.pid); is_hidbus_enabled = true; - const auto device_index = GetDeviceIndexFromHandle(bus_handle_); - - if (device_index) { - const auto entry_index = devices[device_index.value()].handle.internal_index; - auto& cur_entry = hidbus_status.entries[entry_index]; - - if (bus_handle_.internal_index == 0 && Settings::values.enable_ring_controller) { - MakeDevice(bus_handle_); - 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; - cur_entry.is_connected_result = ResultSuccess; - cur_entry.is_enabled = false; - cur_entry.is_polling_mode = false; - } else { - MakeDevice(bus_handle_); - 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; - cur_entry.is_enabled = false; - cur_entry.is_polling_mode = false; - } - - std::memcpy(system.Kernel().GetHidBusSharedMem().GetPointer(), &hidbus_status, - sizeof(hidbus_status)); - - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultSuccess); - return; - } + const auto device_index = GetDeviceIndexFromHandle(bus_handle); - LOG_ERROR(Service_HID, "Invalid handle"); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultUnknown); - return; -} + R_UNLESS(device_index.has_value(), ResultUnknown); -void HidBus::Finalize(HLERequestContext& ctx) { - IPC::RequestParser rp{ctx}; - const auto bus_handle_{rp.PopRaw()}; - const auto applet_resource_user_id{rp.Pop()}; - - LOG_INFO(Service_HID, - "called, abstracted_pad_id={}, bus_type={}, internal_index={}, " - "player_number={}, is_valid={}, applet_resource_user_id={}", - bus_handle_.abstracted_pad_id, bus_handle_.bus_type_id, bus_handle_.internal_index, - bus_handle_.player_number, bus_handle_.is_valid, applet_resource_user_id); - - const auto device_index = GetDeviceIndexFromHandle(bus_handle_); - - if (device_index) { - 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_initialized = false; - device->DeactivateDevice(); + const auto entry_index = devices[device_index.value()].handle.internal_index; + auto& cur_entry = hidbus_status.entries[entry_index]; + if (bus_handle.internal_index == 0 && Settings::values.enable_ring_controller) { + MakeDevice(bus_handle); + 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; + cur_entry.is_connected_result = ResultSuccess; + cur_entry.is_enabled = false; + cur_entry.is_polling_mode = false; + } else { + MakeDevice(bus_handle); + 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; cur_entry.is_enabled = false; cur_entry.is_polling_mode = false; - std::memcpy(system.Kernel().GetHidBusSharedMem().GetPointer(), &hidbus_status, - sizeof(hidbus_status)); - - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultSuccess); - return; } - LOG_ERROR(Service_HID, "Invalid handle"); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultUnknown); - return; + std::memcpy(system.Kernel().GetHidBusSharedMem().GetPointer(), &hidbus_status, + sizeof(hidbus_status)); + R_SUCCEED(); } -void HidBus::EnableExternalDevice(HLERequestContext& ctx) { - IPC::RequestParser rp{ctx}; - struct Parameters { - bool enable; - INSERT_PADDING_BYTES_NOINIT(7); - BusHandle bus_handle; - u64 inval; - u64 applet_resource_user_id; - }; - static_assert(sizeof(Parameters) == 0x20, "Parameters has incorrect size."); - - const auto parameters{rp.PopRaw()}; +Result Hidbus::Finalize(BusHandle bus_handle, AppletResourceUserId aruid) { + LOG_INFO(Service_HID, + "called, abstracted_pad_id={}, bus_type={}, internal_index={}, " + "player_number={}, is_valid={}, applet_resource_user_id={}", + bus_handle.abstracted_pad_id, bus_handle.bus_type_id, bus_handle.internal_index, + bus_handle.player_number, bus_handle.is_valid, aruid.pid); + + const auto device_index = GetDeviceIndexFromHandle(bus_handle); + + R_UNLESS(device_index.has_value(), ResultUnknown); + + 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_initialized = false; + device->DeactivateDevice(); + + cur_entry.is_in_focus = true; + cur_entry.is_connected = false; + cur_entry.is_connected_result = ResultSuccess; + cur_entry.is_enabled = false; + cur_entry.is_polling_mode = false; + std::memcpy(system.Kernel().GetHidBusSharedMem().GetPointer(), &hidbus_status, + sizeof(hidbus_status)); + R_SUCCEED(); +} +Result Hidbus::EnableExternalDevice(bool is_enabled, BusHandle bus_handle, u64 inval, + AppletResourceUserId aruid) { LOG_DEBUG(Service_HID, "called, enable={}, abstracted_pad_id={}, bus_type={}, internal_index={}, " "player_number={}, is_valid={}, inval={}, applet_resource_user_id{}", - parameters.enable, parameters.bus_handle.abstracted_pad_id, - parameters.bus_handle.bus_type_id, parameters.bus_handle.internal_index, - parameters.bus_handle.player_number, parameters.bus_handle.is_valid, parameters.inval, - parameters.applet_resource_user_id); - - const auto device_index = GetDeviceIndexFromHandle(parameters.bus_handle); - - if (device_index) { - auto& device = devices[device_index.value()].device; - device->Enable(parameters.enable); + is_enabled, bus_handle.abstracted_pad_id, bus_handle.bus_type_id, + bus_handle.internal_index, bus_handle.player_number, bus_handle.is_valid, inval, + aruid.pid); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultSuccess); - return; - } + const auto device_index = GetDeviceIndexFromHandle(bus_handle); - LOG_ERROR(Service_HID, "Invalid handle"); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultUnknown); - return; + R_UNLESS(device_index.has_value(), ResultUnknown); + devices[device_index.value()].device->Enable(is_enabled); + R_SUCCEED(); } -void HidBus::GetExternalDeviceId(HLERequestContext& ctx) { - IPC::RequestParser rp{ctx}; - const auto bus_handle_{rp.PopRaw()}; - +Result Hidbus::GetExternalDeviceId(Out out_device_id, BusHandle bus_handle) { LOG_DEBUG(Service_HID, "called, abstracted_pad_id={}, bus_type={}, internal_index={}, player_number={}, " "is_valid={}", - bus_handle_.abstracted_pad_id, bus_handle_.bus_type_id, bus_handle_.internal_index, - bus_handle_.player_number, bus_handle_.is_valid); - - const auto device_index = GetDeviceIndexFromHandle(bus_handle_); - - if (device_index) { - const auto& device = devices[device_index.value()].device; - u32 device_id = device->GetDeviceId(); - IPC::ResponseBuilder rb{ctx, 3}; - rb.Push(ResultSuccess); - rb.Push(device_id); - return; - } + bus_handle.abstracted_pad_id, bus_handle.bus_type_id, bus_handle.internal_index, + bus_handle.player_number, bus_handle.is_valid); - LOG_ERROR(Service_HID, "Invalid handle"); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultUnknown); - return; -} + const auto device_index = GetDeviceIndexFromHandle(bus_handle); -void HidBus::SendCommandAsync(HLERequestContext& ctx) { - IPC::RequestParser rp{ctx}; - const auto data = ctx.ReadBuffer(); - const auto bus_handle_{rp.PopRaw()}; + R_UNLESS(device_index.has_value(), ResultUnknown); + *out_device_id = devices[device_index.value()].device->GetDeviceId(); + R_SUCCEED(); +} + +Result Hidbus::SendCommandAsync(BusHandle bus_handle, + InBuffer buffer_data) { LOG_DEBUG(Service_HID, "called, data_size={}, abstracted_pad_id={}, bus_type={}, internal_index={}, " "player_number={}, is_valid={}", - data.size(), bus_handle_.abstracted_pad_id, bus_handle_.bus_type_id, - bus_handle_.internal_index, bus_handle_.player_number, bus_handle_.is_valid); + buffer_data.size(), bus_handle.abstracted_pad_id, bus_handle.bus_type_id, + bus_handle.internal_index, bus_handle.player_number, bus_handle.is_valid); - const auto device_index = GetDeviceIndexFromHandle(bus_handle_); + const auto device_index = GetDeviceIndexFromHandle(bus_handle); - if (device_index) { - auto& device = devices[device_index.value()].device; - device->SetCommand(data); - - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultSuccess); - return; - } + R_UNLESS(device_index.has_value(), ResultUnknown); - LOG_ERROR(Service_HID, "Invalid handle"); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultUnknown); - return; + devices[device_index.value()].device->SetCommand(buffer_data); + R_SUCCEED(); }; -void HidBus::GetSendCommandAsynceResult(HLERequestContext& ctx) { - IPC::RequestParser rp{ctx}; - const auto bus_handle_{rp.PopRaw()}; - +Result Hidbus::GetSendCommandAsynceResult(Out out_data_size, BusHandle bus_handle, + OutBuffer out_buffer_data) { LOG_DEBUG(Service_HID, "called, abstracted_pad_id={}, bus_type={}, internal_index={}, player_number={}, " "is_valid={}", - bus_handle_.abstracted_pad_id, bus_handle_.bus_type_id, bus_handle_.internal_index, - bus_handle_.player_number, bus_handle_.is_valid); - - const auto device_index = GetDeviceIndexFromHandle(bus_handle_); + bus_handle.abstracted_pad_id, bus_handle.bus_type_id, bus_handle.internal_index, + bus_handle.player_number, bus_handle.is_valid); - if (device_index) { - const auto& device = devices[device_index.value()].device; - const std::vector data = device->GetReply(); - const u64 data_size = ctx.WriteBuffer(data); + const auto device_index = GetDeviceIndexFromHandle(bus_handle); - IPC::ResponseBuilder rb{ctx, 4}; - rb.Push(ResultSuccess); - rb.Push(data_size); - return; - } + R_UNLESS(device_index.has_value(), ResultUnknown); - LOG_ERROR(Service_HID, "Invalid handle"); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultUnknown); - return; + *out_data_size = devices[device_index.value()].device->GetReply(out_buffer_data); + R_SUCCEED(); }; -void HidBus::SetEventForSendCommandAsycResult(HLERequestContext& ctx) { - IPC::RequestParser rp{ctx}; - const auto bus_handle_{rp.PopRaw()}; - +Result Hidbus::SetEventForSendCommandAsycResult(OutCopyHandle out_event, + BusHandle bus_handle) { LOG_INFO(Service_HID, "called, abstracted_pad_id={}, bus_type={}, internal_index={}, player_number={}, " "is_valid={}", - bus_handle_.abstracted_pad_id, bus_handle_.bus_type_id, bus_handle_.internal_index, - bus_handle_.player_number, bus_handle_.is_valid); + bus_handle.abstracted_pad_id, bus_handle.bus_type_id, bus_handle.internal_index, + bus_handle.player_number, bus_handle.is_valid); - const auto device_index = GetDeviceIndexFromHandle(bus_handle_); + const auto device_index = GetDeviceIndexFromHandle(bus_handle); - if (device_index) { - const auto& device = devices[device_index.value()].device; - IPC::ResponseBuilder rb{ctx, 2, 1}; - rb.Push(ResultSuccess); - rb.PushCopyObjects(device->GetSendCommandAsycEvent()); - return; - } + R_UNLESS(device_index.has_value(), ResultUnknown); - LOG_ERROR(Service_HID, "Invalid handle"); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultUnknown); - return; + *out_event = &devices[device_index.value()].device->GetSendCommandAsycEvent(); + R_SUCCEED(); }; -void HidBus::GetSharedMemoryHandle(HLERequestContext& ctx) { +Result Hidbus::GetSharedMemoryHandle(OutCopyHandle out_shared_memory) { LOG_DEBUG(Service_HID, "called"); - IPC::ResponseBuilder rb{ctx, 2, 1}; - rb.Push(ResultSuccess); - rb.PushCopyObjects(&system.Kernel().GetHidBusSharedMem()); + *out_shared_memory = &system.Kernel().GetHidBusSharedMem(); + R_SUCCEED(); } -void HidBus::EnableJoyPollingReceiveMode(HLERequestContext& ctx) { - IPC::RequestParser rp{ctx}; - const auto t_mem_size{rp.Pop()}; - const auto t_mem_handle{ctx.GetCopyHandle(0)}; - const auto polling_mode_{rp.PopEnum()}; - const auto bus_handle_{rp.PopRaw()}; - +Result Hidbus::EnableJoyPollingReceiveMode(u32 t_mem_size, JoyPollingMode polling_mode, + BusHandle bus_handle, + InCopyHandle t_mem) { ASSERT_MSG(t_mem_size == 0x1000, "t_mem_size is not 0x1000 bytes"); - - auto t_mem = ctx.GetObjectFromHandle(t_mem_handle); - - if (t_mem.IsNull()) { - LOG_ERROR(Service_HID, "t_mem is a nullptr for handle=0x{:08X}", t_mem_handle); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultUnknown); - return; - } - - ASSERT_MSG(t_mem->GetSize() == 0x1000, "t_mem has incorrect size"); + ASSERT_MSG(t_mem->GetSize() == t_mem_size, "t_mem has incorrect size"); LOG_INFO(Service_HID, - "called, t_mem_handle=0x{:08X}, polling_mode={}, abstracted_pad_id={}, bus_type={}, " + "called, polling_mode={}, abstracted_pad_id={}, bus_type={}, " "internal_index={}, player_number={}, is_valid={}", - t_mem_handle, polling_mode_, bus_handle_.abstracted_pad_id, bus_handle_.bus_type_id, - bus_handle_.internal_index, bus_handle_.player_number, bus_handle_.is_valid); + polling_mode, bus_handle.abstracted_pad_id, bus_handle.bus_type_id, + bus_handle.internal_index, bus_handle.player_number, bus_handle.is_valid); - const auto device_index = GetDeviceIndexFromHandle(bus_handle_); + const auto device_index = GetDeviceIndexFromHandle(bus_handle); - if (device_index) { - auto& device = devices[device_index.value()].device; - device->SetPollingMode(polling_mode_); - device->SetTransferMemoryAddress(t_mem->GetSourceAddress()); + R_UNLESS(device_index.has_value(), ResultUnknown); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultSuccess); - return; - } - - LOG_ERROR(Service_HID, "Invalid handle"); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultUnknown); - return; + auto& device = devices[device_index.value()].device; + device->SetPollingMode(polling_mode); + device->SetTransferMemoryAddress(t_mem->GetSourceAddress()); + R_SUCCEED(); } -void HidBus::DisableJoyPollingReceiveMode(HLERequestContext& ctx) { - IPC::RequestParser rp{ctx}; - const auto bus_handle_{rp.PopRaw()}; - +Result Hidbus::DisableJoyPollingReceiveMode(BusHandle bus_handle) { LOG_INFO(Service_HID, "called, abstracted_pad_id={}, bus_type={}, internal_index={}, player_number={}, " "is_valid={}", - bus_handle_.abstracted_pad_id, bus_handle_.bus_type_id, bus_handle_.internal_index, - bus_handle_.player_number, bus_handle_.is_valid); + bus_handle.abstracted_pad_id, bus_handle.bus_type_id, bus_handle.internal_index, + bus_handle.player_number, bus_handle.is_valid); - const auto device_index = GetDeviceIndexFromHandle(bus_handle_); + const auto device_index = GetDeviceIndexFromHandle(bus_handle); - if (device_index) { - auto& device = devices[device_index.value()].device; - device->DisablePollingMode(); - - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultSuccess); - return; - } + R_UNLESS(device_index.has_value(), ResultUnknown); - LOG_ERROR(Service_HID, "Invalid handle"); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultUnknown); - return; + auto& device = devices[device_index.value()].device; + device->DisablePollingMode(); + R_SUCCEED(); } -void HidBus::SetStatusManagerType(HLERequestContext& ctx) { - IPC::RequestParser rp{ctx}; - const auto manager_type{rp.PopEnum()}; - +Result Hidbus::SetStatusManagerType(StatusManagerType manager_type) { LOG_WARNING(Service_HID, "(STUBBED) called, manager_type={}", manager_type); - - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultSuccess); + R_SUCCEED(); }; + } // namespace Service::HID diff --git a/src/core/hle/service/hid/hidbus.h b/src/core/hle/service/hid/hidbus.h index 03d9f6863..af4d95667 100644 --- a/src/core/hle/service/hid/hidbus.h +++ b/src/core/hle/service/hid/hidbus.h @@ -5,8 +5,10 @@ #include +#include "core/hle/service/cmif_types.h" #include "core/hle/service/kernel_helpers.h" #include "core/hle/service/service.h" +#include "hid_core/hid_types.h" #include "hid_core/hidbus/hidbus_base.h" namespace Core::Timing { @@ -19,10 +21,10 @@ class System; namespace Service::HID { -class HidBus final : public ServiceFramework { +class Hidbus final : public ServiceFramework { public: - explicit HidBus(Core::System& system_); - ~HidBus() override; + explicit Hidbus(Core::System& system_); + ~Hidbus() override; private: static const std::size_t max_number_of_handles = 0x13; @@ -41,7 +43,7 @@ private: }; // This is nn::hidbus::BusType - enum class BusType : u32 { + enum class BusType : u64 { LeftJoyRail, RightJoyRail, InternalBus, // Lark microphone @@ -51,11 +53,15 @@ private: // This is nn::hidbus::BusHandle struct BusHandle { - u32 abstracted_pad_id; - u8 internal_index; - u8 player_number; - u8 bus_type_id; - bool is_valid; + union { + u64 raw{}; + + BitField<0, 32, u64> abstracted_pad_id; + BitField<32, 8, u64> internal_index; + BitField<40, 8, u64> player_number; + BitField<48, 8, u64> bus_type_id; + BitField<56, 1, u64> is_valid; + }; }; static_assert(sizeof(BusHandle) == 0x8, "BusHandle is an invalid size"); @@ -94,19 +100,38 @@ private: std::unique_ptr device{nullptr}; }; - void GetBusHandle(HLERequestContext& ctx); - void IsExternalDeviceConnected(HLERequestContext& ctx); - void Initialize(HLERequestContext& ctx); - void Finalize(HLERequestContext& ctx); - void EnableExternalDevice(HLERequestContext& ctx); - void GetExternalDeviceId(HLERequestContext& ctx); - void SendCommandAsync(HLERequestContext& ctx); - void GetSendCommandAsynceResult(HLERequestContext& ctx); - void SetEventForSendCommandAsycResult(HLERequestContext& ctx); - void GetSharedMemoryHandle(HLERequestContext& ctx); - void EnableJoyPollingReceiveMode(HLERequestContext& ctx); - void DisableJoyPollingReceiveMode(HLERequestContext& ctx); - void SetStatusManagerType(HLERequestContext& ctx); + Result GetBusHandle(Out out_is_valid, Out out_bus_handle, + Core::HID::NpadIdType npad_id, BusType bus_type, + AppletResourceUserId aruid); + + Result IsExternalDeviceConnected(Out out_is_connected, BusHandle bus_handle); + + Result Initialize(BusHandle bus_handle, AppletResourceUserId aruid); + + Result Finalize(BusHandle bus_handle, AppletResourceUserId aruid); + + Result EnableExternalDevice(bool is_enabled, BusHandle bus_handle, u64 inval, + AppletResourceUserId aruid); + + Result GetExternalDeviceId(Out out_device_id, BusHandle bus_handle); + + Result SendCommandAsync(BusHandle bus_handle, InBuffer buffer_data); + + Result GetSendCommandAsynceResult(Out out_data_size, BusHandle bus_handle, + OutBuffer out_buffer_data); + + Result SetEventForSendCommandAsycResult(OutCopyHandle out_event, + BusHandle bus_handle); + + Result GetSharedMemoryHandle(OutCopyHandle out_shared_memory); + + Result EnableJoyPollingReceiveMode(u32 t_mem_size, JoyPollingMode polling_mode, + BusHandle bus_handle, + InCopyHandle t_mem); + + Result DisableJoyPollingReceiveMode(BusHandle bus_handle); + + Result SetStatusManagerType(StatusManagerType manager_type); void UpdateHidbus(std::chrono::nanoseconds ns_late); std::optional GetDeviceIndexFromHandle(BusHandle handle) const; -- cgit v1.2.3