mirror of https://git.h3cjp.net/H3cJP/yuzu.git
504 lines
18 KiB
C++
504 lines
18 KiB
C++
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
|
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
|
|
#include "common/logging/log.h"
|
|
#include "core/core.h"
|
|
#include "core/core_timing.h"
|
|
#include "core/hle/service/ipc_helpers.h"
|
|
#include "core/hle/service/set/system_settings_server.h"
|
|
#include "core/hle/service/sm/sm.h"
|
|
#include "hid_core/hid_core.h"
|
|
#include "hid_core/hid_util.h"
|
|
#include "hid_core/resource_manager.h"
|
|
|
|
#include "hid_core/resources/applet_resource.h"
|
|
#include "hid_core/resources/debug_pad/debug_pad.h"
|
|
#include "hid_core/resources/digitizer/digitizer.h"
|
|
#include "hid_core/resources/hid_firmware_settings.h"
|
|
#include "hid_core/resources/keyboard/keyboard.h"
|
|
#include "hid_core/resources/mouse/debug_mouse.h"
|
|
#include "hid_core/resources/mouse/mouse.h"
|
|
#include "hid_core/resources/npad/npad.h"
|
|
#include "hid_core/resources/palma/palma.h"
|
|
#include "hid_core/resources/shared_memory_format.h"
|
|
#include "hid_core/resources/six_axis/console_six_axis.h"
|
|
#include "hid_core/resources/six_axis/seven_six_axis.h"
|
|
#include "hid_core/resources/six_axis/six_axis.h"
|
|
#include "hid_core/resources/system_buttons/capture_button.h"
|
|
#include "hid_core/resources/system_buttons/home_button.h"
|
|
#include "hid_core/resources/system_buttons/sleep_button.h"
|
|
#include "hid_core/resources/touch_screen/gesture.h"
|
|
#include "hid_core/resources/touch_screen/touch_screen.h"
|
|
#include "hid_core/resources/touch_screen/touch_screen_driver.h"
|
|
#include "hid_core/resources/touch_screen/touch_screen_resource.h"
|
|
#include "hid_core/resources/unique_pad/unique_pad.h"
|
|
#include "hid_core/resources/vibration/gc_vibration_device.h"
|
|
#include "hid_core/resources/vibration/n64_vibration_device.h"
|
|
#include "hid_core/resources/vibration/vibration_base.h"
|
|
#include "hid_core/resources/vibration/vibration_device.h"
|
|
|
|
namespace Service::HID {
|
|
|
|
// Updating period for each HID device.
|
|
// Period time is obtained by measuring the number of samples in a second on HW using a homebrew
|
|
// Correct npad_update_ns is 4ms this is overclocked to lower input lag
|
|
constexpr auto npad_update_ns = std::chrono::nanoseconds{1 * 1000 * 1000}; // (1ms, 1000Hz)
|
|
constexpr auto default_update_ns = std::chrono::nanoseconds{4 * 1000 * 1000}; // (4ms, 1000Hz)
|
|
constexpr auto mouse_keyboard_update_ns = std::chrono::nanoseconds{8 * 1000 * 1000}; // (8ms, 125Hz)
|
|
constexpr auto motion_update_ns = std::chrono::nanoseconds{5 * 1000 * 1000}; // (5ms, 200Hz)
|
|
|
|
ResourceManager::ResourceManager(Core::System& system_,
|
|
std::shared_ptr<HidFirmwareSettings> settings)
|
|
: firmware_settings{settings}, system{system_}, service_context{system_, "hid"} {
|
|
applet_resource = std::make_shared<AppletResource>(system);
|
|
|
|
// Register update callbacks
|
|
npad_update_event = Core::Timing::CreateEvent("HID::UpdatePadCallback",
|
|
[this](s64 time, std::chrono::nanoseconds ns_late)
|
|
-> std::optional<std::chrono::nanoseconds> {
|
|
UpdateNpad(ns_late);
|
|
return std::nullopt;
|
|
});
|
|
default_update_event = Core::Timing::CreateEvent(
|
|
"HID::UpdateDefaultCallback",
|
|
[this](s64 time,
|
|
std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
|
|
UpdateControllers(ns_late);
|
|
return std::nullopt;
|
|
});
|
|
mouse_keyboard_update_event = Core::Timing::CreateEvent(
|
|
"HID::UpdateMouseKeyboardCallback",
|
|
[this](s64 time,
|
|
std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
|
|
UpdateMouseKeyboard(ns_late);
|
|
return std::nullopt;
|
|
});
|
|
motion_update_event = Core::Timing::CreateEvent(
|
|
"HID::UpdateMotionCallback",
|
|
[this](s64 time,
|
|
std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
|
|
UpdateMotion(ns_late);
|
|
return std::nullopt;
|
|
});
|
|
}
|
|
|
|
ResourceManager::~ResourceManager() {
|
|
system.CoreTiming().UnscheduleEvent(npad_update_event);
|
|
system.CoreTiming().UnscheduleEvent(default_update_event);
|
|
system.CoreTiming().UnscheduleEvent(mouse_keyboard_update_event);
|
|
system.CoreTiming().UnscheduleEvent(motion_update_event);
|
|
system.CoreTiming().UnscheduleEvent(touch_update_event);
|
|
input_event->Finalize();
|
|
};
|
|
|
|
void ResourceManager::Initialize() {
|
|
if (is_initialized) {
|
|
return;
|
|
}
|
|
|
|
system.HIDCore().ReloadInputDevices();
|
|
|
|
input_event = service_context.CreateEvent("ResourceManager:InputEvent");
|
|
|
|
InitializeHandheldConfig();
|
|
InitializeHidCommonSampler();
|
|
InitializeTouchScreenSampler();
|
|
InitializeConsoleSixAxisSampler();
|
|
InitializeAHidSampler();
|
|
|
|
is_initialized = true;
|
|
}
|
|
|
|
std::shared_ptr<AppletResource> ResourceManager::GetAppletResource() const {
|
|
return applet_resource;
|
|
}
|
|
|
|
std::shared_ptr<CaptureButton> ResourceManager::GetCaptureButton() const {
|
|
return capture_button;
|
|
}
|
|
|
|
std::shared_ptr<ConsoleSixAxis> ResourceManager::GetConsoleSixAxis() const {
|
|
return console_six_axis;
|
|
}
|
|
|
|
std::shared_ptr<DebugMouse> ResourceManager::GetDebugMouse() const {
|
|
return debug_mouse;
|
|
}
|
|
|
|
std::shared_ptr<DebugPad> ResourceManager::GetDebugPad() const {
|
|
return debug_pad;
|
|
}
|
|
|
|
std::shared_ptr<Digitizer> ResourceManager::GetDigitizer() const {
|
|
return digitizer;
|
|
}
|
|
|
|
std::shared_ptr<Gesture> ResourceManager::GetGesture() const {
|
|
return gesture;
|
|
}
|
|
|
|
std::shared_ptr<HomeButton> ResourceManager::GetHomeButton() const {
|
|
return home_button;
|
|
}
|
|
|
|
std::shared_ptr<Keyboard> ResourceManager::GetKeyboard() const {
|
|
return keyboard;
|
|
}
|
|
|
|
std::shared_ptr<Mouse> ResourceManager::GetMouse() const {
|
|
return mouse;
|
|
}
|
|
|
|
std::shared_ptr<NPad> ResourceManager::GetNpad() const {
|
|
return npad;
|
|
}
|
|
|
|
std::shared_ptr<Palma> ResourceManager::GetPalma() const {
|
|
return palma;
|
|
}
|
|
|
|
std::shared_ptr<SevenSixAxis> ResourceManager::GetSevenSixAxis() const {
|
|
return seven_six_axis;
|
|
}
|
|
|
|
std::shared_ptr<SixAxis> ResourceManager::GetSixAxis() const {
|
|
return six_axis;
|
|
}
|
|
|
|
std::shared_ptr<SleepButton> ResourceManager::GetSleepButton() const {
|
|
return sleep_button;
|
|
}
|
|
|
|
std::shared_ptr<TouchScreen> ResourceManager::GetTouchScreen() const {
|
|
return touch_screen;
|
|
}
|
|
|
|
std::shared_ptr<UniquePad> ResourceManager::GetUniquePad() const {
|
|
return unique_pad;
|
|
}
|
|
|
|
Result ResourceManager::CreateAppletResource(u64 aruid) {
|
|
if (aruid == SystemAruid) {
|
|
const auto result = RegisterCoreAppletResource();
|
|
if (result.IsError()) {
|
|
return result;
|
|
}
|
|
return GetNpad()->ActivateNpadResource();
|
|
}
|
|
|
|
const auto result = CreateAppletResourceImpl(aruid);
|
|
if (result.IsError()) {
|
|
return result;
|
|
}
|
|
|
|
// Homebrew doesn't try to activate some controllers, so we activate them by default
|
|
npad->Activate();
|
|
six_axis->Activate();
|
|
touch_screen->Activate();
|
|
gesture->Activate();
|
|
|
|
return GetNpad()->ActivateNpadResource(aruid);
|
|
}
|
|
|
|
Result ResourceManager::CreateAppletResourceImpl(u64 aruid) {
|
|
std::scoped_lock lock{shared_mutex};
|
|
return applet_resource->CreateAppletResource(aruid);
|
|
}
|
|
|
|
void ResourceManager::InitializeHandheldConfig() {
|
|
handheld_config = std::make_shared<HandheldConfig>();
|
|
handheld_config->is_handheld_hid_enabled = true;
|
|
handheld_config->is_joycon_rail_enabled = true;
|
|
handheld_config->is_force_handheld_style_vibration = false;
|
|
handheld_config->is_force_handheld = false;
|
|
if (firmware_settings->IsHandheldForced()) {
|
|
handheld_config->is_joycon_rail_enabled = false;
|
|
}
|
|
}
|
|
|
|
void ResourceManager::InitializeHidCommonSampler() {
|
|
debug_pad = std::make_shared<DebugPad>(system.HIDCore());
|
|
mouse = std::make_shared<Mouse>(system.HIDCore());
|
|
debug_mouse = std::make_shared<DebugMouse>(system.HIDCore());
|
|
keyboard = std::make_shared<Keyboard>(system.HIDCore());
|
|
unique_pad = std::make_shared<UniquePad>(system.HIDCore());
|
|
npad = std::make_shared<NPad>(system.HIDCore(), service_context);
|
|
home_button = std::make_shared<HomeButton>(system.HIDCore());
|
|
sleep_button = std::make_shared<SleepButton>(system.HIDCore());
|
|
capture_button = std::make_shared<CaptureButton>(system.HIDCore());
|
|
digitizer = std::make_shared<Digitizer>(system.HIDCore());
|
|
|
|
palma = std::make_shared<Palma>(system.HIDCore(), service_context);
|
|
six_axis = std::make_shared<SixAxis>(system.HIDCore(), npad);
|
|
|
|
debug_pad->SetAppletResource(applet_resource, &shared_mutex);
|
|
digitizer->SetAppletResource(applet_resource, &shared_mutex);
|
|
unique_pad->SetAppletResource(applet_resource, &shared_mutex);
|
|
keyboard->SetAppletResource(applet_resource, &shared_mutex);
|
|
|
|
const auto settings =
|
|
system.ServiceManager().GetService<Service::Set::ISystemSettingsServer>("set:sys", true);
|
|
npad->SetNpadExternals(applet_resource, &shared_mutex, handheld_config, input_event,
|
|
&input_mutex, settings);
|
|
|
|
six_axis->SetAppletResource(applet_resource, &shared_mutex);
|
|
mouse->SetAppletResource(applet_resource, &shared_mutex);
|
|
debug_mouse->SetAppletResource(applet_resource, &shared_mutex);
|
|
home_button->SetAppletResource(applet_resource, &shared_mutex);
|
|
sleep_button->SetAppletResource(applet_resource, &shared_mutex);
|
|
capture_button->SetAppletResource(applet_resource, &shared_mutex);
|
|
|
|
system.CoreTiming().ScheduleLoopingEvent(npad_update_ns, npad_update_ns, npad_update_event);
|
|
system.CoreTiming().ScheduleLoopingEvent(default_update_ns, default_update_ns,
|
|
default_update_event);
|
|
system.CoreTiming().ScheduleLoopingEvent(mouse_keyboard_update_ns, mouse_keyboard_update_ns,
|
|
mouse_keyboard_update_event);
|
|
system.CoreTiming().ScheduleLoopingEvent(motion_update_ns, motion_update_ns,
|
|
motion_update_event);
|
|
}
|
|
|
|
void ResourceManager::InitializeTouchScreenSampler() {
|
|
// This is nn.hid.TouchScreenSampler
|
|
touch_resource = std::make_shared<TouchResource>(system);
|
|
touch_driver = std::make_shared<TouchDriver>(system.HIDCore());
|
|
touch_screen = std::make_shared<TouchScreen>(touch_resource);
|
|
gesture = std::make_shared<Gesture>(touch_resource);
|
|
|
|
touch_update_event = Core::Timing::CreateEvent(
|
|
"HID::TouchUpdateCallback",
|
|
[this](s64 time,
|
|
std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
|
|
touch_resource->OnTouchUpdate(time);
|
|
return std::nullopt;
|
|
});
|
|
|
|
touch_resource->SetTouchDriver(touch_driver);
|
|
touch_resource->SetAppletResource(applet_resource, &shared_mutex);
|
|
touch_resource->SetInputEvent(input_event, &input_mutex);
|
|
touch_resource->SetHandheldConfig(handheld_config);
|
|
touch_resource->SetTimerEvent(touch_update_event);
|
|
}
|
|
|
|
void ResourceManager::InitializeConsoleSixAxisSampler() {
|
|
console_six_axis = std::make_shared<ConsoleSixAxis>(system.HIDCore());
|
|
seven_six_axis = std::make_shared<SevenSixAxis>(system);
|
|
|
|
console_six_axis->SetAppletResource(applet_resource, &shared_mutex);
|
|
}
|
|
|
|
void ResourceManager::InitializeAHidSampler() {
|
|
// TODO
|
|
}
|
|
|
|
Result ResourceManager::RegisterCoreAppletResource() {
|
|
std::scoped_lock lock{shared_mutex};
|
|
return applet_resource->RegisterCoreAppletResource();
|
|
}
|
|
|
|
Result ResourceManager::UnregisterCoreAppletResource() {
|
|
std::scoped_lock lock{shared_mutex};
|
|
return applet_resource->UnregisterCoreAppletResource();
|
|
}
|
|
|
|
Result ResourceManager::RegisterAppletResourceUserId(u64 aruid, bool bool_value) {
|
|
std::scoped_lock lock{shared_mutex};
|
|
auto result = applet_resource->RegisterAppletResourceUserId(aruid, bool_value);
|
|
if (result.IsSuccess()) {
|
|
result = npad->RegisterAppletResourceUserId(aruid);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void ResourceManager::UnregisterAppletResourceUserId(u64 aruid) {
|
|
std::scoped_lock lock{shared_mutex};
|
|
applet_resource->UnregisterAppletResourceUserId(aruid);
|
|
npad->UnregisterAppletResourceUserId(aruid);
|
|
// palma->UnregisterAppletResourceUserId(aruid);
|
|
}
|
|
|
|
Result ResourceManager::GetSharedMemoryHandle(Kernel::KSharedMemory** out_handle, u64 aruid) {
|
|
std::scoped_lock lock{shared_mutex};
|
|
return applet_resource->GetSharedMemoryHandle(out_handle, aruid);
|
|
}
|
|
|
|
void ResourceManager::FreeAppletResourceId(u64 aruid) {
|
|
std::scoped_lock lock{shared_mutex};
|
|
applet_resource->FreeAppletResourceId(aruid);
|
|
npad->FreeAppletResourceId(aruid);
|
|
}
|
|
|
|
void ResourceManager::EnableInput(u64 aruid, bool is_enabled) {
|
|
std::scoped_lock lock{shared_mutex};
|
|
applet_resource->EnableInput(aruid, is_enabled);
|
|
}
|
|
|
|
void ResourceManager::EnableSixAxisSensor(u64 aruid, bool is_enabled) {
|
|
std::scoped_lock lock{shared_mutex};
|
|
applet_resource->EnableSixAxisSensor(aruid, is_enabled);
|
|
}
|
|
|
|
void ResourceManager::EnablePadInput(u64 aruid, bool is_enabled) {
|
|
std::scoped_lock lock{shared_mutex};
|
|
applet_resource->EnablePadInput(aruid, is_enabled);
|
|
}
|
|
|
|
void ResourceManager::EnableTouchScreen(u64 aruid, bool is_enabled) {
|
|
std::scoped_lock lock{shared_mutex};
|
|
applet_resource->EnableTouchScreen(aruid, is_enabled);
|
|
}
|
|
|
|
NpadVibrationBase* ResourceManager::GetVibrationDevice(
|
|
const Core::HID::VibrationDeviceHandle& handle) {
|
|
return npad->GetVibrationDevice(handle);
|
|
}
|
|
|
|
NpadN64VibrationDevice* ResourceManager::GetN64VibrationDevice(
|
|
const Core::HID::VibrationDeviceHandle& handle) {
|
|
return npad->GetN64VibrationDevice(handle);
|
|
}
|
|
|
|
NpadVibrationDevice* ResourceManager::GetNSVibrationDevice(
|
|
const Core::HID::VibrationDeviceHandle& handle) {
|
|
return npad->GetNSVibrationDevice(handle);
|
|
}
|
|
|
|
NpadGcVibrationDevice* ResourceManager::GetGcVibrationDevice(
|
|
const Core::HID::VibrationDeviceHandle& handle) {
|
|
return npad->GetGcVibrationDevice(handle);
|
|
}
|
|
|
|
Result ResourceManager::SetAruidValidForVibration(u64 aruid, bool is_enabled) {
|
|
std::scoped_lock lock{shared_mutex};
|
|
const bool has_changed = applet_resource->SetAruidValidForVibration(aruid, is_enabled);
|
|
|
|
if (has_changed) {
|
|
auto devices = npad->GetAllVibrationDevices();
|
|
for ([[maybe_unused]] auto* device : devices) {
|
|
// TODO
|
|
}
|
|
}
|
|
|
|
auto* vibration_handler = npad->GetVibrationHandler();
|
|
if (aruid != vibration_handler->GetSessionAruid()) {
|
|
vibration_handler->EndPermitVibrationSession();
|
|
}
|
|
|
|
return ResultSuccess;
|
|
}
|
|
|
|
void ResourceManager::SetForceHandheldStyleVibration(bool is_forced) {
|
|
handheld_config->is_force_handheld_style_vibration = is_forced;
|
|
}
|
|
|
|
Result ResourceManager::IsVibrationAruidActive(u64 aruid, bool& is_active) const {
|
|
std::scoped_lock lock{shared_mutex};
|
|
is_active = applet_resource->IsVibrationAruidActive(aruid);
|
|
return ResultSuccess;
|
|
}
|
|
|
|
Result ResourceManager::GetVibrationDeviceInfo(Core::HID::VibrationDeviceInfo& device_info,
|
|
const Core::HID::VibrationDeviceHandle& handle) {
|
|
bool check_device_index = false;
|
|
|
|
const Result is_valid = IsVibrationHandleValid(handle);
|
|
if (is_valid.IsError()) {
|
|
return is_valid;
|
|
}
|
|
|
|
switch (handle.npad_type) {
|
|
case Core::HID::NpadStyleIndex::Fullkey:
|
|
case Core::HID::NpadStyleIndex::Handheld:
|
|
case Core::HID::NpadStyleIndex::JoyconDual:
|
|
case Core::HID::NpadStyleIndex::JoyconLeft:
|
|
case Core::HID::NpadStyleIndex::JoyconRight:
|
|
device_info.type = Core::HID::VibrationDeviceType::LinearResonantActuator;
|
|
check_device_index = true;
|
|
break;
|
|
case Core::HID::NpadStyleIndex::GameCube:
|
|
device_info.type = Core::HID::VibrationDeviceType::GcErm;
|
|
break;
|
|
case Core::HID::NpadStyleIndex::N64:
|
|
device_info.type = Core::HID::VibrationDeviceType::N64;
|
|
break;
|
|
default:
|
|
device_info.type = Core::HID::VibrationDeviceType::Unknown;
|
|
break;
|
|
}
|
|
|
|
device_info.position = Core::HID::VibrationDevicePosition::None;
|
|
if (check_device_index) {
|
|
switch (handle.device_index) {
|
|
case Core::HID::DeviceIndex::Left:
|
|
device_info.position = Core::HID::VibrationDevicePosition::Left;
|
|
break;
|
|
case Core::HID::DeviceIndex::Right:
|
|
device_info.position = Core::HID::VibrationDevicePosition::Right;
|
|
break;
|
|
case Core::HID::DeviceIndex::None:
|
|
default:
|
|
ASSERT_MSG(false, "DeviceIndex should never be None!");
|
|
break;
|
|
}
|
|
}
|
|
return ResultSuccess;
|
|
}
|
|
|
|
Result ResourceManager::SendVibrationValue(u64 aruid,
|
|
const Core::HID::VibrationDeviceHandle& handle,
|
|
const Core::HID::VibrationValue& value) {
|
|
bool has_active_aruid{};
|
|
NpadVibrationDevice* device{nullptr};
|
|
Result result = IsVibrationAruidActive(aruid, has_active_aruid);
|
|
|
|
if (result.IsSuccess() && has_active_aruid) {
|
|
result = IsVibrationHandleValid(handle);
|
|
}
|
|
if (result.IsSuccess() && has_active_aruid) {
|
|
device = GetNSVibrationDevice(handle);
|
|
}
|
|
if (device != nullptr) {
|
|
// Prevent sending vibrations to an inactive vibration handle
|
|
if (!device->IsActive()) {
|
|
return ResultSuccess;
|
|
}
|
|
result = device->SendVibrationValue(value);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
Result ResourceManager::GetTouchScreenFirmwareVersion(Core::HID::FirmwareVersion& firmware) const {
|
|
return ResultSuccess;
|
|
}
|
|
|
|
void ResourceManager::UpdateControllers(std::chrono::nanoseconds ns_late) {
|
|
auto& core_timing = system.CoreTiming();
|
|
debug_pad->OnUpdate(core_timing);
|
|
digitizer->OnUpdate(core_timing);
|
|
unique_pad->OnUpdate(core_timing);
|
|
palma->OnUpdate(core_timing);
|
|
home_button->OnUpdate(core_timing);
|
|
sleep_button->OnUpdate(core_timing);
|
|
capture_button->OnUpdate(core_timing);
|
|
}
|
|
|
|
void ResourceManager::UpdateNpad(std::chrono::nanoseconds ns_late) {
|
|
auto& core_timing = system.CoreTiming();
|
|
npad->OnUpdate(core_timing);
|
|
}
|
|
|
|
void ResourceManager::UpdateMouseKeyboard(std::chrono::nanoseconds ns_late) {
|
|
auto& core_timing = system.CoreTiming();
|
|
mouse->OnUpdate(core_timing);
|
|
debug_mouse->OnUpdate(core_timing);
|
|
keyboard->OnUpdate(core_timing);
|
|
}
|
|
|
|
void ResourceManager::UpdateMotion(std::chrono::nanoseconds ns_late) {
|
|
auto& core_timing = system.CoreTiming();
|
|
six_axis->OnUpdate(core_timing);
|
|
seven_six_axis->OnUpdate(core_timing);
|
|
console_six_axis->OnUpdate(core_timing);
|
|
}
|
|
|
|
} // namespace Service::HID
|