dlls/xinput1_3/hid.c

   1 /*
   2  * The Wine project - Xinput Joystick HID interface
   3  * Copyright 2018 Aric Stewart
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20
  21 #include <assert.h>
  22 #include <stdarg.h>
  23 #include <string.h>
  24
  25 #include "wine/debug.h"
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29 #include "winerror.h"
  30 #include "winreg.h"
  31 #include "wingdi.h"
  32 #include "winnls.h"
  33 #include "winternl.h"
  34
  35 #include "setupapi.h"
  36 #include "devpkey.h"
  37 #include "hidusage.h"
  38 #include "ddk/hidsdi.h"
  39 #include "initguid.h"
  40 #include "devguid.h"
  41
  42 #include "xinput.h"
  43 #include "xinput_private.h"
  44
  45
  46 WINE_DEFAULT_DEBUG_CHANNEL(xinput);
  47
  48 #define XINPUT_GAMEPAD_GUIDE 0x0400
  49
  50 struct axis_info
  51 {
  52     LONG min;
  53     LONG range;
  54     USHORT bits;
  55 };
  56
  57 struct hid_platform_private {
  58     PHIDP_PREPARSED_DATA ppd;
  59     HANDLE device;
  60     WCHAR *device_path;
  61     BOOL enabled;
  62
  63     DWORD report_length;
  64     BYTE current_report;
  65     CHAR *reports[2];
  66
  67     struct axis_info lx, ly, ltrigger, rx, ry, rtrigger;
  68 };
  69
  70 static DWORD last_check = 0;
  71
  72 static void MarkUsage(struct hid_platform_private *private, WORD usage, LONG min, LONG max, USHORT bits)
  73 {
  74     struct axis_info info = {min, max-min, bits};
  75
  76     switch (usage)
  77     {
  78         case HID_USAGE_GENERIC_X: private->lx = info; break;
  79         case HID_USAGE_GENERIC_Y: private->ly = info; break;
  80         case HID_USAGE_GENERIC_Z: private->ltrigger = info; break;
  81         case HID_USAGE_GENERIC_RX: private->rx = info; break;
  82         case HID_USAGE_GENERIC_RY: private->ry = info; break;
  83         case HID_USAGE_GENERIC_RZ: private->rtrigger = info; break;
  84     }
  85 }
  86
  87 static BOOL VerifyGamepad(PHIDP_PREPARSED_DATA ppd, XINPUT_CAPABILITIES *xinput_caps, struct hid_platform_private *private, HIDP_CAPS *caps)
  88 {
  89     HIDP_BUTTON_CAPS *button_caps;
  90     HIDP_VALUE_CAPS *value_caps;
  91
  92     int i;
  93     int button_count = 0;
  94     USHORT button_caps_count = 0;
  95     USHORT value_caps_count = 0;
  96
  97     /* Count buttons */
  98     memset(xinput_caps, 0, sizeof(XINPUT_CAPABILITIES));
  99
 100     button_caps_count = caps->NumberInputButtonCaps;
 101     button_caps = HeapAlloc(GetProcessHeap(), 0, sizeof(*button_caps) * button_caps_count);
 102     HidP_GetButtonCaps(HidP_Input, button_caps, &button_caps_count, ppd);
 103     for (i = 0; i < button_caps_count; i++)
 104     {
 105         if (button_caps[i].UsagePage != HID_USAGE_PAGE_BUTTON)
 106             continue;
 107         if (button_caps[i].IsRange)
 108             button_count = max(button_count, button_caps[i].Range.UsageMax);
 109         else
 110             button_count = max(button_count, button_caps[i].NotRange.Usage);
 111     }
 112     HeapFree(GetProcessHeap(), 0, button_caps);
 113     if (button_count < 11)
 114         WARN("Too few buttons, continuing anyway\n");
 115     xinput_caps->Gamepad.wButtons = 0xffff;
 116
 117     value_caps_count = caps->NumberInputValueCaps;
 118     value_caps = HeapAlloc(GetProcessHeap(), 0, sizeof(*value_caps) * value_caps_count);
 119     HidP_GetValueCaps(HidP_Input, value_caps, &value_caps_count, ppd);
 120     for (i = 0; i < value_caps_count; i++)
 121     {
 122         if (value_caps[i].UsagePage != HID_USAGE_PAGE_GENERIC)
 123             continue;
 124         if (value_caps[i].IsRange)
 125         {
 126             int u;
 127             for (u = value_caps[i].Range.UsageMin; u <=value_caps[i].Range.UsageMax; u++)
 128                 MarkUsage(private, u,  value_caps[i].LogicalMin, value_caps[i].LogicalMax, value_caps[i].BitSize);
 129         }
 130         else
 131             MarkUsage(private, value_caps[i].NotRange.Usage, value_caps[i].LogicalMin, value_caps[i].LogicalMax, value_caps[i].BitSize);
 132     }
 133     HeapFree(GetProcessHeap(), 0, value_caps);
 134
 135     if (private->ltrigger.bits)
 136         xinput_caps->Gamepad.bLeftTrigger = (1u << (sizeof(xinput_caps->Gamepad.bLeftTrigger) + 1)) - 1;
 137     else
 138         WARN("Missing axis LeftTrigger\n");
 139     if (private->rtrigger.bits)
 140         xinput_caps->Gamepad.bRightTrigger = (1u << (sizeof(xinput_caps->Gamepad.bRightTrigger) + 1)) - 1;
 141     else
 142         WARN("Missing axis RightTrigger\n");
 143     if (private->lx.bits)
 144         xinput_caps->Gamepad.sThumbLX = (1u << (sizeof(xinput_caps->Gamepad.sThumbLX) + 1)) - 1;
 145     else
 146         WARN("Missing axis ThumbLX\n");
 147     if (private->ly.bits)
 148         xinput_caps->Gamepad.sThumbLY = (1u << (sizeof(xinput_caps->Gamepad.sThumbLY) + 1)) - 1;
 149     else
 150         WARN("Missing axis ThumbLY\n");
 151     if (private->rx.bits)
 152         xinput_caps->Gamepad.sThumbRX = (1u << (sizeof(xinput_caps->Gamepad.sThumbRX) + 1)) - 1;
 153     else
 154         WARN("Missing axis ThumbRX\n");
 155     if (private->ry.bits)
 156         xinput_caps->Gamepad.sThumbRY = (1u << (sizeof(xinput_caps->Gamepad.sThumbRY) + 1)) - 1;
 157     else
 158         WARN("Missing axis ThumbRY\n");
 159
 160     xinput_caps->Type = XINPUT_DEVTYPE_GAMEPAD;
 161     xinput_caps->SubType = XINPUT_DEVSUBTYPE_GAMEPAD;
 162
 163     value_caps_count = caps->NumberOutputValueCaps;
 164     if (value_caps_count > 0)
 165     {
 166         xinput_caps->Flags |= XINPUT_CAPS_FFB_SUPPORTED;
 167         xinput_caps->Vibration.wLeftMotorSpeed = 255;
 168         xinput_caps->Vibration.wRightMotorSpeed = 255;
 169     }
 170
 171     return TRUE;
 172 }
 173
 174 static BOOL init_controller(xinput_controller *controller, PHIDP_PREPARSED_DATA ppd, HIDP_CAPS *caps, HANDLE device, WCHAR *device_path)
 175 {
 176     size_t size;
 177     struct hid_platform_private *private = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct hid_platform_private));
 178
 179     if (!VerifyGamepad(ppd, &controller->caps, private, caps))
 180     {
 181         HeapFree(GetProcessHeap(), 0, private);
 182         return FALSE;
 183     }
 184
 185     TRACE("Found gamepad %s\n", debugstr_w(device_path));
 186
 187     private->ppd = ppd;
 188     private->device = device;
 189     private->report_length = caps->InputReportByteLength + 1;
 190     private->current_report = 0;
 191     private->reports[0] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, private->report_length);
 192     private->reports[1] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, private->report_length);
 193     size = (lstrlenW(device_path) + 1) * sizeof(WCHAR);
 194     private->device_path = HeapAlloc(GetProcessHeap(), 0, size);
 195     memcpy(private->device_path, device_path, size);
 196     private->enabled = TRUE;
 197
 198     memset(&controller->state, 0, sizeof(controller->state));
 199     memset(&controller->vibration, 0, sizeof(controller->vibration));
 200
 201     controller->platform_private = private;
 202
 203     return TRUE;
 204 }
 205
 206 void HID_find_gamepads(xinput_controller *devices)
 207 {
 208     HDEVINFO device_info_set;
 209     GUID hid_guid;
 210     SP_DEVICE_INTERFACE_DATA interface_data;
 211     SP_DEVICE_INTERFACE_DETAIL_DATA_W *data;
 212     PHIDP_PREPARSED_DATA ppd;
 213     DWORD detail_size = MAX_PATH * sizeof(WCHAR);
 214     HANDLE device;
 215     HIDP_CAPS Caps;
 216     DWORD idx;
 217     int i, open_device_idx;
 218
 219     idx = GetTickCount();
 220     if ((idx - last_check) < 2000)
 221         return;
 222
 223     EnterCriticalSection(&xinput_crit);
 224
 225     if ((idx - last_check) < 2000)
 226     {
 227         LeaveCriticalSection(&xinput_crit);
 228         return;
 229     }
 230     last_check = idx;
 231
 232     HidD_GetHidGuid(&hid_guid);
 233
 234     device_info_set = SetupDiGetClassDevsW(&hid_guid, NULL, NULL, DIGCF_DEVICEINTERFACE | DIGCF_PRESENT);
 235
 236     data = HeapAlloc(GetProcessHeap(), 0 , sizeof(*data) + detail_size);
 237     data->cbSize = sizeof(*data);
 238
 239     ZeroMemory(&interface_data, sizeof(interface_data));
 240     interface_data.cbSize = sizeof(interface_data);
 241
 242     idx = 0;
 243     while (SetupDiEnumDeviceInterfaces(device_info_set, NULL, &hid_guid, idx++,
 244            &interface_data))
 245     {
 246         if (!SetupDiGetDeviceInterfaceDetailW(device_info_set,
 247                 &interface_data, data, sizeof(*data) + detail_size, NULL, NULL))
 248             continue;
 249
 250         if (!wcsstr(data->DevicePath, L"IG_"))
 251             continue;
 252
 253         open_device_idx = -1;
 254         for (i = 0; i < XUSER_MAX_COUNT; i++)
 255         {
 256             struct hid_platform_private *private = devices[i].platform_private;
 257             if (devices[i].platform_private)
 258             {
 259                 if (!wcscmp(data->DevicePath, private->device_path))
 260                     break;
 261             }
 262             else if(open_device_idx < 0)
 263                 open_device_idx = i;
 264         }
 265         if (i != XUSER_MAX_COUNT)
 266             /* this device is already opened */
 267             continue;
 268         if (open_device_idx < 0)
 269             /* no open device slots */
 270             break;
 271         device = CreateFileW(data->DevicePath, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0 );
 272         if (device == INVALID_HANDLE_VALUE)
 273             continue;
 274
 275         HidD_GetPreparsedData(device, &ppd);
 276         HidP_GetCaps(ppd, &Caps);
 277         if (Caps.UsagePage == HID_USAGE_PAGE_GENERIC &&
 278             (Caps.Usage == HID_USAGE_GENERIC_GAMEPAD ||
 279              Caps.Usage == HID_USAGE_GENERIC_JOYSTICK ||
 280              Caps.Usage == 0x8 /* Multi-axis Controller */))
 281         {
 282             if(!init_controller(&devices[open_device_idx], ppd, &Caps, device, data->DevicePath))
 283             {
 284                 CloseHandle(device);
 285                 HidD_FreePreparsedData(ppd);
 286             }
 287         }
 288         else
 289         {
 290             CloseHandle(device);
 291             HidD_FreePreparsedData(ppd);
 292         }
 293     }
 294     HeapFree(GetProcessHeap(), 0, data);
 295     SetupDiDestroyDeviceInfoList(device_info_set);
 296     LeaveCriticalSection(&xinput_crit);
 297 }
 298
 299 static void remove_gamepad(xinput_controller *device)
 300 {
 301     EnterCriticalSection(&device->crit);
 302
 303     if (device->platform_private)
 304     {
 305         struct hid_platform_private *private = device->platform_private;
 306
 307         device->platform_private = NULL;
 308
 309         CloseHandle(private->device);
 310         HeapFree(GetProcessHeap(), 0, private->reports[0]);
 311         HeapFree(GetProcessHeap(), 0, private->reports[1]);
 312         HeapFree(GetProcessHeap(), 0, private->device_path);
 313         HidD_FreePreparsedData(private->ppd);
 314         HeapFree(GetProcessHeap(), 0, private);
 315     }
 316
 317     LeaveCriticalSection(&device->crit);
 318 }
 319
 320 void HID_destroy_gamepads(xinput_controller *devices)
 321 {
 322     int i;
 323     for (i = 0; i < XUSER_MAX_COUNT; i++)
 324         remove_gamepad(&devices[i]);
 325 }
 326
 327 static SHORT scale_short(LONG value, const struct axis_info *axis)
 328 {
 329     return ((((ULONGLONG)(value - axis->min)) * 0xffff) / axis->range) - 32768;
 330 }
 331
 332 static BYTE scale_byte(LONG value, const struct axis_info *axis)
 333 {
 334     return (((ULONGLONG)(value - axis->min)) * 0xff) / axis->range;
 335 }
 336
 337 void HID_update_state(xinput_controller *device, XINPUT_STATE *state)
 338 {
 339     struct hid_platform_private *private = device->platform_private;
 340     int i;
 341     CHAR *report = private->reports[(private->current_report)%2];
 342     CHAR *target_report = private->reports[(private->current_report+1)%2];
 343
 344     USAGE buttons[11];
 345     ULONG button_length, hat_value;
 346     LONG value;
 347
 348     if (!private->enabled)
 349         return;
 350
 351     if (!HidD_GetInputReport(private->device, target_report, private->report_length))
 352     {
 353         if (GetLastError() == ERROR_ACCESS_DENIED || GetLastError() == ERROR_INVALID_HANDLE)
 354         {
 355             EnterCriticalSection(&xinput_crit);
 356             remove_gamepad(device);
 357             LeaveCriticalSection(&xinput_crit);
 358         }
 359         else
 360             ERR("Failed to get Input Report (%x)\n", GetLastError());
 361         return;
 362     }
 363     if (memcmp(report, target_report, private->report_length) != 0)
 364     {
 365         private->current_report = (private->current_report+1)%2;
 366
 367         device->state.dwPacketNumber++;
 368         button_length = ARRAY_SIZE(buttons);
 369         HidP_GetUsages(HidP_Input, HID_USAGE_PAGE_BUTTON, 0, buttons, &button_length, private->ppd, target_report, private->report_length);
 370
 371         device->state.Gamepad.wButtons = 0;
 372         for (i = 0; i < button_length; i++)
 373         {
 374             switch (buttons[i])
 375             {
 376                 case 1: device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_A; break;
 377                 case 2: device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_B; break;
 378                 case 3: device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_X; break;
 379                 case 4: device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_Y; break;
 380                 case 5: device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_LEFT_SHOULDER; break;
 381                 case 6: device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_RIGHT_SHOULDER; break;
 382                 case 7: device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_BACK; break;
 383                 case 8: device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_START; break;
 384                 case 9: device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_LEFT_THUMB; break;
 385                 case 10: device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_RIGHT_THUMB; break;
 386                 case 11: device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_GUIDE; break;
 387             }
 388         }
 389
 390         if(HidP_GetUsageValue(HidP_Input, HID_USAGE_PAGE_GENERIC, 0, HID_USAGE_GENERIC_HATSWITCH, &hat_value,
 391                                   private->ppd, target_report, private->report_length) == HIDP_STATUS_SUCCESS)
 392         {
 393             switch(hat_value){
 394                 /* 8 1 2
 395                  * 7 0 3
 396                  * 6 5 4 */
 397                 case 0:
 398                     break;
 399                 case 1:
 400                     device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_UP;
 401                     break;
 402                 case 2:
 403                     device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_UP | XINPUT_GAMEPAD_DPAD_RIGHT;
 404                     break;
 405                 case 3:
 406                     device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_RIGHT;
 407                     break;
 408                 case 4:
 409                     device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_RIGHT | XINPUT_GAMEPAD_DPAD_DOWN;
 410                     break;
 411                 case 5:
 412                     device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_DOWN;
 413                     break;
 414                 case 6:
 415                     device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_DOWN | XINPUT_GAMEPAD_DPAD_LEFT;
 416                     break;
 417                 case 7:
 418                     device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_LEFT;
 419                     break;
 420                 case 8:
 421                     device->state.Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_LEFT | XINPUT_GAMEPAD_DPAD_UP;
 422                     break;
 423             }
 424         }
 425
 426         if(HidP_GetScaledUsageValue(HidP_Input, HID_USAGE_PAGE_GENERIC, 0, HID_USAGE_GENERIC_X, &value,
 427                                         private->ppd, target_report, private->report_length) == HIDP_STATUS_SUCCESS)
 428             device->state.Gamepad.sThumbLX = scale_short(value, &private->lx);
 429
 430         if(HidP_GetScaledUsageValue(HidP_Input, HID_USAGE_PAGE_GENERIC, 0, HID_USAGE_GENERIC_Y, &value,
 431                                         private->ppd, target_report, private->report_length) == HIDP_STATUS_SUCCESS)
 432             device->state.Gamepad.sThumbLY = -scale_short(value, &private->ly) - 1;
 433
 434         if(HidP_GetScaledUsageValue(HidP_Input, HID_USAGE_PAGE_GENERIC, 0, HID_USAGE_GENERIC_RX, &value,
 435                                         private->ppd, target_report, private->report_length) == HIDP_STATUS_SUCCESS)
 436             device->state.Gamepad.sThumbRX = scale_short(value, &private->rx);
 437
 438         if(HidP_GetScaledUsageValue(HidP_Input, HID_USAGE_PAGE_GENERIC, 0, HID_USAGE_GENERIC_RY, &value,
 439                                         private->ppd, target_report, private->report_length) == HIDP_STATUS_SUCCESS)
 440             device->state.Gamepad.sThumbRY = -scale_short(value, &private->ry) - 1;
 441
 442         if(HidP_GetScaledUsageValue(HidP_Input, HID_USAGE_PAGE_GENERIC, 0, HID_USAGE_GENERIC_RZ, &value,
 443                                         private->ppd, target_report, private->report_length) == HIDP_STATUS_SUCCESS)
 444             device->state.Gamepad.bRightTrigger = scale_byte(value, &private->rtrigger);
 445
 446         if(HidP_GetScaledUsageValue(HidP_Input, HID_USAGE_PAGE_GENERIC, 0, HID_USAGE_GENERIC_Z, &value,
 447                                         private->ppd, target_report, private->report_length) == HIDP_STATUS_SUCCESS)
 448             device->state.Gamepad.bLeftTrigger = scale_byte(value, &private->ltrigger);
 449     }
 450
 451     memcpy(state, &device->state, sizeof(*state));
 452 }
 453
 454 DWORD HID_set_state(xinput_controller* device, XINPUT_VIBRATION* state)
 455 {
 456     struct hid_platform_private *private = device->platform_private;
 457
 458     struct {
 459         BYTE report;
 460         BYTE pad1[2];
 461         BYTE left;
 462         BYTE right;
 463         BYTE pad2[3];
 464     } report;
 465
 466     if (device->caps.Flags & XINPUT_CAPS_FFB_SUPPORTED)
 467     {
 468         device->vibration.wLeftMotorSpeed = state->wLeftMotorSpeed;
 469         device->vibration.wRightMotorSpeed = state->wRightMotorSpeed;
 470
 471         if (private->enabled)
 472         {
 473             BOOLEAN rc;
 474
 475             report.report = 0;
 476             report.pad1[0] = 0x8;
 477             report.pad1[1] = 0x0;
 478             report.left = (BYTE)(state->wLeftMotorSpeed / 256);
 479             report.right = (BYTE)(state->wRightMotorSpeed / 256);
 480             memset(&report.pad2, 0, sizeof(report.pad2));
 481
 482             rc = HidD_SetOutputReport(private->device, &report, sizeof(report));
 483             if (rc)
 484                 return ERROR_SUCCESS;
 485             return GetLastError();
 486         }
 487     }
 488
 489     return ERROR_SUCCESS;
 490 }
 491
 492 void HID_enable(xinput_controller* device, BOOL enable)
 493 {
 494     struct hid_platform_private *private = device->platform_private;
 495
 496     if (device->caps.Flags & XINPUT_CAPS_FFB_SUPPORTED)
 497     {
 498         if (private->enabled && !enable)
 499         {
 500             XINPUT_VIBRATION state;
 501             state.wLeftMotorSpeed = 0;
 502             state.wRightMotorSpeed = 0;
 503             HID_set_state(device, &state);
 504         }
 505         else if (!private->enabled && enable)
 506         {
 507             HID_set_state(device, &device->vibration);
 508         }
 509     }
 510
 511     private->enabled = enable;
 512 }