eden-emu
/
eden
mirror of https://git.eden-emu.dev/eden-emu/eden.git
1
0
Fork 0
Code Releases Wiki Activity
Browse Source

more dangling pointer fixes

lizzie 5 days ago
parent
01352dceab
commit
41c39375df
6 changed files with 113 additions and 161 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 74
      src/core/hle/service/hid/hid_server.cpp
  2. 14
      src/core/hle/service/hid/hid_system_server.cpp
  3. 2
      src/hid_core/resource_manager.cpp
  4. 132
      src/hid_core/resources/npad/npad.cpp
  5. 46
      src/hid_core/resources/npad/npad.h
  6. 6
      src/hid_core/resources/npad/npad_resource.cpp

74
src/core/hle/service/hid/hid_server.cpp
View File

@ -650,8 +650,7 @@ Result IHidServer::SetSupportedNpadStyleSet(Core::HID::NpadStyleSet supported_st
LOG_DEBUG(Service_HID, "called, supported_style_set={}, applet_resource_user_id={}",
supported_style_set, aruid.pid);
R_TRY(
GetResourceManager()->GetNpad()->SetSupportedNpadStyleSet(aruid.pid, supported_style_set));
R_TRY(GetResourceManager()->GetNpad()->SetSupportedNpadStyleSet(system.Kernel(), aruid.pid, supported_style_set));
Core::HID::NpadStyleTag style_tag{supported_style_set};
const auto revision = GetResourceManager()->GetNpad()->GetRevision(aruid.pid);
@ -667,7 +666,7 @@ Result IHidServer::GetSupportedNpadStyleSet(Out<Core::HID::NpadStyleSet> out_sup
ClientAppletResourceUserId aruid) {
LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", aruid.pid);
R_RETURN(GetResourceManager()->GetNpad()->GetSupportedNpadStyleSet(aruid.pid,
R_RETURN(GetResourceManager()->GetNpad()->GetSupportedNpadStyleSet(system.Kernel(), aruid.pid,
*out_supported_style_set));
}
@ -677,7 +676,7 @@ Result IHidServer::SetSupportedNpadIdType(
LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", aruid.pid);
R_RETURN(
GetResourceManager()->GetNpad()->SetSupportedNpadIdType(aruid.pid, supported_npad_list));
GetResourceManager()->GetNpad()->SetSupportedNpadIdType(system.Kernel(), aruid.pid, supported_npad_list));
}
Result IHidServer::ActivateNpad(ClientAppletResourceUserId aruid) {
@ -708,7 +707,7 @@ Result IHidServer::AcquireNpadStyleSetUpdateEventHandle(
Result IHidServer::DisconnectNpad(Core::HID::NpadIdType npad_id, ClientAppletResourceUserId aruid) {
LOG_DEBUG(Service_HID, "called, npad_id={}, applet_resource_user_id={}", npad_id, aruid.pid);
R_RETURN(GetResourceManager()->GetNpad()->DisconnectNpad(aruid.pid, npad_id));
R_RETURN(GetResourceManager()->GetNpad()->DisconnectNpad(system.Kernel(), aruid.pid, npad_id));
}
Result IHidServer::GetPlayerLedPattern(Out<Core::HID::LedPattern> out_led_pattern,
@ -778,7 +777,7 @@ Result IHidServer::SetNpadJoyAssignmentModeSingleByDefault(Core::HID::NpadIdType
LOG_INFO(Service_HID, "called, npad_id={}, applet_resource_user_id={}", npad_id, aruid.pid);
Core::HID::NpadIdType new_npad_id{};
GetResourceManager()->GetNpad()->SetNpadMode(
GetResourceManager()->GetNpad()->SetNpadMode(system.Kernel(),
aruid.pid, new_npad_id, npad_id, NpadJoyDeviceType::Left, NpadJoyAssignmentMode::Single);
R_SUCCEED();
}
@ -790,7 +789,7 @@ Result IHidServer::SetNpadJoyAssignmentModeSingle(Core::HID::NpadIdType npad_id,
npad_id, aruid.pid, npad_joy_device_type);
Core::HID::NpadIdType new_npad_id{};
GetResourceManager()->GetNpad()->SetNpadMode(
GetResourceManager()->GetNpad()->SetNpadMode(system.Kernel(),
aruid.pid, new_npad_id, npad_id, npad_joy_device_type, NpadJoyAssignmentMode::Single);
R_SUCCEED();
}
@ -800,7 +799,7 @@ Result IHidServer::SetNpadJoyAssignmentModeDual(Core::HID::NpadIdType npad_id,
LOG_DEBUG(Service_HID, "called, npad_id={}, applet_resource_user_id={}", npad_id, aruid.pid);
Core::HID::NpadIdType new_npad_id{};
GetResourceManager()->GetNpad()->SetNpadMode(aruid.pid, new_npad_id, npad_id, {},
GetResourceManager()->GetNpad()->SetNpadMode(system.Kernel(), aruid.pid, new_npad_id, npad_id, {},
NpadJoyAssignmentMode::Dual);
R_SUCCEED();
}
@ -812,7 +811,7 @@ Result IHidServer::MergeSingleJoyAsDualJoy(Core::HID::NpadIdType npad_id_1,
npad_id_1, npad_id_2, aruid.pid);
R_RETURN(
GetResourceManager()->GetNpad()->MergeSingleJoyAsDualJoy(aruid.pid, npad_id_1, npad_id_2));
GetResourceManager()->GetNpad()->MergeSingleJoyAsDualJoy(system.Kernel(), aruid.pid, npad_id_1, npad_id_2));
}
Result IHidServer::StartLrAssignmentMode(ClientAppletResourceUserId aruid) {
@ -839,67 +838,40 @@ Result IHidServer::SetNpadHandheldActivationMode(ClientAppletResourceUserId arui
ASSERT_MSG(false, "Activation mode should be always None, Single or Dual");
R_SUCCEED();
}
R_RETURN(
GetResourceManager()->GetNpad()->SetNpadHandheldActivationMode(aruid.pid, activation_mode));
R_RETURN(GetResourceManager()->GetNpad()->SetNpadHandheldActivationMode(system.Kernel(), aruid.pid, activation_mode));
}
Result IHidServer::GetNpadHandheldActivationMode(
Out<NpadHandheldActivationMode> out_activation_mode, ClientAppletResourceUserId aruid) {
LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", aruid.pid);
R_RETURN(GetResourceManager()->GetNpad()->GetNpadHandheldActivationMode(aruid.pid,
*out_activation_mode));
R_RETURN(GetResourceManager()->GetNpad()->GetNpadHandheldActivationMode(system.Kernel(), aruid.pid, *out_activation_mode));
}
Result IHidServer::SwapNpadAssignment(Core::HID::NpadIdType npad_id_1,
Core::HID::NpadIdType npad_id_2,
ClientAppletResourceUserId aruid) {
LOG_DEBUG(Service_HID, "called, npad_id_1={}, npad_id_2={}, applet_resource_user_id={}",
npad_id_1, npad_id_2, aruid.pid);
R_RETURN(GetResourceManager()->GetNpad()->SwapNpadAssignment(aruid.pid, npad_id_1, npad_id_2))
Result IHidServer::SwapNpadAssignment(Core::HID::NpadIdType npad_id_1, Core::HID::NpadIdType npad_id_2, ClientAppletResourceUserId aruid) {
LOG_DEBUG(Service_HID, "called, npad_id_1={}, npad_id_2={}, applet_resource_user_id={}", npad_id_1, npad_id_2, aruid.pid);
R_RETURN(GetResourceManager()->GetNpad()->SwapNpadAssignment(system.Kernel(), aruid.pid, npad_id_1, npad_id_2))
}
Result IHidServer::IsUnintendedHomeButtonInputProtectionEnabled(Out<bool> out_is_enabled,
Core::HID::NpadIdType npad_id,
ClientAppletResourceUserId aruid) {
Result IHidServer::IsUnintendedHomeButtonInputProtectionEnabled(Out<bool> out_is_enabled, Core::HID::NpadIdType npad_id, ClientAppletResourceUserId aruid) {
LOG_INFO(Service_HID, "called, npad_id={}, applet_resource_user_id={}", npad_id, aruid.pid);
R_UNLESS(IsNpadIdValid(npad_id), ResultInvalidNpadId);
R_RETURN(GetResourceManager()->GetNpad()->IsUnintendedHomeButtonInputProtectionEnabled(
*out_is_enabled, aruid.pid, npad_id));
R_RETURN(GetResourceManager()->GetNpad()->IsUnintendedHomeButtonInputProtectionEnabled(*out_is_enabled, aruid.pid, npad_id));
}
Result IHidServer::EnableUnintendedHomeButtonInputProtection(bool is_enabled,
Core::HID::NpadIdType npad_id,
ClientAppletResourceUserId aruid) {
LOG_DEBUG(Service_HID, "called, is_enabled={}, npad_id={}, applet_resource_user_id={}",
is_enabled, npad_id, aruid.pid);
Result IHidServer::EnableUnintendedHomeButtonInputProtection(bool is_enabled, Core::HID::NpadIdType npad_id, ClientAppletResourceUserId aruid) {
LOG_DEBUG(Service_HID, "called, is_enabled={}, npad_id={}, applet_resource_user_id={}",is_enabled, npad_id, aruid.pid);
R_UNLESS(IsNpadIdValid(npad_id), ResultInvalidNpadId);
R_RETURN(GetResourceManager()->GetNpad()->EnableUnintendedHomeButtonInputProtection(
aruid.pid, npad_id, is_enabled));
R_RETURN(GetResourceManager()->GetNpad()->EnableUnintendedHomeButtonInputProtection(aruid.pid, npad_id, is_enabled));
}
Result IHidServer::SetNpadJoyAssignmentModeSingleWithDestination(
Out<bool> out_is_reassigned, Out<Core::HID::NpadIdType> out_new_npad_id,
Core::HID::NpadIdType npad_id, ClientAppletResourceUserId aruid,
NpadJoyDeviceType npad_joy_device_type) {
LOG_INFO(Service_HID, "called, npad_id={}, applet_resource_user_id={}, npad_joy_device_type={}",
npad_id, aruid.pid, npad_joy_device_type);
*out_is_reassigned = GetResourceManager()->GetNpad()->SetNpadMode(
aruid.pid, *out_new_npad_id, npad_id, npad_joy_device_type, NpadJoyAssignmentMode::Single);
Result IHidServer::SetNpadJoyAssignmentModeSingleWithDestination(Out<bool> out_is_reassigned, Out<Core::HID::NpadIdType> out_new_npad_id, Core::HID::NpadIdType npad_id, ClientAppletResourceUserId aruid, NpadJoyDeviceType npad_joy_device_type) {
LOG_INFO(Service_HID, "called, npad_id={}, applet_resource_user_id={}, npad_joy_device_type={}", npad_id, aruid.pid, npad_joy_device_type);
*out_is_reassigned = GetResourceManager()->GetNpad()->SetNpadMode(system.Kernel(), aruid.pid, *out_new_npad_id, npad_id, npad_joy_device_type, NpadJoyAssignmentMode::Single);
R_SUCCEED();
}
Result IHidServer::SetNpadAnalogStickUseCenterClamp(bool use_center_clamp,
ClientAppletResourceUserId aruid) {
LOG_INFO(Service_HID, "called, use_center_clamp={}, applet_resource_user_id={}",
use_center_clamp, aruid.pid);
Result IHidServer::SetNpadAnalogStickUseCenterClamp(bool use_center_clamp, ClientAppletResourceUserId aruid) {
LOG_INFO(Service_HID, "called, use_center_clamp={}, applet_resource_user_id={}", use_center_clamp, aruid.pid);
GetResourceManager()->GetNpad()->SetNpadAnalogStickUseCenterClamp(aruid.pid, use_center_clamp);
R_SUCCEED();
}

14
src/core/hle/service/hid/hid_system_server.cpp
View File

@ -281,7 +281,7 @@ void IHidSystemServer::ApplyNpadSystemCommonPolicy(HLERequestContext& ctx) {
LOG_INFO(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
GetResourceManager()->GetNpad()->ApplyNpadSystemCommonPolicy(applet_resource_user_id);
GetResourceManager()->GetNpad()->ApplyNpadSystemCommonPolicy(system.Kernel(), applet_resource_user_id);
IPC::ResponseBuilder rb{ctx, 2};
rb.Push(ResultSuccess);
@ -328,7 +328,7 @@ void IHidSystemServer::ApplyNpadSystemCommonPolicyFull(HLERequestContext& ctx) {
LOG_INFO(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
GetResourceManager()->GetNpad()->ApplyNpadSystemCommonPolicyFull(applet_resource_user_id);
GetResourceManager()->GetNpad()->ApplyNpadSystemCommonPolicyFull(system.Kernel(), applet_resource_user_id);
IPC::ResponseBuilder rb{ctx, 2};
rb.Push(ResultSuccess);
@ -358,9 +358,8 @@ void IHidSystemServer::GetMaskedSupportedNpadStyleSet(HLERequestContext& ctx) {
LOG_INFO(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
Core::HID::NpadStyleSet supported_styleset{};
const auto& npad = GetResourceManager()->GetNpad();
const Result result =
npad->GetMaskedSupportedNpadStyleSet(applet_resource_user_id, supported_styleset);
const auto npad = GetResourceManager()->GetNpad();
const Result result = npad->GetMaskedSupportedNpadStyleSet(system.Kernel(), applet_resource_user_id, supported_styleset);
IPC::ResponseBuilder rb{ctx, 3};
rb.Push(result);
@ -373,9 +372,8 @@ void IHidSystemServer::SetSupportedNpadStyleSetAll(HLERequestContext& ctx) {
LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
const auto& npad = GetResourceManager()->GetNpad();
const auto result =
npad->SetSupportedNpadStyleSet(applet_resource_user_id, Core::HID::NpadStyleSet::All);
const auto npad = GetResourceManager()->GetNpad();
const auto result = npad->SetSupportedNpadStyleSet(system.Kernel(), applet_resource_user_id, Core::HID::NpadStyleSet::All);
IPC::ResponseBuilder rb{ctx, 2};
rb.Push(result);

2
src/hid_core/resource_manager.cpp
View File

@ -486,7 +486,7 @@ void ResourceManager::UpdateControllers(std::chrono::nanoseconds ns_late) {
void ResourceManager::UpdateNpad(std::chrono::nanoseconds ns_late) {
auto& core_timing = system.CoreTiming();
npad->OnUpdate(core_timing);
npad->OnUpdate(system.Kernel(), core_timing);
}
void ResourceManager::UpdateMouseKeyboard(std::chrono::nanoseconds ns_late) {

132
src/hid_core/resources/npad/npad.cpp
View File

@ -50,8 +50,9 @@ NPad::NPad(Core::HID::HIDCore& hid_core_, KernelHelpers::ServiceContext& service
auto& controller = controller_data[aruid_index][i];
controller.device = hid_core.GetEmulatedControllerByIndex(i);
Core::HID::ControllerUpdateCallback engine_callback{
.on_change =
[this, i](Core::HID::ControllerTriggerType type) { ControllerUpdate(type, i); },
.on_change = [this, i](Core::HID::ControllerTriggerType type) {
ControllerUpdate(hid_core.kernel, type, i);
},
.is_npad_service = true,
};
controller.callback_key = controller.device->SetCallback(engine_callback);
@ -137,10 +138,10 @@ void NPad::FreeAppletResourceId(u64 aruid) {
return npad_resource.FreeAppletResourceId(aruid);
}
void NPad::ControllerUpdate(Core::HID::ControllerTriggerType type, std::size_t controller_idx) {
void NPad::ControllerUpdate(Kernel::KernelCore& kernel, Core::HID::ControllerTriggerType type, std::size_t controller_idx) {
if (type == Core::HID::ControllerTriggerType::All) {
ControllerUpdate(Core::HID::ControllerTriggerType::Connected, controller_idx);
ControllerUpdate(Core::HID::ControllerTriggerType::Battery, controller_idx);
ControllerUpdate(kernel, Core::HID::ControllerTriggerType::Connected, controller_idx);
ControllerUpdate(kernel, Core::HID::ControllerTriggerType::Battery, controller_idx);
return;
}
@ -165,7 +166,7 @@ void NPad::ControllerUpdate(Core::HID::ControllerTriggerType type, std::size_t c
if (is_connected == controller.is_connected) {
return;
}
UpdateControllerAt(data->aruid, npad_type, npad_id, is_connected);
UpdateControllerAt(kernel, data->aruid, npad_type, npad_id, is_connected);
break;
case Core::HID::ControllerTriggerType::Battery: {
if (!controller.device->IsConnected()) {
@ -187,7 +188,7 @@ void NPad::ControllerUpdate(Core::HID::ControllerTriggerType type, std::size_t c
}
}
void NPad::InitNewlyAddedController(u64 aruid, Core::HID::NpadIdType npad_id) {
void NPad::InitNewlyAddedController(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadIdType npad_id) {
auto& controller = GetControllerFromNpadIdType(aruid, npad_id);
if (!npad_resource.IsControllerSupported(aruid, controller.device->GetNpadStyleIndex())) {
return;
@ -202,7 +203,7 @@ void NPad::InitNewlyAddedController(u64 aruid, Core::HID::NpadIdType npad_id) {
return;
}
if (controller_type == Core::HID::NpadStyleIndex::None) {
npad_resource.SignalStyleSetUpdateEvent(hid_core.kernel, aruid, npad_id);
npad_resource.SignalStyleSetUpdateEvent(kernel, aruid, npad_id);
return;
}
@ -386,7 +387,7 @@ void NPad::InitNewlyAddedController(u64 aruid, Core::HID::NpadIdType npad_id) {
Common::Input::PollingMode::Active);
}
npad_resource.SignalStyleSetUpdateEvent(hid_core.kernel, aruid, npad_id);
npad_resource.SignalStyleSetUpdateEvent(kernel, aruid, npad_id);
WriteEmptyEntry(controller.shared_memory);
hid_core.SetLastActiveController(npad_id);
abstracted_pads[NpadIdTypeToIndex(npad_id)].Update();
@ -413,20 +414,20 @@ void NPad::WriteEmptyEntry(NpadInternalState* npad) {
npad->gc_trigger_lifo.WriteNextEntry(dummy_gc_state);
}
void NPad::RequestPadStateUpdate(u64 aruid, Core::HID::NpadIdType npad_id) {
void NPad::RequestPadStateUpdate(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadIdType npad_id) {
std::scoped_lock lock{*applet_resource_holder.shared_mutex};
auto& controller = GetControllerFromNpadIdType(aruid, npad_id);
const auto controller_type = controller.device->GetNpadStyleIndex();
if (!controller.device->IsConnected() && controller.is_connected) {
DisconnectNpad(aruid, npad_id);
DisconnectNpad(kernel, aruid, npad_id);
return;
}
if (!controller.device->IsConnected()) {
return;
}
if (controller.device->IsConnected() && !controller.is_connected) {
InitNewlyAddedController(aruid, npad_id);
InitNewlyAddedController(kernel, aruid, npad_id);
}
// This function is unique to yuzu for the turbo buttons and motion to work properly
@ -482,7 +483,7 @@ void NPad::RequestPadStateUpdate(u64 aruid, Core::HID::NpadIdType npad_id) {
}
}
void NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
void NPad::OnUpdate(Kernel::KernelCore& kernel, const Core::Timing::CoreTiming& core_timing) {
if (ref_counter == 0) {
return;
}
@ -524,7 +525,7 @@ void NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
continue;
}
RequestPadStateUpdate(aruid, controller.device->GetNpadIdType());
RequestPadStateUpdate(kernel, aruid, controller.device->GetNpadIdType());
auto& pad_state = controller.npad_pad_state;
auto& libnx_state = controller.npad_libnx_state;
auto& trigger_state = controller.npad_trigger_state;
@ -641,17 +642,17 @@ void NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
}
}
Result NPad::SetSupportedNpadStyleSet(u64 aruid, Core::HID::NpadStyleSet supported_style_set) {
Result NPad::SetSupportedNpadStyleSet(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadStyleSet supported_style_set) {
std::scoped_lock lock{mutex};
hid_core.SetSupportedStyleTag({supported_style_set});
const Result result = npad_resource.SetSupportedNpadStyleSet(aruid, supported_style_set);
if (result.IsSuccess()) {
OnUpdate({});
OnUpdate(kernel, {});
}
return result;
}
Result NPad::GetSupportedNpadStyleSet(u64 aruid,
Result NPad::GetSupportedNpadStyleSet(Kernel::KernelCore& kernel, u64 aruid,
Core::HID::NpadStyleSet& out_supported_style_set) const {
std::scoped_lock lock{mutex};
const Result result = npad_resource.GetSupportedNpadStyleSet(out_supported_style_set, aruid);
@ -664,8 +665,7 @@ Result NPad::GetSupportedNpadStyleSet(u64 aruid,
return result;
}
Result NPad::GetMaskedSupportedNpadStyleSet(
u64 aruid, Core::HID::NpadStyleSet& out_supported_style_set) const {
Result NPad::GetMaskedSupportedNpadStyleSet(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadStyleSet& out_supported_style_set) const {
std::scoped_lock lock{mutex};
const Result result =
npad_resource.GetMaskedSupportedNpadStyleSet(out_supported_style_set, aruid);
@ -678,8 +678,7 @@ Result NPad::GetMaskedSupportedNpadStyleSet(
return result;
}
Result NPad::SetSupportedNpadIdType(u64 aruid,
std::span<const Core::HID::NpadIdType> supported_npad_list) {
Result NPad::SetSupportedNpadIdType(Kernel::KernelCore& kernel, u64 aruid, std::span<const Core::HID::NpadIdType> supported_npad_list) {
std::scoped_lock lock{mutex};
if (supported_npad_list.size() > MaxSupportedNpadIdTypes) {
return ResultInvalidArraySize;
@ -688,7 +687,7 @@ Result NPad::SetSupportedNpadIdType(u64 aruid,
Result result = npad_resource.SetSupportedNpadIdType(aruid, supported_npad_list);
if (result.IsSuccess()) {
OnUpdate({});
OnUpdate(kernel, {});
}
return result;
@ -704,22 +703,21 @@ Result NPad::GetNpadJoyHoldType(u64 aruid, NpadJoyHoldType& out_hold_type) const
return npad_resource.GetNpadJoyHoldType(out_hold_type, aruid);
}
Result NPad::SetNpadHandheldActivationMode(u64 aruid, NpadHandheldActivationMode mode) {
Result NPad::SetNpadHandheldActivationMode(Kernel::KernelCore& kernel, u64 aruid, NpadHandheldActivationMode mode) {
std::scoped_lock lock{mutex};
Result result = npad_resource.SetNpadHandheldActivationMode(aruid, mode);
if (result.IsSuccess()) {
OnUpdate({});
OnUpdate(kernel, {});
}
return result;
}
Result NPad::GetNpadHandheldActivationMode(u64 aruid, NpadHandheldActivationMode& out_mode) const {
Result NPad::GetNpadHandheldActivationMode(Kernel::KernelCore& kernel, u64 aruid, NpadHandheldActivationMode& out_mode) const {
std::scoped_lock lock{mutex};
return npad_resource.GetNpadHandheldActivationMode(out_mode, aruid);
}
bool NPad::SetNpadMode(u64 aruid, Core::HID::NpadIdType& new_npad_id, Core::HID::NpadIdType npad_id,
NpadJoyDeviceType npad_device_type, NpadJoyAssignmentMode assignment_mode) {
bool NPad::SetNpadMode(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadIdType& new_npad_id, Core::HID::NpadIdType npad_id, NpadJoyDeviceType npad_device_type, NpadJoyAssignmentMode assignment_mode) {
if (!IsNpadIdValid(npad_id)) {
LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
return false;
@ -741,17 +739,17 @@ bool NPad::SetNpadMode(u64 aruid, Core::HID::NpadIdType& new_npad_id, Core::HID:
if (assignment_mode == NpadJoyAssignmentMode::Dual) {
if (controller.device->GetNpadStyleIndex() == Core::HID::NpadStyleIndex::JoyconLeft) {
DisconnectNpad(aruid, npad_id);
DisconnectNpad(kernel, aruid, npad_id);
controller.is_dual_left_connected = true;
controller.is_dual_right_connected = false;
UpdateControllerAt(aruid, Core::HID::NpadStyleIndex::JoyconDual, npad_id, true);
UpdateControllerAt(kernel, aruid, Core::HID::NpadStyleIndex::JoyconDual, npad_id, true);
return false;
}
if (controller.device->GetNpadStyleIndex() == Core::HID::NpadStyleIndex::JoyconRight) {
DisconnectNpad(aruid, npad_id);
DisconnectNpad(kernel, aruid, npad_id);
controller.is_dual_left_connected = false;
controller.is_dual_right_connected = true;
UpdateControllerAt(aruid, Core::HID::NpadStyleIndex::JoyconDual, npad_id, true);
UpdateControllerAt(kernel, aruid, Core::HID::NpadStyleIndex::JoyconDual, npad_id, true);
return false;
}
return false;
@ -765,30 +763,30 @@ bool NPad::SetNpadMode(u64 aruid, Core::HID::NpadIdType& new_npad_id, Core::HID:
}
if (controller.is_dual_left_connected && !controller.is_dual_right_connected) {
DisconnectNpad(aruid, npad_id);
UpdateControllerAt(aruid, Core::HID::NpadStyleIndex::JoyconLeft, npad_id, true);
DisconnectNpad(kernel, aruid, npad_id);
UpdateControllerAt(kernel, aruid, Core::HID::NpadStyleIndex::JoyconLeft, npad_id, true);
return false;
}
if (!controller.is_dual_left_connected && controller.is_dual_right_connected) {
DisconnectNpad(aruid, npad_id);
UpdateControllerAt(aruid, Core::HID::NpadStyleIndex::JoyconRight, npad_id, true);
DisconnectNpad(kernel, aruid, npad_id);
UpdateControllerAt(kernel, aruid, Core::HID::NpadStyleIndex::JoyconRight, npad_id, true);
return false;
}
// We have two controllers connected to the same npad_id we need to split them
new_npad_id = hid_core.GetFirstDisconnectedNpadId();
auto& controller_2 = GetControllerFromNpadIdType(aruid, new_npad_id);
DisconnectNpad(aruid, npad_id);
DisconnectNpad(kernel, aruid, npad_id);
if (npad_device_type == NpadJoyDeviceType::Left) {
UpdateControllerAt(aruid, Core::HID::NpadStyleIndex::JoyconLeft, npad_id, true);
UpdateControllerAt(kernel, aruid, Core::HID::NpadStyleIndex::JoyconLeft, npad_id, true);
controller_2.is_dual_left_connected = false;
controller_2.is_dual_right_connected = true;
UpdateControllerAt(aruid, Core::HID::NpadStyleIndex::JoyconDual, new_npad_id, true);
UpdateControllerAt(kernel, aruid, Core::HID::NpadStyleIndex::JoyconDual, new_npad_id, true);
} else {
UpdateControllerAt(aruid, Core::HID::NpadStyleIndex::JoyconRight, npad_id, true);
UpdateControllerAt(kernel, aruid, Core::HID::NpadStyleIndex::JoyconRight, npad_id, true);
controller_2.is_dual_left_connected = true;
controller_2.is_dual_right_connected = false;
UpdateControllerAt(aruid, Core::HID::NpadStyleIndex::JoyconDual, new_npad_id, true);
UpdateControllerAt(kernel, aruid, Core::HID::NpadStyleIndex::JoyconDual, new_npad_id, true);
}
return true;
}
@ -798,24 +796,22 @@ Result NPad::AcquireNpadStyleSetUpdateEventHandle(Kernel::KernelCore& kernel, u6
return npad_resource.AcquireNpadStyleSetUpdateEventHandle(kernel, aruid, out_event, npad_id);
}
void NPad::AddNewControllerAt(u64 aruid, Core::HID::NpadStyleIndex controller,
Core::HID::NpadIdType npad_id) {
UpdateControllerAt(aruid, controller, npad_id, true);
void NPad::AddNewControllerAt(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadStyleIndex controller, Core::HID::NpadIdType npad_id) {
UpdateControllerAt(kernel, aruid, controller, npad_id, true);
}
void NPad::UpdateControllerAt(u64 aruid, Core::HID::NpadStyleIndex type,
Core::HID::NpadIdType npad_id, bool connected) {
void NPad::UpdateControllerAt(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadStyleIndex type, Core::HID::NpadIdType npad_id, bool connected) {
auto& controller = GetControllerFromNpadIdType(aruid, npad_id);
if (!connected) {
DisconnectNpad(aruid, npad_id);
DisconnectNpad(kernel, aruid, npad_id);
return;
}
controller.device->SetNpadStyleIndex(type);
InitNewlyAddedController(aruid, npad_id);
InitNewlyAddedController(kernel, aruid, npad_id);
}
Result NPad::DisconnectNpad(u64 aruid, Core::HID::NpadIdType npad_id) {
Result NPad::DisconnectNpad(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadIdType npad_id) {
if (!IsNpadIdValid(npad_id)) {
LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
return ResultInvalidNpadId;
@ -858,7 +854,7 @@ Result NPad::DisconnectNpad(u64 aruid, Core::HID::NpadIdType npad_id) {
controller.is_dual_right_connected = true;
controller.is_connected = false;
controller.device->Disconnect();
npad_resource.SignalStyleSetUpdateEvent(hid_core.kernel, aruid, npad_id);
npad_resource.SignalStyleSetUpdateEvent(kernel, aruid, npad_id);
WriteEmptyEntry(shared_memory);
return ResultSuccess;
}
@ -891,8 +887,7 @@ Result NPad::ResetIsSixAxisSensorDeviceNewlyAssigned(
return ResultSuccess;
}
Result NPad::MergeSingleJoyAsDualJoy(u64 aruid, Core::HID::NpadIdType npad_id_1,
Core::HID::NpadIdType npad_id_2) {
Result NPad::MergeSingleJoyAsDualJoy(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadIdType npad_id_1, Core::HID::NpadIdType npad_id_2) {
if (!IsNpadIdValid(npad_id_1) || !IsNpadIdValid(npad_id_2)) {
LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id_1:{}, npad_id_2:{}", npad_id_1,
npad_id_2);
@ -946,11 +941,11 @@ Result NPad::MergeSingleJoyAsDualJoy(u64 aruid, Core::HID::NpadIdType npad_id_1,
}
// Disconnect the joycons and connect them as dual joycon at the first index.
DisconnectNpad(aruid, npad_id_1);
DisconnectNpad(aruid, npad_id_2);
DisconnectNpad(kernel, aruid, npad_id_1);
DisconnectNpad(kernel, aruid, npad_id_2);
controller_1.is_dual_left_connected = true;
controller_1.is_dual_right_connected = true;
AddNewControllerAt(aruid, Core::HID::NpadStyleIndex::JoyconDual, npad_id_1);
AddNewControllerAt(kernel, aruid, Core::HID::NpadStyleIndex::JoyconDual, npad_id_1);
return ResultSuccess;
}
@ -974,11 +969,9 @@ Result NPad::StopLrAssignmentMode(u64 aruid) {
return result;
}
Result NPad::SwapNpadAssignment(u64 aruid, Core::HID::NpadIdType npad_id_1,
Core::HID::NpadIdType npad_id_2) {
Result NPad::SwapNpadAssignment(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadIdType npad_id_1, Core::HID::NpadIdType npad_id_2) {
if (!IsNpadIdValid(npad_id_1) || !IsNpadIdValid(npad_id_2)) {
LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id_1:{}, npad_id_2:{}", npad_id_1,
npad_id_2);
LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id_1:{}, npad_id_2:{}", npad_id_1, npad_id_2);
return ResultInvalidNpadId;
}
if (npad_id_1 == Core::HID::NpadIdType::Handheld ||
@ -1000,20 +993,17 @@ Result NPad::SwapNpadAssignment(u64 aruid, Core::HID::NpadIdType npad_id_1,
return ResultNpadNotConnected;
}
UpdateControllerAt(aruid, type_index_2, npad_id_1, is_connected_2);
UpdateControllerAt(aruid, type_index_1, npad_id_2, is_connected_1);
UpdateControllerAt(kernel, aruid, type_index_2, npad_id_1, is_connected_2);
UpdateControllerAt(kernel, aruid, type_index_1, npad_id_2, is_connected_1);
return ResultSuccess;
}
Result NPad::IsUnintendedHomeButtonInputProtectionEnabled(bool& out_is_enabled, u64 aruid,
Core::HID::NpadIdType npad_id) const {
Result NPad::IsUnintendedHomeButtonInputProtectionEnabled(bool& out_is_enabled, u64 aruid, Core::HID::NpadIdType npad_id) const {
std::scoped_lock lock{mutex};
return npad_resource.GetHomeProtectionEnabled(out_is_enabled, aruid, npad_id);
}
Result NPad::EnableUnintendedHomeButtonInputProtection(u64 aruid, Core::HID::NpadIdType npad_id,
bool is_enabled) {
Result NPad::EnableUnintendedHomeButtonInputProtection(u64 aruid, Core::HID::NpadIdType npad_id, bool is_enabled) {
std::scoped_lock lock{mutex};
return npad_resource.SetHomeProtectionEnabled(aruid, npad_id, is_enabled);
}
@ -1067,29 +1057,29 @@ Core::HID::NpadButton NPad::GetAndResetPressState() {
return static_cast<Core::HID::NpadButton>(press_state.exchange(0));
}
Result NPad::ApplyNpadSystemCommonPolicy(u64 aruid) {
Result NPad::ApplyNpadSystemCommonPolicy(Kernel::KernelCore& kernel, u64 aruid) {
std::scoped_lock lock{mutex};
const Result result = npad_resource.ApplyNpadSystemCommonPolicy(aruid, false);
if (result.IsSuccess()) {
OnUpdate({});
OnUpdate(kernel, {});
}
return result;
}
Result NPad::ApplyNpadSystemCommonPolicyFull(u64 aruid) {
Result NPad::ApplyNpadSystemCommonPolicyFull(Kernel::KernelCore& kernel, u64 aruid) {
std::scoped_lock lock{mutex};
const Result result = npad_resource.ApplyNpadSystemCommonPolicy(aruid, true);
if (result.IsSuccess()) {
OnUpdate({});
OnUpdate(kernel, {});
}
return result;
}
Result NPad::ClearNpadSystemCommonPolicy(u64 aruid) {
Result NPad::ClearNpadSystemCommonPolicy(Kernel::KernelCore& kernel, u64 aruid) {
std::scoped_lock lock{mutex};
const Result result = npad_resource.ClearNpadSystemCommonPolicy(aruid);
if (result.IsSuccess()) {
OnUpdate({});
OnUpdate(kernel, {});
}
return result;
}

46
src/hid_core/resources/npad/npad.h
View File

@ -64,37 +64,31 @@ public:
void FreeAppletResourceId(u64 aruid);
// When the controller is requesting an update for the shared memory
void OnUpdate(const Core::Timing::CoreTiming& core_timing);
void OnUpdate(Kernel::KernelCore& kernel, const Core::Timing::CoreTiming& core_timing);
Result SetSupportedNpadStyleSet(u64 aruid, Core::HID::NpadStyleSet supported_style_set);
Result GetSupportedNpadStyleSet(u64 aruid,
Core::HID::NpadStyleSet& out_supported_style_set) const;
Result GetMaskedSupportedNpadStyleSet(u64 aruid,
Core::HID::NpadStyleSet& out_supported_style_set) const;
Result SetSupportedNpadIdType(u64 aruid,
std::span<const Core::HID::NpadIdType> supported_npad_list);
Result SetSupportedNpadStyleSet(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadStyleSet supported_style_set);
Result GetSupportedNpadStyleSet(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadStyleSet& out_supported_style_set) const;
Result GetMaskedSupportedNpadStyleSet(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadStyleSet& out_supported_style_set) const;
Result SetSupportedNpadIdType(Kernel::KernelCore& kernel, u64 aruid, std::span<const Core::HID::NpadIdType> supported_npad_list);
Result SetNpadJoyHoldType(u64 aruid, NpadJoyHoldType hold_type);
Result GetNpadJoyHoldType(u64 aruid, NpadJoyHoldType& out_hold_type) const;
Result SetNpadHandheldActivationMode(u64 aruid, NpadHandheldActivationMode mode);
Result GetNpadHandheldActivationMode(u64 aruid, NpadHandheldActivationMode& out_mode) const;
Result SetNpadHandheldActivationMode(Kernel::KernelCore& kernel, u64 aruid, NpadHandheldActivationMode mode);
Result GetNpadHandheldActivationMode(Kernel::KernelCore& kernel, u64 aruid, NpadHandheldActivationMode& out_mode) const;
bool SetNpadMode(u64 aruid, Core::HID::NpadIdType& new_npad_id, Core::HID::NpadIdType npad_id,
bool SetNpadMode(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadIdType& new_npad_id, Core::HID::NpadIdType npad_id,
NpadJoyDeviceType npad_device_type, NpadJoyAssignmentMode assignment_mode);
Result AcquireNpadStyleSetUpdateEventHandle(Kernel::KernelCore& kernel, u64 aruid, Kernel::KReadableEvent** out_event,
Core::HID::NpadIdType npad_id);
// Adds a new controller at an index.
void AddNewControllerAt(u64 aruid, Core::HID::NpadStyleIndex controller,
Core::HID::NpadIdType npad_id);
void AddNewControllerAt(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadStyleIndex controller, Core::HID::NpadIdType npad_id);
// Adds a new controller at an index with connection status.
void UpdateControllerAt(u64 aruid, Core::HID::NpadStyleIndex controller,
Core::HID::NpadIdType npad_id, bool connected);
void UpdateControllerAt(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadStyleIndex controller, Core::HID::NpadIdType npad_id, bool connected);
Result DisconnectNpad(u64 aruid, Core::HID::NpadIdType npad_id);
Result DisconnectNpad(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadIdType npad_id);
Result IsFirmwareUpdateAvailableForSixAxisSensor(
u64 aruid, const Core::HID::SixAxisSensorHandle& sixaxis_handle,
@ -113,20 +107,18 @@ public:
void ConnectAllDisconnectedControllers();
void ClearAllControllers();
Result MergeSingleJoyAsDualJoy(u64 aruid, Core::HID::NpadIdType npad_id_1,
Core::HID::NpadIdType npad_id_2);
Result MergeSingleJoyAsDualJoy(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadIdType npad_id_1, Core::HID::NpadIdType npad_id_2);
Result StartLrAssignmentMode(u64 aruid);
Result StopLrAssignmentMode(u64 aruid);
Result SwapNpadAssignment(u64 aruid, Core::HID::NpadIdType npad_id_1,
Core::HID::NpadIdType npad_id_2);
Result SwapNpadAssignment(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadIdType npad_id_1, Core::HID::NpadIdType npad_id_2);
// Logical OR for all buttons presses on all controllers
// Specifically for cheat engine and other features.
Core::HID::NpadButton GetAndResetPressState();
Result ApplyNpadSystemCommonPolicy(u64 aruid);
Result ApplyNpadSystemCommonPolicyFull(u64 aruid);
Result ClearNpadSystemCommonPolicy(u64 aruid);
Result ApplyNpadSystemCommonPolicy(Kernel::KernelCore& kernel, u64 aruid);
Result ApplyNpadSystemCommonPolicyFull(Kernel::KernelCore& kernel, u64 aruid);
Result ClearNpadSystemCommonPolicy(Kernel::KernelCore& kernel, u64 aruid);
void SetRevision(u64 aruid, NpadRevision revision);
NpadRevision GetRevision(u64 aruid);
@ -183,9 +175,9 @@ private:
int callback_key{};
};
void ControllerUpdate(Core::HID::ControllerTriggerType type, std::size_t controller_idx);
void InitNewlyAddedController(u64 aruid, Core::HID::NpadIdType npad_id);
void RequestPadStateUpdate(u64 aruid, Core::HID::NpadIdType npad_id);
void ControllerUpdate(Kernel::KernelCore& kernel, Core::HID::ControllerTriggerType type, std::size_t controller_idx);
void InitNewlyAddedController(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadIdType npad_id);
void RequestPadStateUpdate(Kernel::KernelCore& kernel, u64 aruid, Core::HID::NpadIdType npad_id);
void WriteEmptyEntry(NpadInternalState* npad);
NpadControllerData& GetControllerFromHandle(

6
src/hid_core/resources/npad/npad_resource.cpp
View File

@ -537,9 +537,9 @@ Result NPadResource::SignalStyleSetUpdateEvent(Kernel::KernelCore& kernel, u64 a
if (aruid_index >= AruidIndexMax) {
return ResultNpadNotConnected;
}
auto controller = state[aruid_index].controller_state[NpadIdTypeToIndex(npad_id)];
if (controller.is_styleset_update_event_initialized) {
controller.style_set_update_event->Signal(kernel);
auto& controller_state = state[aruid_index].controller_state[NpadIdTypeToIndex(npad_id)];
if (controller_state.is_styleset_update_event_initialized) {
controller_state.style_set_update_event->Signal(kernel);
}
return ResultSuccess;
}

Write Preview
Loading…
Cancel
Save