summaryrefslogtreecommitdiffstats
path: root/src/core
diff options
context:
space:
mode:
Diffstat (limited to 'src/core')
-rw-r--r--src/core/device_memory_manager.inc7
-rw-r--r--src/core/hle/service/cmif_types.h2
-rw-r--r--src/core/hle/service/hid/hid.cpp2
-rw-r--r--src/core/hle/service/hid/hid_debug_server.cpp173
-rw-r--r--src/core/hle/service/hid/hid_debug_server.h24
-rw-r--r--src/core/hle/service/hid/hid_system_server.cpp9
-rw-r--r--src/core/hle/service/hid/hidbus.cpp481
-rw-r--r--src/core/hle/service/hid/hidbus.h69
-rw-r--r--src/core/hle/service/hid/irs.cpp588
-rw-r--r--src/core/hle/service/hid/irs.h84
-rw-r--r--src/core/hle/service/nvdrv/core/heap_mapper.cpp187
-rw-r--r--src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp6
-rw-r--r--src/core/memory/cheat_engine.cpp5
13 files changed, 606 insertions, 1031 deletions
diff --git a/src/core/device_memory_manager.inc b/src/core/device_memory_manager.inc
index b026f4220..6dfee806c 100644
--- a/src/core/device_memory_manager.inc
+++ b/src/core/device_memory_manager.inc
@@ -532,6 +532,7 @@ void DeviceMemoryManager<Traits>::UpdatePagesCachedCount(DAddr addr, size_t size
cache_bytes = 0;
}
};
+ size_t old_vpage = (base_vaddress >> Memory::YUZU_PAGEBITS) - 1;
for (; page != page_end; ++page) {
CounterAtomicType& count = cached_pages->at(page >> subentries_shift).Count(page);
auto [asid_2, vpage] = ExtractCPUBacking(page);
@@ -547,6 +548,12 @@ void DeviceMemoryManager<Traits>::UpdatePagesCachedCount(DAddr addr, size_t size
memory_device_inter = registered_processes[asid_2.id];
}
+ if (vpage != old_vpage + 1) [[unlikely]] {
+ release_pending();
+ }
+
+ old_vpage = vpage;
+
// Adds or subtracts 1, as count is a unsigned 8-bit value
count.fetch_add(static_cast<CounterType>(delta), std::memory_order_release);
diff --git a/src/core/hle/service/cmif_types.h b/src/core/hle/service/cmif_types.h
index 84f4c2456..325304d5c 100644
--- a/src/core/hle/service/cmif_types.h
+++ b/src/core/hle/service/cmif_types.h
@@ -262,7 +262,7 @@ class OutLargeData {
public:
static_assert(std::is_trivially_copyable_v<T>, "LargeData type must be trivially copyable");
static_assert((A & BufferAttr_In) == 0, "OutLargeData attr must not be In");
- static constexpr BufferAttr Attr = static_cast<BufferAttr>(A | BufferAttr_In | BufferAttr_FixedSize);
+ static constexpr BufferAttr Attr = static_cast<BufferAttr>(A | BufferAttr_Out | BufferAttr_FixedSize);
using Type = T;
/* implicit */ OutLargeData(const OutLargeData& t) : raw(t.raw) {}
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<IHidSystemServer>(system, resource_manager, firmware_settings));
- server_manager->RegisterNamedService("hidbus", std::make_shared<HidBus>(system));
+ server_manager->RegisterNamedService("hidbus", std::make_shared<Hidbus>(system));
server_manager->RegisterNamedService("irs", std::make_shared<IRS::IRS>(system));
server_manager->RegisterNamedService("irs:sys", std::make_shared<IRS::IRS_SYS>(system));
diff --git a/src/core/hle/service/hid/hid_debug_server.cpp b/src/core/hle/service/hid/hid_debug_server.cpp
index 610af34dd..4e2663672 100644
--- a/src/core/hle/service/hid/hid_debug_server.cpp
+++ b/src/core/hle/service/hid/hid_debug_server.cpp
@@ -3,6 +3,7 @@
#include <algorithm>
+#include "core/hle/service/cmif_serialization.h"
#include "core/hle/service/hid/hid_debug_server.h"
#include "core/hle/service/ipc_helpers.h"
#include "hid_core/hid_types.h"
@@ -11,7 +12,6 @@
#include "hid_core/resources/touch_screen/gesture.h"
#include "hid_core/resources/touch_screen/touch_screen.h"
-#include "hid_core/resources/touch_screen/touch_types.h"
namespace Service::HID {
@@ -24,14 +24,14 @@ IHidDebugServer::IHidDebugServer(Core::System& system_, std::shared_ptr<Resource
{0, nullptr, "DeactivateDebugPad"},
{1, nullptr, "SetDebugPadAutoPilotState"},
{2, nullptr, "UnsetDebugPadAutoPilotState"},
- {10, &IHidDebugServer::DeactivateTouchScreen, "DeactivateTouchScreen"},
- {11, &IHidDebugServer::SetTouchScreenAutoPilotState, "SetTouchScreenAutoPilotState"},
- {12, &IHidDebugServer::UnsetTouchScreenAutoPilotState, "UnsetTouchScreenAutoPilotState"},
- {13, &IHidDebugServer::GetTouchScreenConfiguration, "GetTouchScreenConfiguration"},
- {14, &IHidDebugServer::ProcessTouchScreenAutoTune, "ProcessTouchScreenAutoTune"},
- {15, &IHidDebugServer::ForceStopTouchScreenManagement, "ForceStopTouchScreenManagement"},
- {16, &IHidDebugServer::ForceRestartTouchScreenManagement, "ForceRestartTouchScreenManagement"},
- {17, &IHidDebugServer::IsTouchScreenManaged, "IsTouchScreenManaged"},
+ {10, C<&IHidDebugServer::DeactivateTouchScreen>, "DeactivateTouchScreen"},
+ {11, C<&IHidDebugServer::SetTouchScreenAutoPilotState>, "SetTouchScreenAutoPilotState"},
+ {12, C<&IHidDebugServer::UnsetTouchScreenAutoPilotState>, "UnsetTouchScreenAutoPilotState"},
+ {13, C<&IHidDebugServer::GetTouchScreenConfiguration>, "GetTouchScreenConfiguration"},
+ {14, C<&IHidDebugServer::ProcessTouchScreenAutoTune>, "ProcessTouchScreenAutoTune"},
+ {15, C<&IHidDebugServer::ForceStopTouchScreenManagement>, "ForceStopTouchScreenManagement"},
+ {16, C<&IHidDebugServer::ForceRestartTouchScreenManagement>, "ForceRestartTouchScreenManagement"},
+ {17, C<&IHidDebugServer::IsTouchScreenManaged>, "IsTouchScreenManaged"},
{20, nullptr, "DeactivateMouse"},
{21, nullptr, "SetMouseAutoPilotState"},
{22, nullptr, "UnsetMouseAutoPilotState"},
@@ -47,7 +47,7 @@ IHidDebugServer::IHidDebugServer(Core::System& system_, std::shared_ptr<Resource
{60, nullptr, "ClearNpadSystemCommonPolicy"},
{61, nullptr, "DeactivateNpad"},
{62, nullptr, "ForceDisconnectNpad"},
- {91, &IHidDebugServer::DeactivateGesture, "DeactivateGesture"},
+ {91, C<&IHidDebugServer::DeactivateGesture>, "DeactivateGesture"},
{110, nullptr, "DeactivateHomeButton"},
{111, nullptr, "SetHomeButtonAutoPilotState"},
{112, nullptr, "UnsetHomeButtonAutoPilotState"},
@@ -160,169 +160,122 @@ IHidDebugServer::IHidDebugServer(Core::System& system_, std::shared_ptr<Resource
}
IHidDebugServer::~IHidDebugServer() = default;
-void IHidDebugServer::DeactivateTouchScreen(HLERequestContext& ctx) {
- LOG_INFO(Service_HID, "called");
- Result result = ResultSuccess;
+Result IHidDebugServer::DeactivateTouchScreen() {
+ LOG_INFO(Service_HID, "called");
if (!firmware_settings->IsDeviceManaged()) {
- result = GetResourceManager()->GetTouchScreen()->Deactivate();
+ R_RETURN(GetResourceManager()->GetTouchScreen()->Deactivate());
}
- IPC::ResponseBuilder rb{ctx, 2};
- rb.Push(result);
+ R_SUCCEED();
}
-void IHidDebugServer::SetTouchScreenAutoPilotState(HLERequestContext& ctx) {
+Result IHidDebugServer::SetTouchScreenAutoPilotState(
+ InArray<TouchState, BufferAttr_HipcMapAlias> auto_pilot_buffer) {
AutoPilotState auto_pilot{};
- auto_pilot.count = ctx.GetReadBufferNumElements<TouchState>();
- const auto buffer = ctx.ReadBuffer();
- auto_pilot.count = std::min(auto_pilot.count, static_cast<u64>(auto_pilot.state.size()));
- memcpy(auto_pilot.state.data(), buffer.data(), auto_pilot.count * sizeof(TouchState));
+ auto_pilot.count =
+ static_cast<u64>(std::min(auto_pilot_buffer.size(), auto_pilot.state.size()));
+ memcpy(auto_pilot.state.data(), auto_pilot_buffer.data(),
+ auto_pilot.count * sizeof(TouchState));
LOG_INFO(Service_HID, "called, auto_pilot_count={}", auto_pilot.count);
- const Result result =
- GetResourceManager()->GetTouchScreen()->SetTouchScreenAutoPilotState(auto_pilot);
-
- IPC::ResponseBuilder rb{ctx, 2};
- rb.Push(result);
+ R_RETURN(GetResourceManager()->GetTouchScreen()->SetTouchScreenAutoPilotState(auto_pilot));
}
-void IHidDebugServer::UnsetTouchScreenAutoPilotState(HLERequestContext& ctx) {
+Result IHidDebugServer::UnsetTouchScreenAutoPilotState() {
LOG_INFO(Service_HID, "called");
-
- const Result result = GetResourceManager()->GetTouchScreen()->UnsetTouchScreenAutoPilotState();
-
- IPC::ResponseBuilder rb{ctx, 2};
- rb.Push(result);
+ R_RETURN(GetResourceManager()->GetTouchScreen()->UnsetTouchScreenAutoPilotState());
}
-void IHidDebugServer::GetTouchScreenConfiguration(HLERequestContext& ctx) {
- IPC::RequestParser rp{ctx};
- const auto applet_resource_user_id{rp.Pop<u64>()};
-
- LOG_INFO(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
+Result IHidDebugServer::GetTouchScreenConfiguration(
+ Out<Core::HID::TouchScreenConfigurationForNx> out_touchscreen_config,
+ ClientAppletResourceUserId aruid) {
+ LOG_INFO(Service_HID, "called, applet_resource_user_id={}", aruid.pid);
- Core::HID::TouchScreenConfigurationForNx touchscreen_config{};
- const Result result = GetResourceManager()->GetTouchScreen()->GetTouchScreenConfiguration(
- touchscreen_config, applet_resource_user_id);
+ R_TRY(GetResourceManager()->GetTouchScreen()->GetTouchScreenConfiguration(
+ *out_touchscreen_config, aruid.pid));
- if (touchscreen_config.mode != Core::HID::TouchScreenModeForNx::Heat2 &&
- touchscreen_config.mode != Core::HID::TouchScreenModeForNx::Finger) {
- touchscreen_config.mode = Core::HID::TouchScreenModeForNx::UseSystemSetting;
+ if (out_touchscreen_config->mode != Core::HID::TouchScreenModeForNx::Heat2 &&
+ out_touchscreen_config->mode != Core::HID::TouchScreenModeForNx::Finger) {
+ out_touchscreen_config->mode = Core::HID::TouchScreenModeForNx::UseSystemSetting;
}
- IPC::ResponseBuilder rb{ctx, 6};
- rb.Push(result);
- rb.PushRaw(touchscreen_config);
+ R_SUCCEED();
}
-void IHidDebugServer::ProcessTouchScreenAutoTune(HLERequestContext& ctx) {
+Result IHidDebugServer::ProcessTouchScreenAutoTune() {
LOG_INFO(Service_HID, "called");
-
- Result result = GetResourceManager()->GetTouchScreen()->ProcessTouchScreenAutoTune();
-
- IPC::ResponseBuilder rb{ctx, 2};
- rb.Push(result);
+ R_RETURN(GetResourceManager()->GetTouchScreen()->ProcessTouchScreenAutoTune());
}
-void IHidDebugServer::ForceStopTouchScreenManagement(HLERequestContext& ctx) {
+Result IHidDebugServer::ForceStopTouchScreenManagement() {
LOG_INFO(Service_HID, "called");
if (!firmware_settings->IsDeviceManaged()) {
- IPC::ResponseBuilder rb{ctx, 2};
- rb.Push(ResultSuccess);
- return;
+ R_SUCCEED();
}
- Result result = ResultSuccess;
- bool is_touch_active{};
- bool is_gesture_active{};
auto touch_screen = GetResourceManager()->GetTouchScreen();
auto gesture = GetResourceManager()->GetGesture();
if (firmware_settings->IsTouchI2cManaged()) {
- result = touch_screen->IsActive(is_touch_active);
- if (result.IsSuccess()) {
- result = gesture->IsActive(is_gesture_active);
- }
- if (result.IsSuccess() && is_touch_active) {
- result = touch_screen->Deactivate();
+ bool is_touch_active{};
+ bool is_gesture_active{};
+ R_TRY(touch_screen->IsActive(is_touch_active));
+ R_TRY(gesture->IsActive(is_gesture_active));
+
+ if (is_touch_active) {
+ R_TRY(touch_screen->Deactivate());
}
- if (result.IsSuccess() && is_gesture_active) {
- result = gesture->Deactivate();
+ if (is_gesture_active) {
+ R_TRY(gesture->Deactivate());
}
}
- IPC::ResponseBuilder rb{ctx, 2};
- rb.Push(result);
+ R_SUCCEED();
}
-void IHidDebugServer::ForceRestartTouchScreenManagement(HLERequestContext& ctx) {
- IPC::RequestParser rp{ctx};
- struct Parameters {
- u32 basic_gesture_id;
- INSERT_PADDING_WORDS_NOINIT(1);
- u64 applet_resource_user_id;
- };
- static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size.");
-
- const auto parameters{rp.PopRaw<Parameters>()};
-
+Result IHidDebugServer::ForceRestartTouchScreenManagement(u32 basic_gesture_id,
+ ClientAppletResourceUserId aruid) {
LOG_INFO(Service_HID, "called, basic_gesture_id={}, applet_resource_user_id={}",
- parameters.basic_gesture_id, parameters.applet_resource_user_id);
+ basic_gesture_id, aruid.pid);
- Result result = ResultSuccess;
auto touch_screen = GetResourceManager()->GetTouchScreen();
auto gesture = GetResourceManager()->GetGesture();
if (firmware_settings->IsDeviceManaged() && firmware_settings->IsTouchI2cManaged()) {
- result = gesture->Activate();
- if (result.IsSuccess()) {
- result =
- gesture->Activate(parameters.applet_resource_user_id, parameters.basic_gesture_id);
- }
- if (result.IsSuccess()) {
- result = touch_screen->Activate();
- }
- if (result.IsSuccess()) {
- result = touch_screen->Activate(parameters.applet_resource_user_id);
- }
+ R_TRY(gesture->Activate());
+ R_TRY(gesture->Activate(aruid.pid, basic_gesture_id));
+ R_TRY(touch_screen->Activate());
+ R_TRY(touch_screen->Activate(aruid.pid));
}
- IPC::ResponseBuilder rb{ctx, 2};
- rb.Push(result);
+ R_SUCCEED();
}
-void IHidDebugServer::IsTouchScreenManaged(HLERequestContext& ctx) {
+Result IHidDebugServer::IsTouchScreenManaged(Out<bool> out_is_managed) {
LOG_INFO(Service_HID, "called");
bool is_touch_active{};
bool is_gesture_active{};
+ R_TRY(GetResourceManager()->GetTouchScreen()->IsActive(is_touch_active));
+ R_TRY(GetResourceManager()->GetGesture()->IsActive(is_gesture_active));
- Result result = GetResourceManager()->GetTouchScreen()->IsActive(is_touch_active);
- if (result.IsSuccess()) {
- result = GetResourceManager()->GetGesture()->IsActive(is_gesture_active);
- }
-
- IPC::ResponseBuilder rb{ctx, 3};
- rb.Push(result);
- rb.Push(is_touch_active | is_gesture_active);
+ *out_is_managed = is_touch_active || is_gesture_active;
+ R_SUCCEED();
}
-void IHidDebugServer::DeactivateGesture(HLERequestContext& ctx) {
+Result IHidDebugServer::DeactivateGesture() {
LOG_INFO(Service_HID, "called");
- Result result = ResultSuccess;
-
if (!firmware_settings->IsDeviceManaged()) {
- result = GetResourceManager()->GetGesture()->Deactivate();
+ R_RETURN(GetResourceManager()->GetGesture()->Deactivate());
}
- IPC::ResponseBuilder rb{ctx, 2};
- rb.Push(result);
+ R_SUCCEED();
}
std::shared_ptr<ResourceManager> IHidDebugServer::GetResourceManager() {
diff --git a/src/core/hle/service/hid/hid_debug_server.h b/src/core/hle/service/hid/hid_debug_server.h
index 7d5b082b3..3a483f07e 100644
--- a/src/core/hle/service/hid/hid_debug_server.h
+++ b/src/core/hle/service/hid/hid_debug_server.h
@@ -3,7 +3,9 @@
#pragma once
+#include "core/hle/service/cmif_types.h"
#include "core/hle/service/service.h"
+#include "hid_core/resources/touch_screen/touch_types.h"
namespace Core {
class System;
@@ -20,15 +22,19 @@ public:
~IHidDebugServer() override;
private:
- void DeactivateTouchScreen(HLERequestContext& ctx);
- void SetTouchScreenAutoPilotState(HLERequestContext& ctx);
- void UnsetTouchScreenAutoPilotState(HLERequestContext& ctx);
- void GetTouchScreenConfiguration(HLERequestContext& ctx);
- void ProcessTouchScreenAutoTune(HLERequestContext& ctx);
- void ForceStopTouchScreenManagement(HLERequestContext& ctx);
- void ForceRestartTouchScreenManagement(HLERequestContext& ctx);
- void IsTouchScreenManaged(HLERequestContext& ctx);
- void DeactivateGesture(HLERequestContext& ctx);
+ Result DeactivateTouchScreen();
+ Result SetTouchScreenAutoPilotState(
+ InArray<TouchState, BufferAttr_HipcMapAlias> auto_pilot_buffer);
+ Result UnsetTouchScreenAutoPilotState();
+ Result GetTouchScreenConfiguration(
+ Out<Core::HID::TouchScreenConfigurationForNx> out_touchscreen_config,
+ ClientAppletResourceUserId aruid);
+ Result ProcessTouchScreenAutoTune();
+ Result ForceStopTouchScreenManagement();
+ Result ForceRestartTouchScreenManagement(u32 basic_gesture_id,
+ ClientAppletResourceUserId aruid);
+ Result IsTouchScreenManaged(Out<bool> out_is_managed);
+ Result DeactivateGesture();
std::shared_ptr<ResourceManager> GetResourceManager();
diff --git a/src/core/hle/service/hid/hid_system_server.cpp b/src/core/hle/service/hid/hid_system_server.cpp
index 22471e9e2..7126a1dcd 100644
--- a/src/core/hle/service/hid/hid_system_server.cpp
+++ b/src/core/hle/service/hid/hid_system_server.cpp
@@ -508,13 +508,8 @@ void IHidSystemServer::RegisterAppletResourceUserId(HLERequestContext& ctx) {
Result result = GetResourceManager()->RegisterAppletResourceUserId(
parameters.applet_resource_user_id, parameters.enable_input);
- if (result.IsSuccess()) {
- // result = GetResourceManager()->GetNpad()->RegisterAppletResourceUserId(
- // parameters.applet_resource_user_id);
- }
-
IPC::ResponseBuilder rb{ctx, 2};
- rb.Push(ResultSuccess);
+ rb.Push(result);
}
void IHidSystemServer::UnregisterAppletResourceUserId(HLERequestContext& ctx) {
@@ -524,8 +519,6 @@ void IHidSystemServer::UnregisterAppletResourceUserId(HLERequestContext& ctx) {
LOG_INFO(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
GetResourceManager()->UnregisterAppletResourceUserId(applet_resource_user_id);
- // GetResourceManager()->GetNpad()->UnregisterAppletResourceUserId(applet_resource_user_id);
- // GetResourceManager()->GetPalma()->UnregisterAppletResourceUserId(applet_resource_user_id);
IPC::ResponseBuilder rb{ctx, 2};
rb.Push(ResultSuccess);
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<std::size_t> HidBus::GetDeviceIndexFromHandle(BusHandle handle) const {
+std::optional<std::size_t> 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<std::size_t> 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<Parameters>()};
-
- 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<bool> out_is_valid, Out<BusHandle> 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<Core::HID::NpadIdType>(handle.player_number) == parameters.npad_id &&
- handle.bus_type_id == static_cast<u8>(parameters.bus_type)) {
+ if (handle.player_number.As<Core::HID::NpadIdType>() == npad_id &&
+ handle.bus_type_id == static_cast<u8>(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<u8>(i),
- .internal_index = static_cast<u8>(i),
- .player_number = static_cast<u8>(parameters.npad_id),
- .bus_type_id = static_cast<u8>(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<u8>(npad_id));
+ devices[i].handle.bus_type_id.Assign(static_cast<u8>(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<BusHandle>()};
-
+Result Hidbus::IsExternalDeviceConnected(Out<bool> 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<BusHandle>()};
- const auto applet_resource_user_id{rp.Pop<u64>()};
-
+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<RingController>(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<HidbusStubbed>(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<BusHandle>()};
- const auto applet_resource_user_id{rp.Pop<u64>()};
-
- 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<RingController>(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<HidbusStubbed>(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<Parameters>()};
+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<BusHandle>()};
-
+Result Hidbus::GetExternalDeviceId(Out<u32> 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<u32>(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<BusHandle>()};
+ 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<BufferAttr_HipcAutoSelect> 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<BusHandle>()};
-
+Result Hidbus::GetSendCommandAsynceResult(Out<u64> out_data_size, BusHandle bus_handle,
+ OutBuffer<BufferAttr_HipcAutoSelect> 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<u8> 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<u64>(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<BusHandle>()};
-
+Result Hidbus::SetEventForSendCommandAsycResult(OutCopyHandle<Kernel::KReadableEvent> 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<Kernel::KSharedMemory> 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<u32>()};
- const auto t_mem_handle{ctx.GetCopyHandle(0)};
- const auto polling_mode_{rp.PopEnum<JoyPollingMode>()};
- const auto bus_handle_{rp.PopRaw<BusHandle>()};
-
+Result Hidbus::EnableJoyPollingReceiveMode(u32 t_mem_size, JoyPollingMode polling_mode,
+ BusHandle bus_handle,
+ InCopyHandle<Kernel::KTransferMemory> t_mem) {
ASSERT_MSG(t_mem_size == 0x1000, "t_mem_size is not 0x1000 bytes");
-
- auto t_mem = ctx.GetObjectFromHandle<Kernel::KTransferMemory>(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<BusHandle>()};
-
+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<StatusManagerType>()};
-
+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 <functional>
+#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<HidBus> {
+class Hidbus final : public ServiceFramework<Hidbus> {
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<HidbusBase> 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<bool> out_is_valid, Out<BusHandle> out_bus_handle,
+ Core::HID::NpadIdType npad_id, BusType bus_type,
+ AppletResourceUserId aruid);
+
+ Result IsExternalDeviceConnected(Out<bool> 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<u32> out_device_id, BusHandle bus_handle);
+
+ Result SendCommandAsync(BusHandle bus_handle, InBuffer<BufferAttr_HipcAutoSelect> buffer_data);
+
+ Result GetSendCommandAsynceResult(Out<u64> out_data_size, BusHandle bus_handle,
+ OutBuffer<BufferAttr_HipcAutoSelect> out_buffer_data);
+
+ Result SetEventForSendCommandAsycResult(OutCopyHandle<Kernel::KReadableEvent> out_event,
+ BusHandle bus_handle);
+
+ Result GetSharedMemoryHandle(OutCopyHandle<Kernel::KSharedMemory> out_shared_memory);
+
+ Result EnableJoyPollingReceiveMode(u32 t_mem_size, JoyPollingMode polling_mode,
+ BusHandle bus_handle,
+ InCopyHandle<Kernel::KTransferMemory> t_mem);
+
+ Result DisableJoyPollingReceiveMode(BusHandle bus_handle);
+
+ Result SetStatusManagerType(StatusManagerType manager_type);
void UpdateHidbus(std::chrono::nanoseconds ns_late);
std::optional<std::size_t> GetDeviceIndexFromHandle(BusHandle handle) const;
diff --git a/src/core/hle/service/hid/irs.cpp b/src/core/hle/service/hid/irs.cpp
index 18e544f2f..7d7368ff9 100644
--- a/src/core/hle/service/hid/irs.cpp
+++ b/src/core/hle/service/hid/irs.cpp
@@ -9,6 +9,7 @@
#include "core/hle/kernel/k_shared_memory.h"
#include "core/hle/kernel/k_transfer_memory.h"
#include "core/hle/kernel/kernel.h"
+#include "core/hle/service/cmif_serialization.h"
#include "core/hle/service/hid/irs.h"
#include "core/hle/service/ipc_helpers.h"
#include "core/memory.h"
@@ -28,24 +29,24 @@ namespace Service::IRS {
IRS::IRS(Core::System& system_) : ServiceFramework{system_, "irs"} {
// clang-format off
static const FunctionInfo functions[] = {
- {302, &IRS::ActivateIrsensor, "ActivateIrsensor"},
- {303, &IRS::DeactivateIrsensor, "DeactivateIrsensor"},
- {304, &IRS::GetIrsensorSharedMemoryHandle, "GetIrsensorSharedMemoryHandle"},
- {305, &IRS::StopImageProcessor, "StopImageProcessor"},
- {306, &IRS::RunMomentProcessor, "RunMomentProcessor"},
- {307, &IRS::RunClusteringProcessor, "RunClusteringProcessor"},
- {308, &IRS::RunImageTransferProcessor, "RunImageTransferProcessor"},
- {309, &IRS::GetImageTransferProcessorState, "GetImageTransferProcessorState"},
- {310, &IRS::RunTeraPluginProcessor, "RunTeraPluginProcessor"},
- {311, &IRS::GetNpadIrCameraHandle, "GetNpadIrCameraHandle"},
- {312, &IRS::RunPointingProcessor, "RunPointingProcessor"},
- {313, &IRS::SuspendImageProcessor, "SuspendImageProcessor"},
- {314, &IRS::CheckFirmwareVersion, "CheckFirmwareVersion"},
- {315, &IRS::SetFunctionLevel, "SetFunctionLevel"},
- {316, &IRS::RunImageTransferExProcessor, "RunImageTransferExProcessor"},
- {317, &IRS::RunIrLedProcessor, "RunIrLedProcessor"},
- {318, &IRS::StopImageProcessorAsync, "StopImageProcessorAsync"},
- {319, &IRS::ActivateIrsensorWithFunctionLevel, "ActivateIrsensorWithFunctionLevel"},
+ {302, C<&IRS::ActivateIrsensor>, "ActivateIrsensor"},
+ {303, C<&IRS::DeactivateIrsensor>, "DeactivateIrsensor"},
+ {304, C<&IRS::GetIrsensorSharedMemoryHandle>, "GetIrsensorSharedMemoryHandle"},
+ {305, C<&IRS::StopImageProcessor>, "StopImageProcessor"},
+ {306, C<&IRS::RunMomentProcessor>, "RunMomentProcessor"},
+ {307, C<&IRS::RunClusteringProcessor>, "RunClusteringProcessor"},
+ {308, C<&IRS::RunImageTransferProcessor>, "RunImageTransferProcessor"},
+ {309, C<&IRS::GetImageTransferProcessorState>, "GetImageTransferProcessorState"},
+ {310, C<&IRS::RunTeraPluginProcessor>, "RunTeraPluginProcessor"},
+ {311, C<&IRS::GetNpadIrCameraHandle>, "GetNpadIrCameraHandle"},
+ {312, C<&IRS::RunPointingProcessor>, "RunPointingProcessor"},
+ {313, C<&IRS::SuspendImageProcessor>, "SuspendImageProcessor"},
+ {314, C<&IRS::CheckFirmwareVersion>, "CheckFirmwareVersion"},
+ {315, C<&IRS::SetFunctionLevel>, "SetFunctionLevel"},
+ {316, C<&IRS::RunImageTransferExProcessor>, "RunImageTransferExProcessor"},
+ {317, C<&IRS::RunIrLedProcessor>, "RunIrLedProcessor"},
+ {318, C<&IRS::StopImageProcessorAsync>, "StopImageProcessorAsync"},
+ {319, C<&IRS::ActivateIrsensorWithFunctionLevel>, "ActivateIrsensorWithFunctionLevel"},
};
// clang-format on
@@ -57,489 +58,292 @@ IRS::IRS(Core::System& system_) : ServiceFramework{system_, "irs"} {
}
IRS::~IRS() = default;
-void IRS::ActivateIrsensor(HLERequestContext& ctx) {
- IPC::RequestParser rp{ctx};
- const auto applet_resource_user_id{rp.Pop<u64>()};
-
- LOG_WARNING(Service_IRS, "(STUBBED) called, applet_resource_user_id={}",
- applet_resource_user_id);
-
- IPC::ResponseBuilder rb{ctx, 2};
- rb.Push(ResultSuccess);
+Result IRS::ActivateIrsensor(ClientAppletResourceUserId aruid) {
+ LOG_WARNING(Service_IRS, "(STUBBED) called, applet_resource_user_id={}", aruid.pid);
+ R_SUCCEED();
}
-void IRS::DeactivateIrsensor(HLERequestContext& ctx) {
- IPC::RequestParser rp{ctx};
- const auto applet_resource_user_id{rp.Pop<u64>()};
-
- LOG_WARNING(Service_IRS, "(STUBBED) called, applet_resource_user_id={}",
- applet_resource_user_id);
-
- IPC::ResponseBuilder rb{ctx, 2};
- rb.Push(ResultSuccess);
+Result IRS::DeactivateIrsensor(ClientAppletResourceUserId aruid) {
+ LOG_WARNING(Service_IRS, "(STUBBED) called, applet_resource_user_id={}", aruid.pid);
+ R_SUCCEED();
}
-void IRS::GetIrsensorSharedMemoryHandle(HLERequestContext& ctx) {
- IPC::RequestParser rp{ctx};
- const auto applet_resource_user_id{rp.Pop<u64>()};
-
- LOG_DEBUG(Service_IRS, "called, applet_resource_user_id={}", applet_resource_user_id);
+Result IRS::GetIrsensorSharedMemoryHandle(OutCopyHandle<Kernel::KSharedMemory> out_shared_memory,
+ ClientAppletResourceUserId aruid) {
+ LOG_DEBUG(Service_IRS, "called, applet_resource_user_id={}", aruid.pid);
- IPC::ResponseBuilder rb{ctx, 2, 1};
- rb.Push(ResultSuccess);
- rb.PushCopyObjects(&system.Kernel().GetIrsSharedMem());
+ *out_shared_memory = &system.Kernel().GetIrsSharedMem();
+ R_SUCCEED();
}
-void IRS::StopImageProcessor(HLERequestContext& ctx) {
- IPC::RequestParser rp{ctx};
- struct Parameters {
- Core::IrSensor::IrCameraHandle camera_handle;
- INSERT_PADDING_WORDS_NOINIT(1);
- u64 applet_resource_user_id;
- };
- static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size.");
-
- const auto parameters{rp.PopRaw<Parameters>()};
-
+Result IRS::StopImageProcessor(Core::IrSensor::IrCameraHandle camera_handle,
+ ClientAppletResourceUserId aruid) {
LOG_WARNING(Service_IRS,
"(STUBBED) called, npad_type={}, npad_id={}, applet_resource_user_id={}",
- parameters.camera_handle.npad_type, parameters.camera_handle.npad_id,
- parameters.applet_resource_user_id);
-
- auto result = IsIrCameraHandleValid(parameters.camera_handle);
- if (result.IsSuccess()) {
- // TODO: Stop Image processor
- npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
- Common::Input::PollingMode::Active);
- result = ResultSuccess;
- }
+ camera_handle.npad_type, camera_handle.npad_id, aruid.pid);
- IPC::ResponseBuilder rb{ctx, 2};
- rb.Push(result);
-}
-
-void IRS::RunMomentProcessor(HLERequestContext& ctx) {
- IPC::RequestParser rp{ctx};
- struct Parameters {
- Core::IrSensor::IrCameraHandle camera_handle;
- INSERT_PADDING_WORDS_NOINIT(1);
- u64 applet_resource_user_id;
- Core::IrSensor::PackedMomentProcessorConfig processor_config;
- };
- static_assert(sizeof(Parameters) == 0x30, "Parameters has incorrect size.");
+ R_TRY(IsIrCameraHandleValid(camera_handle));
- const auto parameters{rp.PopRaw<Parameters>()};
+ // TODO: Stop Image processor
+ npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
+ Common::Input::PollingMode::Active);
+ R_SUCCEED();
+}
+Result IRS::RunMomentProcessor(
+ Core::IrSensor::IrCameraHandle camera_handle, ClientAppletResourceUserId aruid,
+ const Core::IrSensor::PackedMomentProcessorConfig& processor_config) {
LOG_WARNING(Service_IRS,
"(STUBBED) called, npad_type={}, npad_id={}, applet_resource_user_id={}",
- parameters.camera_handle.npad_type, parameters.camera_handle.npad_id,
- parameters.applet_resource_user_id);
-
- const auto result = IsIrCameraHandleValid(parameters.camera_handle);
-
- if (result.IsSuccess()) {
- auto& device = GetIrCameraSharedMemoryDeviceEntry(parameters.camera_handle);
- MakeProcessorWithCoreContext<MomentProcessor>(parameters.camera_handle, device);
- auto& image_transfer_processor = GetProcessor<MomentProcessor>(parameters.camera_handle);
- image_transfer_processor.SetConfig(parameters.processor_config);
- npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
- Common::Input::PollingMode::IR);
- }
+ camera_handle.npad_type, camera_handle.npad_id, aruid.pid);
- IPC::ResponseBuilder rb{ctx, 2};
- rb.Push(result);
-}
+ R_TRY(IsIrCameraHandleValid(camera_handle));
-void IRS::RunClusteringProcessor(HLERequestContext& ctx) {
- IPC::RequestParser rp{ctx};
- struct Parameters {
- Core::IrSensor::IrCameraHandle camera_handle;
- INSERT_PADDING_WORDS_NOINIT(1);
- u64 applet_resource_user_id;
- Core::IrSensor::PackedClusteringProcessorConfig processor_config;
- };
- static_assert(sizeof(Parameters) == 0x38, "Parameters has incorrect size.");
+ auto& device = GetIrCameraSharedMemoryDeviceEntry(camera_handle);
+ MakeProcessorWithCoreContext<MomentProcessor>(camera_handle, device);
+ auto& image_transfer_processor = GetProcessor<MomentProcessor>(camera_handle);
+ image_transfer_processor.SetConfig(processor_config);
+ npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
+ Common::Input::PollingMode::IR);
- const auto parameters{rp.PopRaw<Parameters>()};
+ R_SUCCEED();
+}
+Result IRS::RunClusteringProcessor(
+ Core::IrSensor::IrCameraHandle camera_handle, ClientAppletResourceUserId aruid,
+ const Core::IrSensor::PackedClusteringProcessorConfig& processor_config) {
LOG_WARNING(Service_IRS,
"(STUBBED) called, npad_type={}, npad_id={}, applet_resource_user_id={}",
- parameters.camera_handle.npad_type, parameters.camera_handle.npad_id,
- parameters.applet_resource_user_id);
-
- auto result = IsIrCameraHandleValid(parameters.camera_handle);
-
- if (result.IsSuccess()) {
- auto& device = GetIrCameraSharedMemoryDeviceEntry(parameters.camera_handle);
- MakeProcessorWithCoreContext<ClusteringProcessor>(parameters.camera_handle, device);
- auto& image_transfer_processor =
- GetProcessor<ClusteringProcessor>(parameters.camera_handle);
- image_transfer_processor.SetConfig(parameters.processor_config);
- npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
- Common::Input::PollingMode::IR);
- }
+ camera_handle.npad_type, camera_handle.npad_id, aruid.pid);
- IPC::ResponseBuilder rb{ctx, 2};
- rb.Push(result);
-}
+ R_TRY(IsIrCameraHandleValid(camera_handle));
-void IRS::RunImageTransferProcessor(HLERequestContext& ctx) {
- IPC::RequestParser rp{ctx};
- struct Parameters {
- Core::IrSensor::IrCameraHandle camera_handle;
- INSERT_PADDING_WORDS_NOINIT(1);
- u64 applet_resource_user_id;
- Core::IrSensor::PackedImageTransferProcessorConfig processor_config;
- u32 transfer_memory_size;
- };
- static_assert(sizeof(Parameters) == 0x30, "Parameters has incorrect size.");
+ auto& device = GetIrCameraSharedMemoryDeviceEntry(camera_handle);
+ MakeProcessorWithCoreContext<ClusteringProcessor>(camera_handle, device);
+ auto& image_transfer_processor = GetProcessor<ClusteringProcessor>(camera_handle);
+ image_transfer_processor.SetConfig(processor_config);
+ npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
+ Common::Input::PollingMode::IR);
- const auto parameters{rp.PopRaw<Parameters>()};
- const auto t_mem_handle{ctx.GetCopyHandle(0)};
+ R_SUCCEED();
+}
- auto t_mem = ctx.GetObjectFromHandle<Kernel::KTransferMemory>(t_mem_handle);
+Result IRS::RunImageTransferProcessor(
+ Core::IrSensor::IrCameraHandle camera_handle, ClientAppletResourceUserId aruid,
+ const Core::IrSensor::PackedImageTransferProcessorConfig& processor_config,
+ u64 transfer_memory_size, InCopyHandle<Kernel::KTransferMemory> t_mem) {
- if (t_mem.IsNull()) {
- LOG_ERROR(Service_IRS, "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() == parameters.transfer_memory_size, "t_mem has incorrect size");
+ ASSERT_MSG(t_mem->GetSize() == transfer_memory_size, "t_mem has incorrect size");
LOG_INFO(Service_IRS,
"called, npad_type={}, npad_id={}, transfer_memory_size={}, transfer_memory_size={}, "
"applet_resource_user_id={}",
- parameters.camera_handle.npad_type, parameters.camera_handle.npad_id,
- parameters.transfer_memory_size, t_mem->GetSize(), parameters.applet_resource_user_id);
-
- const auto result = IsIrCameraHandleValid(parameters.camera_handle);
-
- if (result.IsSuccess()) {
- auto& device = GetIrCameraSharedMemoryDeviceEntry(parameters.camera_handle);
- MakeProcessorWithCoreContext<ImageTransferProcessor>(parameters.camera_handle, device);
- auto& image_transfer_processor =
- GetProcessor<ImageTransferProcessor>(parameters.camera_handle);
- image_transfer_processor.SetConfig(parameters.processor_config);
- image_transfer_processor.SetTransferMemoryAddress(t_mem->GetSourceAddress());
- npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
- Common::Input::PollingMode::IR);
- }
+ camera_handle.npad_type, camera_handle.npad_id, transfer_memory_size, t_mem->GetSize(),
+ aruid.pid);
- IPC::ResponseBuilder rb{ctx, 2};
- rb.Push(result);
-}
+ R_TRY(IsIrCameraHandleValid(camera_handle));
-void IRS::GetImageTransferProcessorState(HLERequestContext& ctx) {
- IPC::RequestParser rp{ctx};
- struct Parameters {
- Core::IrSensor::IrCameraHandle camera_handle;
- INSERT_PADDING_WORDS_NOINIT(1);
- u64 applet_resource_user_id;
- };
- static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size.");
+ auto& device = GetIrCameraSharedMemoryDeviceEntry(camera_handle);
+ MakeProcessorWithCoreContext<ImageTransferProcessor>(camera_handle, device);
+ auto& image_transfer_processor = GetProcessor<ImageTransferProcessor>(camera_handle);
+ image_transfer_processor.SetConfig(processor_config);
+ image_transfer_processor.SetTransferMemoryAddress(t_mem->GetSourceAddress());
+ npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
+ Common::Input::PollingMode::IR);
- const auto parameters{rp.PopRaw<Parameters>()};
+ R_SUCCEED();
+}
+Result IRS::GetImageTransferProcessorState(
+ Out<Core::IrSensor::ImageTransferProcessorState> out_state,
+ Core::IrSensor::IrCameraHandle camera_handle, ClientAppletResourceUserId aruid,
+ OutBuffer<BufferAttr_HipcMapAlias> out_buffer_data) {
LOG_DEBUG(Service_IRS, "(STUBBED) called, npad_type={}, npad_id={}, applet_resource_user_id={}",
- parameters.camera_handle.npad_type, parameters.camera_handle.npad_id,
- parameters.applet_resource_user_id);
-
- const auto result = IsIrCameraHandleValid(parameters.camera_handle);
- if (result.IsError()) {
- IPC::ResponseBuilder rb{ctx, 2};
- rb.Push(result);
- return;
- }
+ camera_handle.npad_type, camera_handle.npad_id, aruid.pid);
- const auto& device = GetIrCameraSharedMemoryDeviceEntry(parameters.camera_handle);
+ R_TRY(IsIrCameraHandleValid(camera_handle));
- if (device.mode != Core::IrSensor::IrSensorMode::ImageTransferProcessor) {
- IPC::ResponseBuilder rb{ctx, 2};
- rb.Push(InvalidProcessorState);
- return;
- }
+ const auto& device = GetIrCameraSharedMemoryDeviceEntry(camera_handle);
+
+ R_TRY(IsIrCameraHandleValid(camera_handle));
+ R_UNLESS(device.mode == Core::IrSensor::IrSensorMode::ImageTransferProcessor,
+ InvalidProcessorState);
- std::vector<u8> data{};
- const auto& image_transfer_processor =
- GetProcessor<ImageTransferProcessor>(parameters.camera_handle);
- const auto& state = image_transfer_processor.GetState(data);
+ *out_state = GetProcessor<ImageTransferProcessor>(camera_handle).GetState(out_buffer_data);
- ctx.WriteBuffer(data);
- IPC::ResponseBuilder rb{ctx, 6};
- rb.Push(ResultSuccess);
- rb.PushRaw(state);
+ R_SUCCEED();
}
-void IRS::RunTeraPluginProcessor(HLERequestContext& ctx) {
- IPC::RequestParser rp{ctx};
- struct Parameters {
- Core::IrSensor::IrCameraHandle camera_handle;
- Core::IrSensor::PackedTeraPluginProcessorConfig processor_config;
- INSERT_PADDING_WORDS_NOINIT(1);
- u64 applet_resource_user_id;
- };
- static_assert(sizeof(Parameters) == 0x18, "Parameters has incorrect size.");
+Result IRS::RunTeraPluginProcessor(Core::IrSensor::IrCameraHandle camera_handle,
+ Core::IrSensor::PackedTeraPluginProcessorConfig processor_config,
+ ClientAppletResourceUserId aruid) {
+ LOG_WARNING(Service_IRS,
+ "(STUBBED) called, npad_type={}, npad_id={}, mode={}, mcu_version={}.{}, "
+ "applet_resource_user_id={}",
+ camera_handle.npad_type, camera_handle.npad_id, processor_config.mode,
+ processor_config.required_mcu_version.major,
+ processor_config.required_mcu_version.minor, aruid.pid);
- const auto parameters{rp.PopRaw<Parameters>()};
+ R_TRY(IsIrCameraHandleValid(camera_handle));
- LOG_WARNING(
- Service_IRS,
- "(STUBBED) called, npad_type={}, npad_id={}, mode={}, mcu_version={}.{}, "
- "applet_resource_user_id={}",
- parameters.camera_handle.npad_type, parameters.camera_handle.npad_id,
- parameters.processor_config.mode, parameters.processor_config.required_mcu_version.major,
- parameters.processor_config.required_mcu_version.minor, parameters.applet_resource_user_id);
-
- const auto result = IsIrCameraHandleValid(parameters.camera_handle);
-
- if (result.IsSuccess()) {
- auto& device = GetIrCameraSharedMemoryDeviceEntry(parameters.camera_handle);
- MakeProcessor<TeraPluginProcessor>(parameters.camera_handle, device);
- auto& image_transfer_processor =
- GetProcessor<TeraPluginProcessor>(parameters.camera_handle);
- image_transfer_processor.SetConfig(parameters.processor_config);
- npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
- Common::Input::PollingMode::IR);
- }
+ auto& device = GetIrCameraSharedMemoryDeviceEntry(camera_handle);
+ MakeProcessor<TeraPluginProcessor>(camera_handle, device);
+ auto& image_transfer_processor = GetProcessor<TeraPluginProcessor>(camera_handle);
+ image_transfer_processor.SetConfig(processor_config);
+ npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
+ Common::Input::PollingMode::IR);
- IPC::ResponseBuilder rb{ctx, 2};
- rb.Push(result);
+ R_SUCCEED();
}
-void IRS::GetNpadIrCameraHandle(HLERequestContext& ctx) {
- IPC::RequestParser rp{ctx};
- const auto npad_id{rp.PopEnum<Core::HID::NpadIdType>()};
-
- if (npad_id > Core::HID::NpadIdType::Player8 && npad_id != Core::HID::NpadIdType::Invalid &&
- npad_id != Core::HID::NpadIdType::Handheld) {
- IPC::ResponseBuilder rb{ctx, 2};
- rb.Push(Service::HID::ResultInvalidNpadId);
- return;
- }
+Result IRS::GetNpadIrCameraHandle(Out<Core::IrSensor::IrCameraHandle> out_camera_handle,
+ Core::HID::NpadIdType npad_id) {
+ R_UNLESS(HID::IsNpadIdValid(npad_id), HID::ResultInvalidNpadId);
- Core::IrSensor::IrCameraHandle camera_handle{
+ *out_camera_handle = {
.npad_id = static_cast<u8>(HID::NpadIdTypeToIndex(npad_id)),
.npad_type = Core::HID::NpadStyleIndex::None,
};
LOG_INFO(Service_IRS, "called, npad_id={}, camera_npad_id={}, camera_npad_type={}", npad_id,
- camera_handle.npad_id, camera_handle.npad_type);
+ out_camera_handle->npad_id, out_camera_handle->npad_type);
- IPC::ResponseBuilder rb{ctx, 3};
- rb.Push(ResultSuccess);
- rb.PushRaw(camera_handle);
+ R_SUCCEED();
}
-void IRS::RunPointingProcessor(HLERequestContext& ctx) {
- IPC::RequestParser rp{ctx};
- const auto camera_handle{rp.PopRaw<Core::IrSensor::IrCameraHandle>()};
- const auto processor_config{rp.PopRaw<Core::IrSensor::PackedPointingProcessorConfig>()};
- const auto applet_resource_user_id{rp.Pop<u64>()};
-
+Result IRS::RunPointingProcessor(
+ Core::IrSensor::IrCameraHandle camera_handle,
+ const Core::IrSensor::PackedPointingProcessorConfig& processor_config,
+ ClientAppletResourceUserId aruid) {
LOG_WARNING(
Service_IRS,
"(STUBBED) called, npad_type={}, npad_id={}, mcu_version={}.{}, applet_resource_user_id={}",
camera_handle.npad_type, camera_handle.npad_id, processor_config.required_mcu_version.major,
- processor_config.required_mcu_version.minor, applet_resource_user_id);
+ processor_config.required_mcu_version.minor, aruid.pid);
- auto result = IsIrCameraHandleValid(camera_handle);
+ R_TRY(IsIrCameraHandleValid(camera_handle));
- if (result.IsSuccess()) {
- auto& device = GetIrCameraSharedMemoryDeviceEntry(camera_handle);
- MakeProcessor<PointingProcessor>(camera_handle, device);
- auto& image_transfer_processor = GetProcessor<PointingProcessor>(camera_handle);
- image_transfer_processor.SetConfig(processor_config);
- npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
- Common::Input::PollingMode::IR);
- }
+ auto& device = GetIrCameraSharedMemoryDeviceEntry(camera_handle);
+ MakeProcessor<PointingProcessor>(camera_handle, device);
+ auto& image_transfer_processor = GetProcessor<PointingProcessor>(camera_handle);
+ image_transfer_processor.SetConfig(processor_config);
+ npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
+ Common::Input::PollingMode::IR);
- IPC::ResponseBuilder rb{ctx, 2};
- rb.Push(result);
+ R_SUCCEED();
}
-void IRS::SuspendImageProcessor(HLERequestContext& ctx) {
- IPC::RequestParser rp{ctx};
- struct Parameters {
- Core::IrSensor::IrCameraHandle camera_handle;
- INSERT_PADDING_WORDS_NOINIT(1);
- u64 applet_resource_user_id;
- };
- static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size.");
-
- const auto parameters{rp.PopRaw<Parameters>()};
-
+Result IRS::SuspendImageProcessor(Core::IrSensor::IrCameraHandle camera_handle,
+ ClientAppletResourceUserId aruid) {
LOG_WARNING(Service_IRS,
"(STUBBED) called, npad_type={}, npad_id={}, applet_resource_user_id={}",
- parameters.camera_handle.npad_type, parameters.camera_handle.npad_id,
- parameters.applet_resource_user_id);
+ camera_handle.npad_type, camera_handle.npad_id, aruid.pid);
- auto result = IsIrCameraHandleValid(parameters.camera_handle);
- if (result.IsSuccess()) {
- // TODO: Suspend image processor
- result = ResultSuccess;
- }
+ R_TRY(IsIrCameraHandleValid(camera_handle));
- IPC::ResponseBuilder rb{ctx, 2};
- rb.Push(result);
-}
+ // TODO: Suspend image processor
-void IRS::CheckFirmwareVersion(HLERequestContext& ctx) {
- IPC::RequestParser rp{ctx};
- const auto camera_handle{rp.PopRaw<Core::IrSensor::IrCameraHandle>()};
- const auto mcu_version{rp.PopRaw<Core::IrSensor::PackedMcuVersion>()};
- const auto applet_resource_user_id{rp.Pop<u64>()};
+ R_SUCCEED();
+}
+Result IRS::CheckFirmwareVersion(Core::IrSensor::IrCameraHandle camera_handle,
+ Core::IrSensor::PackedMcuVersion mcu_version,
+ ClientAppletResourceUserId aruid) {
LOG_WARNING(
Service_IRS,
"(STUBBED) called, npad_type={}, npad_id={}, applet_resource_user_id={}, mcu_version={}.{}",
- camera_handle.npad_type, camera_handle.npad_id, applet_resource_user_id, mcu_version.major,
+ camera_handle.npad_type, camera_handle.npad_id, aruid.pid, mcu_version.major,
mcu_version.minor);
- auto result = IsIrCameraHandleValid(camera_handle);
- if (result.IsSuccess()) {
- // TODO: Check firmware version
- result = ResultSuccess;
- }
+ R_TRY(IsIrCameraHandleValid(camera_handle));
- IPC::ResponseBuilder rb{ctx, 2};
- rb.Push(result);
-}
+ // TODO: Check firmware version
-void IRS::SetFunctionLevel(HLERequestContext& ctx) {
- IPC::RequestParser rp{ctx};
- const auto camera_handle{rp.PopRaw<Core::IrSensor::IrCameraHandle>()};
- const auto function_level{rp.PopRaw<Core::IrSensor::PackedFunctionLevel>()};
- const auto applet_resource_user_id{rp.Pop<u64>()};
+ R_SUCCEED();
+}
+Result IRS::SetFunctionLevel(Core::IrSensor::IrCameraHandle camera_handle,
+ Core::IrSensor::PackedFunctionLevel function_level,
+ ClientAppletResourceUserId aruid) {
LOG_WARNING(
Service_IRS,
"(STUBBED) called, npad_type={}, npad_id={}, function_level={}, applet_resource_user_id={}",
- camera_handle.npad_type, camera_handle.npad_id, function_level.function_level,
- applet_resource_user_id);
+ camera_handle.npad_type, camera_handle.npad_id, function_level.function_level, aruid.pid);
- auto result = IsIrCameraHandleValid(camera_handle);
- if (result.IsSuccess()) {
- // TODO: Set Function level
- result = ResultSuccess;
- }
+ R_TRY(IsIrCameraHandleValid(camera_handle));
- IPC::ResponseBuilder rb{ctx, 2};
- rb.Push(result);
-}
+ // TODO: Set Function level
-void IRS::RunImageTransferExProcessor(HLERequestContext& ctx) {
- IPC::RequestParser rp{ctx};
- struct Parameters {
- Core::IrSensor::IrCameraHandle camera_handle;
- INSERT_PADDING_WORDS_NOINIT(1);
- u64 applet_resource_user_id;
- Core::IrSensor::PackedImageTransferProcessorExConfig processor_config;
- u64 transfer_memory_size;
- };
- static_assert(sizeof(Parameters) == 0x38, "Parameters has incorrect size.");
+ R_SUCCEED();
+}
- const auto parameters{rp.PopRaw<Parameters>()};
- const auto t_mem_handle{ctx.GetCopyHandle(0)};
+Result IRS::RunImageTransferExProcessor(
+ Core::IrSensor::IrCameraHandle camera_handle, ClientAppletResourceUserId aruid,
+ const Core::IrSensor::PackedImageTransferProcessorExConfig& processor_config,
+ u64 transfer_memory_size, InCopyHandle<Kernel::KTransferMemory> t_mem) {
- auto t_mem = ctx.GetObjectFromHandle<Kernel::KTransferMemory>(t_mem_handle);
+ ASSERT_MSG(t_mem->GetSize() == transfer_memory_size, "t_mem has incorrect size");
LOG_INFO(Service_IRS,
"called, npad_type={}, npad_id={}, transfer_memory_size={}, "
"applet_resource_user_id={}",
- parameters.camera_handle.npad_type, parameters.camera_handle.npad_id,
- parameters.transfer_memory_size, parameters.applet_resource_user_id);
-
- auto result = IsIrCameraHandleValid(parameters.camera_handle);
-
- if (result.IsSuccess()) {
- auto& device = GetIrCameraSharedMemoryDeviceEntry(parameters.camera_handle);
- MakeProcessorWithCoreContext<ImageTransferProcessor>(parameters.camera_handle, device);
- auto& image_transfer_processor =
- GetProcessor<ImageTransferProcessor>(parameters.camera_handle);
- image_transfer_processor.SetConfig(parameters.processor_config);
- image_transfer_processor.SetTransferMemoryAddress(t_mem->GetSourceAddress());
- npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
- Common::Input::PollingMode::IR);
- }
+ camera_handle.npad_type, camera_handle.npad_id, transfer_memory_size, aruid.pid);
- IPC::ResponseBuilder rb{ctx, 2};
- rb.Push(result);
-}
+ R_TRY(IsIrCameraHandleValid(camera_handle));
+
+ auto& device = GetIrCameraSharedMemoryDeviceEntry(camera_handle);
+ MakeProcessorWithCoreContext<ImageTransferProcessor>(camera_handle, device);
+ auto& image_transfer_processor = GetProcessor<ImageTransferProcessor>(camera_handle);
+ image_transfer_processor.SetConfig(processor_config);
+ image_transfer_processor.SetTransferMemoryAddress(t_mem->GetSourceAddress());
+ npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
+ Common::Input::PollingMode::IR);
-void IRS::RunIrLedProcessor(HLERequestContext& ctx) {
- IPC::RequestParser rp{ctx};
- const auto camera_handle{rp.PopRaw<Core::IrSensor::IrCameraHandle>()};
- const auto processor_config{rp.PopRaw<Core::IrSensor::PackedIrLedProcessorConfig>()};
- const auto applet_resource_user_id{rp.Pop<u64>()};
+ R_SUCCEED();
+}
+Result IRS::RunIrLedProcessor(Core::IrSensor::IrCameraHandle camera_handle,
+ Core::IrSensor::PackedIrLedProcessorConfig processor_config,
+ ClientAppletResourceUserId aruid) {
LOG_WARNING(Service_IRS,
"(STUBBED) called, npad_type={}, npad_id={}, light_target={}, mcu_version={}.{} "
"applet_resource_user_id={}",
camera_handle.npad_type, camera_handle.npad_id, processor_config.light_target,
processor_config.required_mcu_version.major,
- processor_config.required_mcu_version.minor, applet_resource_user_id);
+ processor_config.required_mcu_version.minor, aruid.pid);
- auto result = IsIrCameraHandleValid(camera_handle);
+ R_TRY(IsIrCameraHandleValid(camera_handle));
- if (result.IsSuccess()) {
- auto& device = GetIrCameraSharedMemoryDeviceEntry(camera_handle);
- MakeProcessor<IrLedProcessor>(camera_handle, device);
- auto& image_transfer_processor = GetProcessor<IrLedProcessor>(camera_handle);
- image_transfer_processor.SetConfig(processor_config);
- npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
- Common::Input::PollingMode::IR);
- }
+ auto& device = GetIrCameraSharedMemoryDeviceEntry(camera_handle);
+ MakeProcessor<IrLedProcessor>(camera_handle, device);
+ auto& image_transfer_processor = GetProcessor<IrLedProcessor>(camera_handle);
+ image_transfer_processor.SetConfig(processor_config);
+ npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
+ Common::Input::PollingMode::IR);
- IPC::ResponseBuilder rb{ctx, 2};
- rb.Push(result);
+ R_SUCCEED();
}
-void IRS::StopImageProcessorAsync(HLERequestContext& ctx) {
- IPC::RequestParser rp{ctx};
- struct Parameters {
- Core::IrSensor::IrCameraHandle camera_handle;
- INSERT_PADDING_WORDS_NOINIT(1);
- u64 applet_resource_user_id;
- };
- static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size.");
-
- const auto parameters{rp.PopRaw<Parameters>()};
-
+Result IRS::StopImageProcessorAsync(Core::IrSensor::IrCameraHandle camera_handle,
+ ClientAppletResourceUserId aruid) {
LOG_WARNING(Service_IRS,
"(STUBBED) called, npad_type={}, npad_id={}, applet_resource_user_id={}",
- parameters.camera_handle.npad_type, parameters.camera_handle.npad_id,
- parameters.applet_resource_user_id);
-
- auto result = IsIrCameraHandleValid(parameters.camera_handle);
- if (result.IsSuccess()) {
- // TODO: Stop image processor async
- npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
- Common::Input::PollingMode::Active);
- result = ResultSuccess;
- }
+ camera_handle.npad_type, camera_handle.npad_id, aruid.pid);
- IPC::ResponseBuilder rb{ctx, 2};
- rb.Push(result);
-}
+ R_TRY(IsIrCameraHandleValid(camera_handle));
-void IRS::ActivateIrsensorWithFunctionLevel(HLERequestContext& ctx) {
- IPC::RequestParser rp{ctx};
- struct Parameters {
- Core::IrSensor::PackedFunctionLevel function_level;
- INSERT_PADDING_WORDS_NOINIT(1);
- u64 applet_resource_user_id;
- };
- static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size.");
+ // TODO: Stop image processor async
+ npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
+ Common::Input::PollingMode::Active);
- const auto parameters{rp.PopRaw<Parameters>()};
+ R_SUCCEED();
+}
+Result IRS::ActivateIrsensorWithFunctionLevel(Core::IrSensor::PackedFunctionLevel function_level,
+ ClientAppletResourceUserId aruid) {
LOG_WARNING(Service_IRS, "(STUBBED) called, function_level={}, applet_resource_user_id={}",
- parameters.function_level.function_level, parameters.applet_resource_user_id);
-
- IPC::ResponseBuilder rb{ctx, 2};
- rb.Push(ResultSuccess);
+ function_level.function_level, aruid.pid);
+ R_SUCCEED();
}
Result IRS::IsIrCameraHandleValid(const Core::IrSensor::IrCameraHandle& camera_handle) const {
diff --git a/src/core/hle/service/hid/irs.h b/src/core/hle/service/hid/irs.h
index 06b7279ee..58dfee6c3 100644
--- a/src/core/hle/service/hid/irs.h
+++ b/src/core/hle/service/hid/irs.h
@@ -4,6 +4,7 @@
#pragma once
#include "core/core.h"
+#include "core/hle/service/cmif_types.h"
#include "core/hle/service/service.h"
#include "hid_core/hid_types.h"
#include "hid_core/irsensor/irs_types.h"
@@ -35,26 +36,73 @@ private:
};
static_assert(sizeof(StatusManager) == 0x8000, "StatusManager is an invalid size");
- void ActivateIrsensor(HLERequestContext& ctx);
- void DeactivateIrsensor(HLERequestContext& ctx);
- void GetIrsensorSharedMemoryHandle(HLERequestContext& ctx);
- void StopImageProcessor(HLERequestContext& ctx);
- void RunMomentProcessor(HLERequestContext& ctx);
- void RunClusteringProcessor(HLERequestContext& ctx);
- void RunImageTransferProcessor(HLERequestContext& ctx);
- void GetImageTransferProcessorState(HLERequestContext& ctx);
- void RunTeraPluginProcessor(HLERequestContext& ctx);
- void GetNpadIrCameraHandle(HLERequestContext& ctx);
- void RunPointingProcessor(HLERequestContext& ctx);
- void SuspendImageProcessor(HLERequestContext& ctx);
- void CheckFirmwareVersion(HLERequestContext& ctx);
- void SetFunctionLevel(HLERequestContext& ctx);
- void RunImageTransferExProcessor(HLERequestContext& ctx);
- void RunIrLedProcessor(HLERequestContext& ctx);
- void StopImageProcessorAsync(HLERequestContext& ctx);
- void ActivateIrsensorWithFunctionLevel(HLERequestContext& ctx);
+ Result ActivateIrsensor(ClientAppletResourceUserId aruid);
+
+ Result DeactivateIrsensor(ClientAppletResourceUserId aruid);
+
+ Result GetIrsensorSharedMemoryHandle(OutCopyHandle<Kernel::KSharedMemory> out_shared_memory,
+ ClientAppletResourceUserId aruid);
+ Result StopImageProcessor(Core::IrSensor::IrCameraHandle camera_handle,
+ ClientAppletResourceUserId aruid);
+
+ Result RunMomentProcessor(Core::IrSensor::IrCameraHandle camera_handle,
+ ClientAppletResourceUserId aruid,
+ const Core::IrSensor::PackedMomentProcessorConfig& processor_config);
+
+ Result RunClusteringProcessor(
+ Core::IrSensor::IrCameraHandle camera_handle, ClientAppletResourceUserId aruid,
+ const Core::IrSensor::PackedClusteringProcessorConfig& processor_config);
+
+ Result RunImageTransferProcessor(
+ Core::IrSensor::IrCameraHandle camera_handle, ClientAppletResourceUserId aruid,
+ const Core::IrSensor::PackedImageTransferProcessorConfig& processor_config,
+ u64 transfer_memory_size, InCopyHandle<Kernel::KTransferMemory> t_mem);
+
+ Result GetImageTransferProcessorState(
+ Out<Core::IrSensor::ImageTransferProcessorState> out_state,
+ Core::IrSensor::IrCameraHandle camera_handle, ClientAppletResourceUserId aruid,
+ OutBuffer<BufferAttr_HipcMapAlias> out_buffer_data);
+
+ Result RunTeraPluginProcessor(Core::IrSensor::IrCameraHandle camera_handle,
+ Core::IrSensor::PackedTeraPluginProcessorConfig processor_config,
+ ClientAppletResourceUserId aruid);
+
+ Result GetNpadIrCameraHandle(Out<Core::IrSensor::IrCameraHandle> out_camera_handle,
+ Core::HID::NpadIdType npad_id);
+
+ Result RunPointingProcessor(
+ Core::IrSensor::IrCameraHandle camera_handle,
+ const Core::IrSensor::PackedPointingProcessorConfig& processor_config,
+ ClientAppletResourceUserId aruid);
+
+ Result SuspendImageProcessor(Core::IrSensor::IrCameraHandle camera_handle,
+ ClientAppletResourceUserId aruid);
+
+ Result CheckFirmwareVersion(Core::IrSensor::IrCameraHandle camera_handle,
+ Core::IrSensor::PackedMcuVersion mcu_version,
+ ClientAppletResourceUserId aruid);
+
+ Result SetFunctionLevel(Core::IrSensor::IrCameraHandle camera_handle,
+ Core::IrSensor::PackedFunctionLevel function_level,
+ ClientAppletResourceUserId aruid);
+
+ Result RunImageTransferExProcessor(
+ Core::IrSensor::IrCameraHandle camera_handle, ClientAppletResourceUserId aruid,
+ const Core::IrSensor::PackedImageTransferProcessorExConfig& processor_config,
+ u64 transfer_memory_size, InCopyHandle<Kernel::KTransferMemory> t_mem);
+
+ Result RunIrLedProcessor(Core::IrSensor::IrCameraHandle camera_handle,
+ Core::IrSensor::PackedIrLedProcessorConfig processor_config,
+ ClientAppletResourceUserId aruid);
+
+ Result StopImageProcessorAsync(Core::IrSensor::IrCameraHandle camera_handle,
+ ClientAppletResourceUserId aruid);
+
+ Result ActivateIrsensorWithFunctionLevel(Core::IrSensor::PackedFunctionLevel function_level,
+ ClientAppletResourceUserId aruid);
Result IsIrCameraHandleValid(const Core::IrSensor::IrCameraHandle& camera_handle) const;
+
Core::IrSensor::DeviceFormat& GetIrCameraSharedMemoryDeviceEntry(
const Core::IrSensor::IrCameraHandle& camera_handle);
diff --git a/src/core/hle/service/nvdrv/core/heap_mapper.cpp b/src/core/hle/service/nvdrv/core/heap_mapper.cpp
index 096dc5deb..af17e3e85 100644
--- a/src/core/hle/service/nvdrv/core/heap_mapper.cpp
+++ b/src/core/hle/service/nvdrv/core/heap_mapper.cpp
@@ -3,110 +3,21 @@
#include <mutex>
-#include <boost/container/small_vector.hpp>
-#define BOOST_NO_MT
-#include <boost/pool/detail/mutex.hpp>
-#undef BOOST_NO_MT
-#include <boost/icl/interval.hpp>
-#include <boost/icl/interval_base_set.hpp>
-#include <boost/icl/interval_set.hpp>
-#include <boost/icl/split_interval_map.hpp>
-#include <boost/pool/pool.hpp>
-#include <boost/pool/pool_alloc.hpp>
-#include <boost/pool/poolfwd.hpp>
-
+#include "common/range_sets.h"
+#include "common/range_sets.inc"
#include "core/hle/service/nvdrv/core/heap_mapper.h"
#include "video_core/host1x/host1x.h"
-namespace boost {
-template <typename T>
-class fast_pool_allocator<T, default_user_allocator_new_delete, details::pool::null_mutex, 4096, 0>;
-}
-
namespace Service::Nvidia::NvCore {
-using IntervalCompare = std::less<DAddr>;
-using IntervalInstance = boost::icl::interval_type_default<DAddr, std::less>;
-using IntervalAllocator = boost::fast_pool_allocator<DAddr>;
-using IntervalSet = boost::icl::interval_set<DAddr>;
-using IntervalType = typename IntervalSet::interval_type;
-
-template <typename Type>
-struct counter_add_functor : public boost::icl::identity_based_inplace_combine<Type> {
- // types
- typedef counter_add_functor<Type> type;
- typedef boost::icl::identity_based_inplace_combine<Type> base_type;
-
- // public member functions
- void operator()(Type& current, const Type& added) const {
- current += added;
- if (current < base_type::identity_element()) {
- current = base_type::identity_element();
- }
- }
-
- // public static functions
- static void version(Type&){};
-};
-
-using OverlapCombine = counter_add_functor<int>;
-using OverlapSection = boost::icl::inter_section<int>;
-using OverlapCounter = boost::icl::split_interval_map<DAddr, int>;
-
struct HeapMapper::HeapMapperInternal {
- HeapMapperInternal(Tegra::Host1x::Host1x& host1x) : device_memory{host1x.MemoryManager()} {}
+ HeapMapperInternal(Tegra::Host1x::Host1x& host1x) : m_device_memory{host1x.MemoryManager()} {}
~HeapMapperInternal() = default;
- template <typename Func>
- void ForEachInOverlapCounter(OverlapCounter& current_range, VAddr cpu_addr, u64 size,
- Func&& func) {
- const DAddr start_address = cpu_addr;
- const DAddr end_address = start_address + size;
- const IntervalType search_interval{start_address, end_address};
- auto it = current_range.lower_bound(search_interval);
- if (it == current_range.end()) {
- return;
- }
- auto end_it = current_range.upper_bound(search_interval);
- for (; it != end_it; it++) {
- auto& inter = it->first;
- DAddr inter_addr_end = inter.upper();
- DAddr inter_addr = inter.lower();
- if (inter_addr_end > end_address) {
- inter_addr_end = end_address;
- }
- if (inter_addr < start_address) {
- inter_addr = start_address;
- }
- func(inter_addr, inter_addr_end, it->second);
- }
- }
-
- void RemoveEachInOverlapCounter(OverlapCounter& current_range,
- const IntervalType search_interval, int subtract_value) {
- bool any_removals = false;
- current_range.add(std::make_pair(search_interval, subtract_value));
- do {
- any_removals = false;
- auto it = current_range.lower_bound(search_interval);
- if (it == current_range.end()) {
- return;
- }
- auto end_it = current_range.upper_bound(search_interval);
- for (; it != end_it; it++) {
- if (it->second <= 0) {
- any_removals = true;
- current_range.erase(it);
- break;
- }
- }
- } while (any_removals);
- }
-
- IntervalSet base_set;
- OverlapCounter mapping_overlaps;
- Tegra::MaxwellDeviceMemoryManager& device_memory;
- std::mutex guard;
+ Common::RangeSet<VAddr> m_temporary_set;
+ Common::OverlapRangeSet<VAddr> m_mapped_ranges;
+ Tegra::MaxwellDeviceMemoryManager& m_device_memory;
+ std::mutex m_guard;
};
HeapMapper::HeapMapper(VAddr start_vaddress, DAddr start_daddress, size_t size, Core::Asid asid,
@@ -116,60 +27,48 @@ HeapMapper::HeapMapper(VAddr start_vaddress, DAddr start_daddress, size_t size,
}
HeapMapper::~HeapMapper() {
- m_internal->device_memory.Unmap(m_daddress, m_size);
+ // Unmap whatever has been mapped.
+ m_internal->m_mapped_ranges.ForEach([this](VAddr start_addr, VAddr end_addr, s32 count) {
+ const size_t sub_size = end_addr - start_addr;
+ const size_t offset = start_addr - m_vaddress;
+ m_internal->m_device_memory.Unmap(m_daddress + offset, sub_size);
+ });
}
DAddr HeapMapper::Map(VAddr start, size_t size) {
- std::scoped_lock lk(m_internal->guard);
- m_internal->base_set.clear();
- const IntervalType interval{start, start + size};
- m_internal->base_set.insert(interval);
- m_internal->ForEachInOverlapCounter(m_internal->mapping_overlaps, start, size,
- [this](VAddr start_addr, VAddr end_addr, int) {
- const IntervalType other{start_addr, end_addr};
- m_internal->base_set.subtract(other);
- });
- if (!m_internal->base_set.empty()) {
- auto it = m_internal->base_set.begin();
- auto end_it = m_internal->base_set.end();
- for (; it != end_it; it++) {
- const VAddr inter_addr_end = it->upper();
- const VAddr inter_addr = it->lower();
- const size_t offset = inter_addr - m_vaddress;
- const size_t sub_size = inter_addr_end - inter_addr;
- m_internal->device_memory.Map(m_daddress + offset, m_vaddress + offset, sub_size,
- m_asid);
- }
- }
- m_internal->mapping_overlaps += std::make_pair(interval, 1);
- m_internal->base_set.clear();
- return m_daddress + (start - m_vaddress);
+ std::scoped_lock lk(m_internal->m_guard);
+ // Add the mapping range to a temporary range set.
+ m_internal->m_temporary_set.Clear();
+ m_internal->m_temporary_set.Add(start, size);
+
+ // Remove anything that's already mapped from the temporary range set.
+ m_internal->m_mapped_ranges.ForEachInRange(
+ start, size, [this](VAddr start_addr, VAddr end_addr, s32) {
+ m_internal->m_temporary_set.Subtract(start_addr, end_addr - start_addr);
+ });
+
+ // Map anything that has not been mapped yet.
+ m_internal->m_temporary_set.ForEach([this](VAddr start_addr, VAddr end_addr) {
+ const size_t sub_size = end_addr - start_addr;
+ const size_t offset = start_addr - m_vaddress;
+ m_internal->m_device_memory.Map(m_daddress + offset, m_vaddress + offset, sub_size, m_asid);
+ });
+
+ // Add the mapping range to the split map, to register the map and overlaps.
+ m_internal->m_mapped_ranges.Add(start, size);
+ m_internal->m_temporary_set.Clear();
+ return m_daddress + static_cast<DAddr>(start - m_vaddress);
}
void HeapMapper::Unmap(VAddr start, size_t size) {
- std::scoped_lock lk(m_internal->guard);
- m_internal->base_set.clear();
- m_internal->ForEachInOverlapCounter(m_internal->mapping_overlaps, start, size,
- [this](VAddr start_addr, VAddr end_addr, int value) {
- if (value <= 1) {
- const IntervalType other{start_addr, end_addr};
- m_internal->base_set.insert(other);
- }
- });
- if (!m_internal->base_set.empty()) {
- auto it = m_internal->base_set.begin();
- auto end_it = m_internal->base_set.end();
- for (; it != end_it; it++) {
- const VAddr inter_addr_end = it->upper();
- const VAddr inter_addr = it->lower();
- const size_t offset = inter_addr - m_vaddress;
- const size_t sub_size = inter_addr_end - inter_addr;
- m_internal->device_memory.Unmap(m_daddress + offset, sub_size);
- }
- }
- const IntervalType to_remove{start, start + size};
- m_internal->RemoveEachInOverlapCounter(m_internal->mapping_overlaps, to_remove, -1);
- m_internal->base_set.clear();
+ std::scoped_lock lk(m_internal->m_guard);
+
+ // Just subtract the range and whatever is deleted, unmap it.
+ m_internal->m_mapped_ranges.Subtract(start, size, [this](VAddr start_addr, VAddr end_addr) {
+ const size_t sub_size = end_addr - start_addr;
+ const size_t offset = start_addr - m_vaddress;
+ m_internal->m_device_memory.Unmap(m_daddress + offset, sub_size);
+ });
}
} // namespace Service::Nvidia::NvCore
diff --git a/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp b/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp
index e6646ba04..68fe38874 100644
--- a/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp
@@ -123,6 +123,8 @@ NvResult nvhost_as_gpu::AllocAsEx(IoctlAllocAsEx& params) {
vm.va_range_end = params.va_range_end;
}
+ const u64 max_big_page_bits = Common::Log2Ceil64(vm.va_range_end);
+
const auto start_pages{static_cast<u32>(vm.va_range_start >> VM::PAGE_SIZE_BITS)};
const auto end_pages{static_cast<u32>(vm.va_range_split >> VM::PAGE_SIZE_BITS)};
vm.small_page_allocator = std::make_shared<VM::Allocator>(start_pages, end_pages);
@@ -132,8 +134,8 @@ NvResult nvhost_as_gpu::AllocAsEx(IoctlAllocAsEx& params) {
static_cast<u32>((vm.va_range_end - vm.va_range_split) >> vm.big_page_size_bits)};
vm.big_page_allocator = std::make_unique<VM::Allocator>(start_big_pages, end_big_pages);
- gmmu = std::make_shared<Tegra::MemoryManager>(system, 40, vm.big_page_size_bits,
- VM::PAGE_SIZE_BITS);
+ gmmu = std::make_shared<Tegra::MemoryManager>(system, max_big_page_bits, vm.va_range_split,
+ vm.big_page_size_bits, VM::PAGE_SIZE_BITS);
system.GPU().InitAddressSpace(*gmmu);
vm.initialised = true;
diff --git a/src/core/memory/cheat_engine.cpp b/src/core/memory/cheat_engine.cpp
index f3b8243d5..b84b57d92 100644
--- a/src/core/memory/cheat_engine.cpp
+++ b/src/core/memory/cheat_engine.cpp
@@ -5,6 +5,7 @@
#include "common/hex_util.h"
#include "common/microprofile.h"
#include "common/swap.h"
+#include "core/arm/debug.h"
#include "core/core.h"
#include "core/core_timing.h"
#include "core/hle/kernel/k_page_table.h"
@@ -64,7 +65,9 @@ void StandardVmCallbacks::MemoryWriteUnsafe(VAddr address, const void* data, u64
return;
}
- system.ApplicationMemory().WriteBlock(address, data, size);
+ if (system.ApplicationMemory().WriteBlock(address, data, size)) {
+ Core::InvalidateInstructionCacheRange(system.ApplicationProcess(), address, size);
+ }
}
u64 StandardVmCallbacks::HidKeysDown() {