Sweden-Number/dlls/xinput1_3/hid.c

514 lines
18 KiB
C
Raw Normal View History

/*
* The Wine project - Xinput Joystick HID interface
* Copyright 2018 Aric Stewart
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <assert.h>
#include <stdarg.h>
#include <string.h>
#include "wine/debug.h"
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "winerror.h"
#include "winreg.h"
#include "wingdi.h"
#include "winnls.h"
#include "winternl.h"
#include "setupapi.h"
#include "devpkey.h"
#include "hidusage.h"
#include "ddk/hidsdi.h"
#include "initguid.h"
#include "devguid.h"
#include "xinput.h"
#include "xinput_private.h"
WINE_DEFAULT_DEBUG_CHANNEL(xinput);
#define XINPUT_GAMEPAD_GUIDE 0x0400
struct axis_info
{
LONG min;
LONG range;
USHORT bits;
};
struct hid_platform_private {
PHIDP_PREPARSED_DATA ppd;
HANDLE device;
WCHAR *device_path;
BOOL enabled;
DWORD report_length;
BYTE current_report;
CHAR *reports[2];
struct axis_info lx, ly, ltrigger, rx, ry, rtrigger;
};
static DWORD last_check = 0;
static void MarkUsage(struct hid_platform_private *private, WORD usage, LONG min, LONG max, USHORT bits)
{
struct axis_info info = {min, max-min, bits};
switch (usage)
{
case HID_USAGE_GENERIC_X: private->lx = info; break;
case HID_USAGE_GENERIC_Y: private->ly = info; break;
case HID_USAGE_GENERIC_Z: private->ltrigger = info; break;
case HID_USAGE_GENERIC_RX: private->rx = info; break;
case HID_USAGE_GENERIC_RY: private->ry = info; break;
case HID_USAGE_GENERIC_RZ: private->rtrigger = info; break;
}
}
static BOOL VerifyGamepad(PHIDP_PREPARSED_DATA ppd, XINPUT_CAPABILITIES *xinput_caps, struct hid_platform_private *private, HIDP_CAPS *caps)
{
HIDP_BUTTON_CAPS *button_caps;
HIDP_VALUE_CAPS *value_caps;
int i;
int button_count = 0;
USHORT button_caps_count = 0;
USHORT value_caps_count = 0;
/* Count buttons */
memset(xinput_caps, 0, sizeof(XINPUT_CAPABILITIES));
button_caps_count = caps->NumberInputButtonCaps;
button_caps = HeapAlloc(GetProcessHeap(), 0, sizeof(*button_caps) * button_caps_count);
HidP_GetButtonCaps(HidP_Input, button_caps, &button_caps_count, ppd);
for (i = 0; i < button_caps_count; i++)
{
if (button_caps[i].UsagePage != HID_USAGE_PAGE_BUTTON)
continue;
if (button_caps[i].IsRange)
button_count = max(button_count, button_caps[i].Range.UsageMax);
else
button_count = max(button_count, button_caps[i].NotRange.Usage);
}
HeapFree(GetProcessHeap(), 0, button_caps);
if (button_count < 11)
WARN("Too few buttons, continuing anyway\n");
xinput_caps->Gamepad.wButtons = 0xffff;
value_caps_count = caps->NumberInputValueCaps;
value_caps = HeapAlloc(GetProcessHeap(), 0, sizeof(*value_caps) * value_caps_count);
HidP_GetValueCaps(HidP_Input, value_caps, &value_caps_count, ppd);
for (i = 0; i < value_caps_count; i++)
{
if (value_caps[i].UsagePage != HID_USAGE_PAGE_GENERIC)
continue;
if (value_caps[i].IsRange)
{
int u;
for (u = value_caps[i].Range.UsageMin; u <=value_caps[i].Range.UsageMax; u++)
MarkUsage(private, u, value_caps[i].LogicalMin, value_caps[i].LogicalMax, value_caps[i].BitSize);
}
else
MarkUsage(private, value_caps[i].NotRange.Usage, value_caps[i].LogicalMin, value_caps[i].LogicalMax, value_caps[i].BitSize);
}
HeapFree(GetProcessHeap(), 0, value_caps);
if (private->ltrigger.bits)
xinput_caps->Gamepad.bLeftTrigger = (1u << (sizeof(xinput_caps->Gamepad.bLeftTrigger) + 1)) - 1;
else
WARN("Missing axis LeftTrigger\n");
if (private->rtrigger.bits)
xinput_caps->Gamepad.bRightTrigger = (1u << (sizeof(xinput_caps->Gamepad.bRightTrigger) + 1)) - 1;
else
WARN("Missing axis RightTrigger\n");
if (private->lx.bits)
xinput_caps->Gamepad.sThumbLX = (1u << (sizeof(xinput_caps->Gamepad.sThumbLX) + 1)) - 1;
else
WARN("Missing axis ThumbLX\n");
if (private->ly.bits)
xinput_caps->Gamepad.sThumbLY = (1u << (sizeof(xinput_caps->Gamepad.sThumbLY) + 1)) - 1;
else
WARN("Missing axis ThumbLY\n");
if (private->rx.bits)
xinput_caps->Gamepad.sThumbRX = (1u << (sizeof(xinput_caps->Gamepad.sThumbRX) + 1)) - 1;
else
WARN("Missing axis ThumbRX\n");
if (private->ry.bits)
xinput_caps->Gamepad.sThumbRY = (1u << (sizeof(xinput_caps->Gamepad.sThumbRY) + 1)) - 1;
else
WARN("Missing axis ThumbRY\n");
xinput_caps->Type = XINPUT_DEVTYPE_GAMEPAD;
xinput_caps->SubType = XINPUT_DEVSUBTYPE_GAMEPAD;
value_caps_count = caps->NumberOutputValueCaps;
if (value_caps_count > 0)
{
xinput_caps->Flags |= XINPUT_CAPS_FFB_SUPPORTED;
xinput_caps->Vibration.wLeftMotorSpeed = 255;
xinput_caps->Vibration.wRightMotorSpeed = 255;
}
return TRUE;
}
static BOOL init_controller(xinput_controller *controller, PHIDP_PREPARSED_DATA ppd, HIDP_CAPS *caps, HANDLE device, WCHAR *device_path)
{
size_t size;
struct hid_platform_private *private = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct hid_platform_private));
if (!VerifyGamepad(ppd, &controller->caps, private, caps))
{
HeapFree(GetProcessHeap(), 0, private);
return FALSE;
}
TRACE("Found gamepad %s\n", debugstr_w(device_path));
private->ppd = ppd;
private->device = device;
private->report_length = caps->InputReportByteLength + 1;
private->current_report = 0;
private->reports[0] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, private->report_length);
private->reports[1] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, private->report_length);
size = (lstrlenW(device_path) + 1) * sizeof(WCHAR);
private->device_path = HeapAlloc(GetProcessHeap(), 0, size);
memcpy(private->device_path, device_path, size);
private->enabled = TRUE;
memset(&controller->state, 0, sizeof(controller->state));
memset(&controller->vibration, 0, sizeof(controller->vibration));
controller->platform_private = private;
return TRUE;
}
void HID_find_gamepads(xinput_controller *devices)
{
HDEVINFO device_info_set;
GUID hid_guid;
SP_DEVICE_INTERFACE_DATA interface_data;
SP_DEVICE_INTERFACE_DETAIL_DATA_W *data;
PHIDP_PREPARSED_DATA ppd;
DWORD detail_size = MAX_PATH * sizeof(WCHAR);
HANDLE device;
HIDP_CAPS Caps;
DWORD idx;
int i, open_device_idx;
idx = GetTickCount();
if ((idx - last_check) < 2000)
return;
EnterCriticalSection(&xinput_crit);
if ((idx - last_check) < 2000)
{
LeaveCriticalSection(&xinput_crit);
return;
}
last_check = idx;
HidD_GetHidGuid(&hid_guid);
device_info_set = SetupDiGetClassDevsW(&hid_guid, NULL, NULL, DIGCF_DEVICEINTERFACE | DIGCF_PRESENT);
data = HeapAlloc(GetProcessHeap(), 0 , sizeof(*data) + detail_size);
data->cbSize = sizeof(*data);
ZeroMemory(&interface_data, sizeof(interface_data));
interface_data.cbSize = sizeof(interface_data);
idx = 0;
while (SetupDiEnumDeviceInterfaces(device_info_set, NULL, &hid_guid, idx++,
&interface_data))
{
static const WCHAR ig[] = {'I','G','_',0};
if (!SetupDiGetDeviceInterfaceDetailW(device_info_set,
&interface_data, data, sizeof(*data) + detail_size, NULL, NULL))
continue;
if (!wcsstr(data->DevicePath, ig))
continue;
open_device_idx = -1;
for (i = 0; i < XUSER_MAX_COUNT; i++)
{
struct hid_platform_private *private = devices[i].platform_private;
if (devices[i].platform_private)
{
if (!wcscmp(data->DevicePath, private->device_path))
break;
}
else if(open_device_idx < 0)
open_device_idx = i;
}
if (i != XUSER_MAX_COUNT)
/* this device is already opened */
continue;
if (open_device_idx < 0)
/* no open device slots */
break;
device = CreateFileW(data->DevicePath, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0 );
if (device == INVALID_HANDLE_VALUE)
continue;
HidD_GetPreparsedData(device, &ppd);
HidP_GetCaps(ppd, &Caps);
if (Caps.UsagePage == HID_USAGE_PAGE_GENERIC &&
(Caps.Usage == HID_USAGE_GENERIC_GAMEPAD ||
Caps.Usage == HID_USAGE_GENERIC_JOYSTICK ||
Caps.Usage == 0x8 /* Multi-axis Controller */))
{
if(!init_controller(&devices[open_device_idx], ppd, &Caps, device, data->DevicePath))
{
CloseHandle(device);
HidD_FreePreparsedData(ppd);
}
}
else
{
CloseHandle(device);
HidD_FreePreparsedData(ppd);
}
}
HeapFree(GetProcessHeap(), 0, data);
SetupDiDestroyDeviceInfoList(device_info_set);
LeaveCriticalSection(&xinput_crit);
}
static void remove_gamepad(xinput_controller *device)
{
EnterCriticalSection(&device->crit);
if (device->platform_private)
{
struct hid_platform_private *private = device->platform_private;
device->platform_private = NULL;
CloseHandle(private->device);
HeapFree(GetProcessHeap(), 0, private->reports[0]);
HeapFree(GetProcessHeap(), 0, private->reports[1]);
HeapFree(GetProcessHeap(), 0, private->device_path);
HidD_FreePreparsedData(private->ppd);
HeapFree(GetProcessHeap(), 0, private);
}
LeaveCriticalSection(&device->crit);
}
void HID_destroy_gamepads(xinput_controller *devices)
{
int i;
for (i = 0; i < XUSER_MAX_COUNT; i++)
remove_gamepad(&devices[i]);
}
static SHORT scale_short(LONG value, const struct axis_info *axis)
{
return ((((ULONGLONG)(value - axis->min)) * 0xffff) / axis->range) - 32768;
}
static BYTE scale_byte(LONG value, const struct axis_info *axis)
{
return (((ULONGLONG)(value - axis->min)) * 0xff) / axis->range;
}
void HID_update_state(xinput_controller *device, XINPUT_STATE *state)
{
struct hid_platform_private *private = device->platform_private;
int i;
CHAR *report = private->reports[(private->current_report)%2];
CHAR *target_report = private->reports[(private->current_report+1)%2];
USAGE buttons[11];
ULONG button_length, hat_value;
LONG value;
if (!private->enabled)
return;
if (!HidD_GetInputReport(private->device, target_report, private->report_length))
{
if (GetLastError() == ERROR_ACCESS_DENIED || GetLastError() == ERROR_INVALID_HANDLE)
{
EnterCriticalSection(&xinput_crit);
remove_gamepad(device);
LeaveCriticalSection(&xinput_crit);
}
else
ERR("Failed to get Input Report (%x)\n", GetLastError());
return;
}
if (memcmp(report, target_report, private->report_length) != 0)
{
private->current_report = (private->current_report+1)%2;
device->state.dwPacketNumber++;
button_length = ARRAY_SIZE(buttons);
HidP_GetUsages(HidP_Input, HID_USAGE_PAGE_BUTTON, 0, buttons, &button_length, private->ppd, target_report, private->report_length);
device->state.Gamepad.wButtons = 0;
for (i = 0; i < button_length; i++)
{
switch (buttons[i])
{
case 1: device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_A; break;
case 2: device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_B; break;
case 3: device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_X; break;
case 4: device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_Y; break;
case 5: device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_LEFT_SHOULDER; break;
case 6: device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_RIGHT_SHOULDER; break;
case 7: device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_BACK; break;
case 8: device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_START; break;
case 9: device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_LEFT_THUMB; break;
case 10: device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_RIGHT_THUMB; break;
case 11: device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_GUIDE; break;
}
}
if(HidP_GetUsageValue(HidP_Input, HID_USAGE_PAGE_GENERIC, 0, HID_USAGE_GENERIC_HATSWITCH, &hat_value,
private->ppd, target_report, private->report_length) == HIDP_STATUS_SUCCESS)
{
switch(hat_value){
/* 8 1 2
* 7 0 3
* 6 5 4 */
case 0:
break;
case 1:
device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_UP;
break;
case 2:
device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_UP | XINPUT_GAMEPAD_DPAD_RIGHT;
break;
case 3:
device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_RIGHT;
break;
case 4:
device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_RIGHT | XINPUT_GAMEPAD_DPAD_DOWN;
break;
case 5:
device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_DOWN;
break;
case 6:
device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_DOWN | XINPUT_GAMEPAD_DPAD_LEFT;
break;
case 7:
device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_LEFT;
break;
case 8:
device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_LEFT | XINPUT_GAMEPAD_DPAD_UP;
break;
}
}
if(HidP_GetScaledUsageValue(HidP_Input, HID_USAGE_PAGE_GENERIC, 0, HID_USAGE_GENERIC_X, &value,
private->ppd, target_report, private->report_length) == HIDP_STATUS_SUCCESS)
device->state.Gamepad.sThumbLX = scale_short(value, &private->lx);
if(HidP_GetScaledUsageValue(HidP_Input, HID_USAGE_PAGE_GENERIC, 0, HID_USAGE_GENERIC_Y, &value,
private->ppd, target_report, private->report_length) == HIDP_STATUS_SUCCESS)
device->state.Gamepad.sThumbLY = -scale_short(value, &private->ly) - 1;
if(HidP_GetScaledUsageValue(HidP_Input, HID_USAGE_PAGE_GENERIC, 0, HID_USAGE_GENERIC_RX, &value,
private->ppd, target_report, private->report_length) == HIDP_STATUS_SUCCESS)
device->state.Gamepad.sThumbRX = scale_short(value, &private->rx);
if(HidP_GetScaledUsageValue(HidP_Input, HID_USAGE_PAGE_GENERIC, 0, HID_USAGE_GENERIC_RY, &value,
private->ppd, target_report, private->report_length) == HIDP_STATUS_SUCCESS)
device->state.Gamepad.sThumbRY = -scale_short(value, &private->ry) - 1;
if(HidP_GetScaledUsageValue(HidP_Input, HID_USAGE_PAGE_GENERIC, 0, HID_USAGE_GENERIC_RZ, &value,
private->ppd, target_report, private->report_length) == HIDP_STATUS_SUCCESS)
device->state.Gamepad.bRightTrigger = scale_byte(value, &private->rtrigger);
if(HidP_GetScaledUsageValue(HidP_Input, HID_USAGE_PAGE_GENERIC, 0, HID_USAGE_GENERIC_Z, &value,
private->ppd, target_report, private->report_length) == HIDP_STATUS_SUCCESS)
device->state.Gamepad.bLeftTrigger = scale_byte(value, &private->ltrigger);
}
memcpy(state, &device->state, sizeof(*state));
}
DWORD HID_set_state(xinput_controller* device, XINPUT_VIBRATION* state)
{
struct hid_platform_private *private = device->platform_private;
struct {
BYTE report;
BYTE pad1[2];
BYTE left;
BYTE right;
BYTE pad2[3];
} report;
if (device->caps.Flags & XINPUT_CAPS_FFB_SUPPORTED)
{
device->vibration.wLeftMotorSpeed = state->wLeftMotorSpeed;
device->vibration.wRightMotorSpeed = state->wRightMotorSpeed;
if (private->enabled)
{
BOOLEAN rc;
report.report = 0;
report.pad1[0] = 0x8;
report.pad1[1] = 0x0;
report.left = (BYTE)(state->wLeftMotorSpeed / 256);
report.right = (BYTE)(state->wRightMotorSpeed / 256);
memset(&report.pad2, 0, sizeof(report.pad2));
rc = HidD_SetOutputReport(private->device, &report, sizeof(report));
if (rc)
return ERROR_SUCCESS;
return GetLastError();
}
}
return ERROR_SUCCESS;
}
void HID_enable(xinput_controller* device, BOOL enable)
{
struct hid_platform_private *private = device->platform_private;
if (device->caps.Flags & XINPUT_CAPS_FFB_SUPPORTED)
{
if (private->enabled && !enable)
{
XINPUT_VIBRATION state;
state.wLeftMotorSpeed = 0;
state.wRightMotorSpeed = 0;
HID_set_state(device, &state);
}
else if (!private->enabled && enable)
{
HID_set_state(device, &device->vibration);
}
}
private->enabled = enable;
}