ShuriZma
/
xenia-canary
mirror of https://github.com/xenia-canary/xenia-canary.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[Kernel] Move xam_input to new shim convention.

This commit is contained in:
gibbed 2018-05-27 16:59:07 -05:00
parent 4cc2aaf5b9
commit ee7b9f415a
1 changed files with 93 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

248
src/xenia/kernel/xam/xam_input.cc
View File

@ -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<X_INPUT_CAPABILITIES> 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<X_INPUT_CAPABILITIES> 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<X_INPUT_STATE> 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<X_INPUT_VIBRATION> 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<X_INPUT_KEYSTROKE> 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<X_INPUT_KEYSTROKE> 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