From ee7b9f415a6fb6bc300f14b958de2ffc07bab280 Mon Sep 17 00:00:00 2001 From: gibbed Date: Sun, 27 May 2018 16:59:07 -0500 Subject: [PATCH] [Kernel] Move xam_input to new shim convention. --- src/xenia/kernel/xam/xam_input.cc | 248 +++++++++++------------------- 1 file changed, 93 insertions(+), 155 deletions(-) diff --git a/src/xenia/kernel/xam/xam_input.cc b/src/xenia/kernel/xam/xam_input.cc index 328d1d6c0..f0bf0fc5b 100644 --- a/src/xenia/kernel/xam/xam_input.cc +++ b/src/xenia/kernel/xam/xam_input.cc @@ -28,243 +28,181 @@ using xe::hid::X_INPUT_VIBRATION; constexpr uint32_t XINPUT_FLAG_GAMEPAD = 0x01; constexpr uint32_t XINPUT_FLAG_ANY_USER = 1 << 30; -SHIM_CALL XamResetInactivity_shim(PPCContext* ppc_context, - KernelState* kernel_state) { - uint32_t unk = SHIM_GET_ARG_32(0); - - XELOGD("XamResetInactivity(%d)", unk); - +dword_result_t XamResetInactivity(dword_t unk) { // Result ignored. - SHIM_SET_RETURN_32(0); + return 0; } +DECLARE_XAM_EXPORT(XamResetInactivity, ExportTag::kInput | ExportTag::kStub); -SHIM_CALL XamEnableInactivityProcessing_shim(PPCContext* ppc_context, - KernelState* kernel_state) { - uint32_t zero = SHIM_GET_ARG_32(0); - uint32_t unk = SHIM_GET_ARG_32(1); - - XELOGD("XamEnableInactivityProcessing(%d, %d)", zero, unk); - +dword_result_t XamEnableInactivityProcessing(dword_t zero, dword_t unk) { // Expects 0. - SHIM_SET_RETURN_32(0); + return 0; } +DECLARE_XAM_EXPORT(XamEnableInactivityProcessing, + ExportTag::kInput | ExportTag::kStub); // http://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.reference.xinputgetcapabilities(v=vs.85).aspx -SHIM_CALL XamInputGetCapabilities_shim(PPCContext* ppc_context, - KernelState* kernel_state) { - uint32_t user_index = SHIM_GET_ARG_32(0); - uint32_t flags = SHIM_GET_ARG_32(1); - uint32_t caps_ptr = SHIM_GET_ARG_32(2); - - XELOGD("XamInputGetCapabilities(%d, %.8X, %.8X)", user_index, flags, - caps_ptr); - - if (!caps_ptr) { - SHIM_SET_RETURN_32(X_ERROR_BAD_ARGUMENTS); - return; +dword_result_t XamInputGetCapabilities(dword_t user_index, dword_t flags, + pointer_t caps) { + if (!caps) { + return X_ERROR_BAD_ARGUMENTS; } + if ((flags & 0xFF) && (flags & XINPUT_FLAG_GAMEPAD) == 0) { // Ignore any query for other types of devices. - SHIM_SET_RETURN_32(X_ERROR_DEVICE_NOT_CONNECTED); - return; + return X_ERROR_DEVICE_NOT_CONNECTED; } - if ((user_index & 0xFF) == 0xFF || (flags & XINPUT_FLAG_ANY_USER)) { + + uint32_t actual_user_index = user_index; + if ((actual_user_index & 0xFF) == 0xFF || (flags & XINPUT_FLAG_ANY_USER)) { // Always pin user to 0. - user_index = 0; + actual_user_index = 0; } - auto input_system = kernel_state->emulator()->input_system(); - - auto caps = SHIM_STRUCT(X_INPUT_CAPABILITIES, caps_ptr); - X_RESULT result = input_system->GetCapabilities(user_index, flags, caps); - SHIM_SET_RETURN_32(result); + auto input_system = kernel_state()->emulator()->input_system(); + return input_system->GetCapabilities(actual_user_index, flags, caps); } +DECLARE_XAM_EXPORT(XamInputGetCapabilities, + ExportTag::kInput | ExportTag::kSketchy); -SHIM_CALL XamInputGetCapabilitiesEx_shim(PPCContext* ppc_context, - KernelState* kernel_state) { - uint32_t unk = SHIM_GET_ARG_32(0); - uint32_t user_index = SHIM_GET_ARG_32(1); - uint32_t flags = SHIM_GET_ARG_32(2); - uint32_t caps_ptr = SHIM_GET_ARG_32(3); - - XELOGD("XamInputGetCapabilitiesEx(%d, %d, %.8X, %.8X)", unk, user_index, - flags, caps_ptr); - - if (!caps_ptr) { - SHIM_SET_RETURN_32(X_ERROR_BAD_ARGUMENTS); - return; +dword_result_t XamInputGetCapabilitiesEx(dword_t unk, dword_t user_index, + dword_t flags, + pointer_t caps) { + if (!caps) { + return X_ERROR_BAD_ARGUMENTS; } + if ((flags & 0xFF) && (flags & XINPUT_FLAG_GAMEPAD) == 0) { // Ignore any query for other types of devices. - SHIM_SET_RETURN_32(X_ERROR_DEVICE_NOT_CONNECTED); - return; + return X_ERROR_DEVICE_NOT_CONNECTED; } - if ((user_index & 0xFF) == 0xFF || (flags & XINPUT_FLAG_ANY_USER)) { + + uint32_t actual_user_index = user_index; + if ((actual_user_index & 0xFF) == 0xFF || (flags & XINPUT_FLAG_ANY_USER)) { // Always pin user to 0. - user_index = 0; + actual_user_index = 0; } - auto input_system = kernel_state->emulator()->input_system(); - - auto caps = SHIM_STRUCT(X_INPUT_CAPABILITIES, caps_ptr); - X_RESULT result = input_system->GetCapabilities(user_index, flags, caps); - SHIM_SET_RETURN_32(result); + auto input_system = kernel_state()->emulator()->input_system(); + return input_system->GetCapabilities(actual_user_index, flags, caps); } +DECLARE_XAM_EXPORT(XamInputGetCapabilitiesEx, + ExportTag::kInput | ExportTag::kSketchy); // http://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.reference.xinputgetstate(v=vs.85).aspx -SHIM_CALL XamInputGetState_shim(PPCContext* ppc_context, - KernelState* kernel_state) { - uint32_t user_index = SHIM_GET_ARG_32(0); - uint32_t flags = SHIM_GET_ARG_32(1); - uint32_t state_ptr = SHIM_GET_ARG_32(2); - - XELOGD("XamInputGetState(%d, %.8X, %.8X)", user_index, flags, state_ptr); - +dword_result_t XamInputGetState(dword_t user_index, dword_t flags, + pointer_t input_state) { // Games call this with a NULL state ptr, probably as a query. if ((flags & 0xFF) && (flags & XINPUT_FLAG_GAMEPAD) == 0) { // Ignore any query for other types of devices. - SHIM_SET_RETURN_32(X_ERROR_DEVICE_NOT_CONNECTED); - return; + return X_ERROR_DEVICE_NOT_CONNECTED; } - if ((user_index & 0xFF) == 0xFF || (flags & XINPUT_FLAG_ANY_USER)) { + + uint32_t actual_user_index = user_index; + if ((actual_user_index & 0xFF) == 0xFF || (flags & XINPUT_FLAG_ANY_USER)) { // Always pin user to 0. - user_index = 0; + actual_user_index = 0; } - auto input_system = kernel_state->emulator()->input_system(); - - auto input_state = SHIM_STRUCT(X_INPUT_STATE, state_ptr); - X_RESULT result = input_system->GetState(user_index, input_state); - SHIM_SET_RETURN_32(result); + auto input_system = kernel_state()->emulator()->input_system(); + return input_system->GetState(user_index, input_state); } +DECLARE_XAM_EXPORT(XamInputGetState, + ExportTag::kInput | ExportTag::kImplemented); // http://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.reference.xinputsetstate(v=vs.85).aspx -SHIM_CALL XamInputSetState_shim(PPCContext* ppc_context, - KernelState* kernel_state) { - uint32_t user_index = SHIM_GET_ARG_32(0); - uint32_t unk = SHIM_GET_ARG_32(1); - uint32_t vibration_ptr = SHIM_GET_ARG_32(2); - - XELOGD("XamInputSetState(%d, %.8X, %.8X)", user_index, unk, vibration_ptr); - - if (!vibration_ptr) { - SHIM_SET_RETURN_32(X_ERROR_BAD_ARGUMENTS); - return; +dword_result_t XamInputSetState(dword_t user_index, dword_t unk, + pointer_t vibration) { + if (!vibration) { + return X_ERROR_BAD_ARGUMENTS; } + + uint32_t actual_user_index = user_index; if ((user_index & 0xFF) == 0xFF) { // Always pin user to 0. - user_index = 0; + actual_user_index = 0; } - auto input_system = kernel_state->emulator()->input_system(); - - auto vibration = SHIM_STRUCT(X_INPUT_VIBRATION, vibration_ptr); - X_RESULT result = input_system->SetState(user_index, vibration); - SHIM_SET_RETURN_32(result); + auto input_system = kernel_state()->emulator()->input_system(); + return input_system->SetState(user_index, vibration); } +DECLARE_XAM_EXPORT(XamInputSetState, + ExportTag::kInput | ExportTag::kImplemented); // http://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.reference.xinputgetkeystroke(v=vs.85).aspx -SHIM_CALL XamInputGetKeystroke_shim(PPCContext* ppc_context, - KernelState* kernel_state) { - uint32_t user_index = SHIM_GET_ARG_32(0); - uint32_t flags = SHIM_GET_ARG_32(1); - uint32_t keystroke_ptr = SHIM_GET_ARG_32(2); - +dword_result_t XamInputGetKeystroke(dword_t user_index, dword_t flags, + pointer_t keystroke) { // http://ffplay360.googlecode.com/svn/Test/Common/AtgXime.cpp // user index = index or XUSER_INDEX_ANY // flags = XINPUT_FLAG_GAMEPAD (| _ANYUSER | _ANYDEVICE) - XELOGD("XamInputGetKeystroke(%d, %.8X, %.8X)", user_index, flags, - keystroke_ptr); - - if (!keystroke_ptr) { - SHIM_SET_RETURN_32(X_ERROR_BAD_ARGUMENTS); - return; + if (!keystroke) { + return X_ERROR_BAD_ARGUMENTS; } + if ((flags & 0xFF) && (flags & XINPUT_FLAG_GAMEPAD) == 0) { // Ignore any query for other types of devices. - SHIM_SET_RETURN_32(X_ERROR_DEVICE_NOT_CONNECTED); - return; + return X_ERROR_DEVICE_NOT_CONNECTED; } - if ((user_index & 0xFF) == 0xFF || (flags & XINPUT_FLAG_ANY_USER)) { + + uint32_t actual_user_index = user_index; + if ((actual_user_index & 0xFF) == 0xFF || (flags & XINPUT_FLAG_ANY_USER)) { // Always pin user to 0. - user_index = 0; + actual_user_index = 0; } - auto input_system = kernel_state->emulator()->input_system(); - - auto keystroke = SHIM_STRUCT(X_INPUT_KEYSTROKE, keystroke_ptr); - X_RESULT result = input_system->GetKeystroke(user_index, flags, keystroke); - SHIM_SET_RETURN_32(result); + auto input_system = kernel_state()->emulator()->input_system(); + return input_system->GetKeystroke(user_index, flags, keystroke); } +DECLARE_XAM_EXPORT(XamInputGetKeystroke, + ExportTag::kInput | ExportTag::kImplemented); // Same as non-ex, just takes a pointer to user index. -SHIM_CALL XamInputGetKeystrokeEx_shim(PPCContext* ppc_context, - KernelState* kernel_state) { - uint32_t user_index_ptr = SHIM_GET_ARG_32(0); - uint32_t flags = SHIM_GET_ARG_32(1); - uint32_t keystroke_ptr = SHIM_GET_ARG_32(2); - - uint32_t user_index = SHIM_MEM_32(user_index_ptr); - - XELOGD("XamInputGetKeystrokeEx(%.8X(%d), %.8X, %.8X)", user_index_ptr, - user_index, flags, keystroke_ptr); - - if (!keystroke_ptr) { - SHIM_SET_RETURN_32(X_ERROR_BAD_ARGUMENTS); - return; +dword_result_t XamInputGetKeystrokeEx(lpdword_t user_index_ptr, dword_t flags, + pointer_t keystroke) { + if (!keystroke) { + return X_ERROR_BAD_ARGUMENTS; } + if ((flags & 0xFF) && (flags & XINPUT_FLAG_GAMEPAD) == 0) { // Ignore any query for other types of devices. - SHIM_SET_RETURN_32(X_ERROR_DEVICE_NOT_CONNECTED); - return; + return X_ERROR_DEVICE_NOT_CONNECTED; } + + uint32_t user_index = *user_index_ptr; if ((user_index & 0xFF) == 0xFF || (flags & XINPUT_FLAG_ANY_USER)) { // Always pin user to 0. user_index = 0; } - auto input_system = kernel_state->emulator()->input_system(); - - auto keystroke = SHIM_STRUCT(X_INPUT_KEYSTROKE, keystroke_ptr); - X_RESULT result = input_system->GetKeystroke(user_index, flags, keystroke); + auto input_system = kernel_state()->emulator()->input_system(); + auto result = input_system->GetKeystroke(user_index, flags, keystroke); if (XSUCCEEDED(result)) { - SHIM_SET_MEM_32(user_index_ptr, keystroke->user_index); + *user_index_ptr = keystroke->user_index; } - SHIM_SET_RETURN_32(result); + return result; } +DECLARE_XAM_EXPORT(XamInputGetKeystrokeEx, + ExportTag::kInput | ExportTag::kImplemented); -SHIM_CALL XamUserGetDeviceContext_shim(PPCContext* ppc_context, - KernelState* kernel_state) { - uint32_t user_index = SHIM_GET_ARG_32(0); - uint32_t unk = SHIM_GET_ARG_32(1); - uint32_t out_ptr = SHIM_GET_ARG_32(2); - - XELOGD("XamUserGetDeviceContext(%d, %d, %.8X)", user_index, unk, out_ptr); - +dword_result_t XamUserGetDeviceContext(dword_t user_index, dword_t unk, + lpdword_t out_ptr) { // Games check the result - usually with some masking. // If this function fails they assume zero, so let's fail AND // set zero just to be safe. - SHIM_SET_MEM_32(out_ptr, 0); + *out_ptr = 0; if (!user_index || (user_index & 0xFF) == 0xFF) { - SHIM_SET_RETURN_32(0); + return 0; } else { - SHIM_SET_RETURN_32(-1); + return -1; } } +DECLARE_XAM_EXPORT(XamUserGetDeviceContext, + ExportTag::kInput | ExportTag::kStub); void RegisterInputExports(xe::cpu::ExportResolver* export_resolver, KernelState* kernel_state) { - SHIM_SET_MAPPING("xam.xex", XamResetInactivity, state); - SHIM_SET_MAPPING("xam.xex", XamEnableInactivityProcessing, state); - SHIM_SET_MAPPING("xam.xex", XamInputGetCapabilities, state); - SHIM_SET_MAPPING("xam.xex", XamInputGetCapabilitiesEx, state); - SHIM_SET_MAPPING("xam.xex", XamInputGetState, state); - SHIM_SET_MAPPING("xam.xex", XamInputSetState, state); - SHIM_SET_MAPPING("xam.xex", XamInputGetKeystroke, state); - SHIM_SET_MAPPING("xam.xex", XamInputGetKeystrokeEx, state); - SHIM_SET_MAPPING("xam.xex", XamUserGetDeviceContext, state); } } // namespace xam