dlls/windows.gaming.input/provider.c

   1 /* WinRT Windows.Gaming.Input implementation
   2  *
   3  * Copyright 2022 Rémi Bernon for CodeWeavers
   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 #include "private.h"
  21
  22 #include "initguid.h"
  23 #include "ddk/hidsdi.h"
  24 #include "dinput.h"
  25 #include "provider.h"
  26 #include "hidusage.h"
  27
  28 #include "wine/debug.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(input);
  31
  32 DEFINE_GUID( device_path_guid, 0x00000000, 0x0000, 0x0000, 0x8d, 0x4a, 0x23, 0x90, 0x3f, 0xb6, 0xbd, 0xf8 );
  33
  34 static CRITICAL_SECTION provider_cs;
  35 static CRITICAL_SECTION_DEBUG provider_cs_debug =
  36 {
  37     0, 0, &provider_cs,
  38     { &provider_cs_debug.ProcessLocksList, &provider_cs_debug.ProcessLocksList },
  39       0, 0, { (DWORD_PTR)(__FILE__ ": provider_cs") }
  40 };
  41 static CRITICAL_SECTION provider_cs = { &provider_cs_debug, -1, 0, 0, 0, 0 };
  42
  43 static struct list provider_list = LIST_INIT( provider_list );
  44
  45 struct provider
  46 {
  47     IWineGameControllerProvider IWineGameControllerProvider_iface;
  48     IGameControllerProvider IGameControllerProvider_iface;
  49     LONG ref;
  50
  51     IDirectInputDevice8W *dinput_device;
  52     WCHAR device_path[MAX_PATH];
  53     struct list entry;
  54
  55     struct WineGameControllerVibration vibration;
  56
  57     char *report_buf;
  58     PHIDP_PREPARSED_DATA preparsed;
  59     HIDP_VALUE_CAPS haptics_rumble_caps;
  60     HIDP_VALUE_CAPS haptics_buzz_caps;
  61     HIDP_VALUE_CAPS haptics_left_caps;
  62     HIDP_VALUE_CAPS haptics_right_caps;
  63     BYTE haptics_report;
  64     HIDP_CAPS caps;
  65     HANDLE device;
  66 };
  67
  68 static inline struct provider *impl_from_IWineGameControllerProvider( IWineGameControllerProvider *iface )
  69 {
  70     return CONTAINING_RECORD( iface, struct provider, IWineGameControllerProvider_iface );
  71 }
  72
  73 static HRESULT WINAPI wine_provider_QueryInterface( IWineGameControllerProvider *iface, REFIID iid, void **out )
  74 {
  75     struct provider *impl = impl_from_IWineGameControllerProvider( iface );
  76
  77     TRACE( "iface %p, iid %s, out %p.\n", iface, debugstr_guid( iid ), out );
  78
  79     if (IsEqualGUID( iid, &IID_IUnknown ) ||
  80         IsEqualGUID( iid, &IID_IInspectable ) ||
  81         IsEqualGUID( iid, &IID_IAgileObject ) ||
  82         IsEqualGUID( iid, &IID_IWineGameControllerProvider ))
  83     {
  84         IInspectable_AddRef( (*out = &impl->IWineGameControllerProvider_iface) );
  85         return S_OK;
  86     }
  87
  88     if (IsEqualGUID( iid, &IID_IGameControllerProvider ))
  89     {
  90         IInspectable_AddRef( (*out = &impl->IGameControllerProvider_iface) );
  91         return S_OK;
  92     }
  93
  94     FIXME( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
  95     *out = NULL;
  96     return E_NOINTERFACE;
  97 }
  98
  99 static ULONG WINAPI wine_provider_AddRef( IWineGameControllerProvider *iface )
 100 {
 101     struct provider *impl = impl_from_IWineGameControllerProvider( iface );
 102     ULONG ref = InterlockedIncrement( &impl->ref );
 103     TRACE( "iface %p increasing refcount to %lu.\n", iface, ref );
 104     return ref;
 105 }
 106
 107 static ULONG WINAPI wine_provider_Release( IWineGameControllerProvider *iface )
 108 {
 109     struct provider *impl = impl_from_IWineGameControllerProvider( iface );
 110     ULONG ref = InterlockedDecrement( &impl->ref );
 111
 112     TRACE( "iface %p decreasing refcount to %lu.\n", iface, ref );
 113
 114     if (!ref)
 115     {
 116         IDirectInputDevice8_Release( impl->dinput_device );
 117         HidD_FreePreparsedData( impl->preparsed );
 118         CloseHandle( impl->device );
 119         free( impl->report_buf );
 120         free( impl );
 121     }
 122
 123     return ref;
 124 }
 125
 126 static HRESULT WINAPI wine_provider_GetIids( IWineGameControllerProvider *iface, ULONG *iid_count, IID **iids )
 127 {
 128     FIXME( "iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids );
 129     return E_NOTIMPL;
 130 }
 131
 132 static HRESULT WINAPI wine_provider_GetRuntimeClassName( IWineGameControllerProvider *iface, HSTRING *class_name )
 133 {
 134     FIXME( "iface %p, class_name %p stub!\n", iface, class_name );
 135     return E_NOTIMPL;
 136 }
 137
 138 static HRESULT WINAPI wine_provider_GetTrustLevel( IWineGameControllerProvider *iface, TrustLevel *trust_level )
 139 {
 140     FIXME( "iface %p, trust_level %p stub!\n", iface, trust_level );
 141     return E_NOTIMPL;
 142 }
 143
 144 static BOOL CALLBACK count_ffb_axes( const DIDEVICEOBJECTINSTANCEW *obj, void *args )
 145 {
 146     DWORD *count = args;
 147     if (obj->dwType & DIDFT_FFACTUATOR) (*count)++;
 148     return DIENUM_CONTINUE;
 149 }
 150
 151 static HRESULT WINAPI wine_provider_get_Type( IWineGameControllerProvider *iface, WineGameControllerType *value )
 152 {
 153     struct provider *impl = impl_from_IWineGameControllerProvider( iface );
 154     DIDEVICEINSTANCEW instance = {.dwSize = sizeof(DIDEVICEINSTANCEW)};
 155     HRESULT hr;
 156
 157     TRACE( "iface %p, value %p.\n", iface, value );
 158
 159     if (FAILED(hr = IDirectInputDevice8_GetDeviceInfo( impl->dinput_device, &instance ))) return hr;
 160
 161     switch (GET_DIDEVICE_TYPE( instance.dwDevType ))
 162     {
 163     case DI8DEVTYPE_DRIVING: *value = WineGameControllerType_RacingWheel; break;
 164     case DI8DEVTYPE_GAMEPAD: *value = WineGameControllerType_Gamepad; break;
 165     default:
 166     {
 167         DWORD count = 0;
 168         hr = IDirectInputDevice8_EnumObjects( impl->dinput_device, count_ffb_axes, &count, DIDFT_AXIS );
 169         if (SUCCEEDED(hr) && count == 1) *value = WineGameControllerType_RacingWheel;
 170         else *value = WineGameControllerType_Joystick;
 171         break;
 172     }
 173     }
 174
 175     return S_OK;
 176 }
 177
 178 static HRESULT WINAPI wine_provider_get_AxisCount( IWineGameControllerProvider *iface, INT32 *value )
 179 {
 180     struct provider *impl = impl_from_IWineGameControllerProvider( iface );
 181     DIDEVCAPS caps = {.dwSize = sizeof(DIDEVCAPS)};
 182     HRESULT hr;
 183
 184     TRACE( "iface %p, value %p.\n", iface, value );
 185
 186     if (SUCCEEDED(hr = IDirectInputDevice8_GetCapabilities( impl->dinput_device, &caps )))
 187         *value = caps.dwAxes;
 188     return hr;
 189 }
 190
 191 static HRESULT WINAPI wine_provider_get_ButtonCount( IWineGameControllerProvider *iface, INT32 *value )
 192 {
 193     struct provider *impl = impl_from_IWineGameControllerProvider( iface );
 194     DIDEVCAPS caps = {.dwSize = sizeof(DIDEVCAPS)};
 195     HRESULT hr;
 196
 197     TRACE( "iface %p, value %p.\n", iface, value );
 198
 199     if (SUCCEEDED(hr = IDirectInputDevice8_GetCapabilities( impl->dinput_device, &caps )))
 200         *value = caps.dwButtons;
 201     return hr;
 202 }
 203
 204 static HRESULT WINAPI wine_provider_get_SwitchCount( IWineGameControllerProvider *iface, INT32 *value )
 205 {
 206     struct provider *impl = impl_from_IWineGameControllerProvider( iface );
 207     DIDEVCAPS caps = {.dwSize = sizeof(DIDEVCAPS)};
 208     HRESULT hr;
 209
 210     TRACE( "iface %p, value %p.\n", iface, value );
 211
 212     if (SUCCEEDED(hr = IDirectInputDevice8_GetCapabilities( impl->dinput_device, &caps )))
 213         *value = caps.dwPOVs;
 214     return hr;
 215 }
 216
 217 static HRESULT WINAPI wine_provider_get_State( IWineGameControllerProvider *iface, struct WineGameControllerState *out )
 218 {
 219     struct provider *impl = impl_from_IWineGameControllerProvider( iface );
 220     DIJOYSTATE2 state = {0};
 221     UINT32 i = 0;
 222     HRESULT hr;
 223
 224     TRACE( "iface %p, out %p.\n", iface, out );
 225
 226     if (FAILED(hr = IDirectInputDevice8_GetDeviceState( impl->dinput_device, sizeof(state), &state )))
 227     {
 228         WARN( "Failed to read device state, hr %#lx\n", hr );
 229         return S_OK;
 230     }
 231
 232     i = ARRAY_SIZE(state.rgbButtons);
 233     while (i--) out->buttons[i] = (state.rgbButtons[i] != 0);
 234
 235     i = ARRAY_SIZE(state.rgdwPOV);
 236     while (i--)
 237     {
 238         if (state.rgdwPOV[i] == ~0) out->switches[i] = GameControllerSwitchPosition_Center;
 239         else out->switches[i] = state.rgdwPOV[i] * 8 / 36000 + 1;
 240     }
 241
 242     i = 0;
 243     out->axes[i++] = state.lX / 65535.;
 244     out->axes[i++] = state.lY / 65535.;
 245     out->axes[i++] = state.lZ / 65535.;
 246     out->axes[i++] = state.lRx / 65535.;
 247     out->axes[i++] = state.lRy / 65535.;
 248     out->axes[i++] = state.lRz / 65535.;
 249     out->axes[i++] = state.rglSlider[0] / 65535.;
 250     out->axes[i++] = state.rglSlider[1] / 65535.;
 251     out->axes[i++] = state.lVX / 65535.;
 252     out->axes[i++] = state.lVY / 65535.;
 253     out->axes[i++] = state.lVZ / 65535.;
 254     out->axes[i++] = state.lVRx / 65535.;
 255     out->axes[i++] = state.lVRy / 65535.;
 256     out->axes[i++] = state.lVRz / 65535.;
 257     out->axes[i++] = state.rglVSlider[0] / 65535.;
 258     out->axes[i++] = state.rglVSlider[1] / 65535.;
 259     out->axes[i++] = state.lAX / 65535.;
 260     out->axes[i++] = state.lAY / 65535.;
 261     out->axes[i++] = state.lAZ / 65535.;
 262     out->axes[i++] = state.lARx / 65535.;
 263     out->axes[i++] = state.lARy / 65535.;
 264     out->axes[i++] = state.lARz / 65535.;
 265     out->axes[i++] = state.rglASlider[0] / 65535.;
 266     out->axes[i++] = state.rglASlider[1] / 65535.;
 267     out->axes[i++] = state.lFX / 65535.;
 268     out->axes[i++] = state.lFY / 65535.;
 269     out->axes[i++] = state.lFZ / 65535.;
 270     out->axes[i++] = state.lFRx / 65535.;
 271     out->axes[i++] = state.lFRy / 65535.;
 272     out->axes[i++] = state.lFRz / 65535.;
 273     out->axes[i++] = state.rglFSlider[0] / 65535.;
 274     out->axes[i++] = state.rglFSlider[1] / 65535.;
 275     out->timestamp = GetTickCount64();
 276
 277     return S_OK;
 278 }
 279
 280 static HRESULT WINAPI wine_provider_get_Vibration( IWineGameControllerProvider *iface, struct WineGameControllerVibration *out )
 281 {
 282     struct provider *impl = impl_from_IWineGameControllerProvider( iface );
 283     TRACE( "iface %p, out %p.\n", iface, out );
 284     *out = impl->vibration;
 285     return S_OK;
 286 }
 287
 288 static HRESULT WINAPI wine_provider_put_Vibration( IWineGameControllerProvider *iface, struct WineGameControllerVibration value )
 289 {
 290     struct provider *impl = impl_from_IWineGameControllerProvider( iface );
 291     ULONG report_len = impl->caps.OutputReportByteLength;
 292     PHIDP_PREPARSED_DATA preparsed = impl->preparsed;
 293     char *report_buf = impl->report_buf;
 294     USHORT collection;
 295     NTSTATUS status;
 296     BOOL ret;
 297
 298     TRACE( "iface %p, value %p.\n", iface, &value );
 299
 300     if (!memcmp( &impl->vibration, &value, sizeof(value) )) return S_OK;
 301     impl->vibration = value;
 302
 303     status = HidP_InitializeReportForID( HidP_Output, impl->haptics_report, preparsed, report_buf, report_len );
 304     if (status != HIDP_STATUS_SUCCESS) WARN( "HidP_InitializeReportForID returned %#lx\n", status );
 305
 306     collection = impl->haptics_rumble_caps.LinkCollection;
 307     status = HidP_SetUsageValue( HidP_Output, HID_USAGE_PAGE_HAPTICS, collection, HID_USAGE_HAPTICS_INTENSITY,
 308                                  impl->vibration.rumble, preparsed, report_buf, report_len );
 309     if (status != HIDP_STATUS_SUCCESS) WARN( "HidP_SetUsageValue INTENSITY returned %#lx\n", status );
 310
 311     collection = impl->haptics_buzz_caps.LinkCollection;
 312     status = HidP_SetUsageValue( HidP_Output, HID_USAGE_PAGE_HAPTICS, collection, HID_USAGE_HAPTICS_INTENSITY,
 313                                  impl->vibration.buzz, preparsed, report_buf, report_len );
 314     if (status != HIDP_STATUS_SUCCESS) WARN( "HidP_SetUsageValue INTENSITY returned %#lx\n", status );
 315
 316     collection = impl->haptics_left_caps.LinkCollection;
 317     status = HidP_SetUsageValue( HidP_Output, HID_USAGE_PAGE_HAPTICS, collection, HID_USAGE_HAPTICS_INTENSITY,
 318                                  impl->vibration.left, preparsed, report_buf, report_len );
 319     if (status != HIDP_STATUS_SUCCESS) WARN( "HidP_SetUsageValue INTENSITY returned %#lx\n", status );
 320
 321     collection = impl->haptics_right_caps.LinkCollection;
 322     status = HidP_SetUsageValue( HidP_Output, HID_USAGE_PAGE_HAPTICS, collection, HID_USAGE_HAPTICS_INTENSITY,
 323                                  impl->vibration.right, preparsed, report_buf, report_len );
 324     if (status != HIDP_STATUS_SUCCESS) WARN( "HidP_SetUsageValue INTENSITY returned %#lx\n", status );
 325
 326     ret = HidD_SetOutputReport( impl->device, report_buf, report_len );
 327     if (!ret) WARN( "HidD_SetOutputReport failed with error %lu\n", GetLastError() );
 328
 329     return S_OK;
 330 }
 331
 332 static HRESULT WINAPI wine_provider_get_ForceFeedbackMotor( IWineGameControllerProvider *iface, IForceFeedbackMotor **value )
 333 {
 334     struct provider *impl = impl_from_IWineGameControllerProvider( iface );
 335     DIDEVCAPS caps = {.dwSize = sizeof(DIDEVCAPS)};
 336     HRESULT hr;
 337
 338     TRACE( "iface %p, value %p.\n", iface, value );
 339
 340     if (SUCCEEDED(hr = IDirectInputDevice8_GetCapabilities( impl->dinput_device, &caps )) && (caps.dwFlags & DIDC_FORCEFEEDBACK))
 341         return force_feedback_motor_create( impl->dinput_device, value );
 342
 343     *value = NULL;
 344     return S_OK;
 345 }
 346
 347 static const struct IWineGameControllerProviderVtbl wine_provider_vtbl =
 348 {
 349     wine_provider_QueryInterface,
 350     wine_provider_AddRef,
 351     wine_provider_Release,
 352     /* IInspectable methods */
 353     wine_provider_GetIids,
 354     wine_provider_GetRuntimeClassName,
 355     wine_provider_GetTrustLevel,
 356     /* IWineGameControllerProvider methods */
 357     wine_provider_get_Type,
 358     wine_provider_get_AxisCount,
 359     wine_provider_get_ButtonCount,
 360     wine_provider_get_SwitchCount,
 361     wine_provider_get_State,
 362     wine_provider_get_Vibration,
 363     wine_provider_put_Vibration,
 364     wine_provider_get_ForceFeedbackMotor,
 365 };
 366
 367 DEFINE_IINSPECTABLE( game_provider, IGameControllerProvider, struct provider, IWineGameControllerProvider_iface )
 368
 369 static HRESULT WINAPI game_provider_get_FirmwareVersionInfo( IGameControllerProvider *iface, GameControllerVersionInfo *value )
 370 {
 371     FIXME( "iface %p, value %p stub!\n", iface, value );
 372     return E_NOTIMPL;
 373 }
 374
 375 static HRESULT WINAPI game_provider_get_HardwareProductId( IGameControllerProvider *iface, UINT16 *value )
 376 {
 377     DIPROPDWORD vid_pid = {.diph = {.dwHeaderSize = sizeof(DIPROPHEADER), .dwSize = sizeof(DIPROPDWORD)}};
 378     struct provider *impl = impl_from_IGameControllerProvider( iface );
 379     HRESULT hr;
 380
 381     TRACE( "iface %p, value %p.\n", iface, value );
 382
 383     if (SUCCEEDED(hr = IDirectInputDevice8_GetProperty( impl->dinput_device, DIPROP_VIDPID, &vid_pid.diph )))
 384         *value = HIWORD(vid_pid.dwData);
 385     return hr;
 386 }
 387
 388 static HRESULT WINAPI game_provider_get_HardwareVendorId( IGameControllerProvider *iface, UINT16 *value )
 389 {
 390     DIPROPDWORD vid_pid = {.diph = {.dwHeaderSize = sizeof(DIPROPHEADER), .dwSize = sizeof(DIPROPDWORD)}};
 391     struct provider *impl = impl_from_IGameControllerProvider( iface );
 392     HRESULT hr;
 393
 394     TRACE( "iface %p, value %p.\n", iface, value );
 395
 396     if (SUCCEEDED(hr = IDirectInputDevice8_GetProperty( impl->dinput_device, DIPROP_VIDPID, &vid_pid.diph )))
 397         *value = LOWORD(vid_pid.dwData);
 398     return hr;
 399 }
 400
 401 static HRESULT WINAPI game_provider_get_HardwareVersionInfo( IGameControllerProvider *iface, GameControllerVersionInfo *value )
 402 {
 403     FIXME( "iface %p, value %p stub!\n", iface, value );
 404     return E_NOTIMPL;
 405 }
 406
 407 static HRESULT WINAPI game_provider_get_IsConnected( IGameControllerProvider *iface, boolean *value )
 408 {
 409     FIXME( "iface %p, value %p stub!\n", iface, value );
 410     return E_NOTIMPL;
 411 }
 412
 413 static const struct IGameControllerProviderVtbl game_provider_vtbl =
 414 {
 415     game_provider_QueryInterface,
 416     game_provider_AddRef,
 417     game_provider_Release,
 418     /* IInspectable methods */
 419     game_provider_GetIids,
 420     game_provider_GetRuntimeClassName,
 421     game_provider_GetTrustLevel,
 422     /* IGameControllerProvider methods */
 423     game_provider_get_FirmwareVersionInfo,
 424     game_provider_get_HardwareProductId,
 425     game_provider_get_HardwareVendorId,
 426     game_provider_get_HardwareVersionInfo,
 427     game_provider_get_IsConnected,
 428 };
 429
 430 static void check_haptics_caps( struct provider *provider, HANDLE device, PHIDP_PREPARSED_DATA preparsed,
 431                                 HIDP_LINK_COLLECTION_NODE *collections, HIDP_VALUE_CAPS *caps )
 432 {
 433     USHORT count, report_len = provider->caps.FeatureReportByteLength;
 434     ULONG parent = caps->LinkCollection, waveform = 0;
 435     char *report_buf = provider->report_buf;
 436     HIDP_VALUE_CAPS value_caps;
 437     USAGE_AND_PAGE phy_usages;
 438     NTSTATUS status;
 439
 440     while (collections[parent].LinkUsagePage != HID_USAGE_PAGE_HAPTICS ||
 441            collections[parent].LinkUsage != HID_USAGE_HAPTICS_SIMPLE_CONTROLLER)
 442         if (!(parent = collections[parent].Parent)) break;
 443
 444     if (collections[parent].LinkUsagePage != HID_USAGE_PAGE_HAPTICS ||
 445         collections[parent].LinkUsage != HID_USAGE_HAPTICS_SIMPLE_CONTROLLER)
 446     {
 447         WARN( "Failed to find haptics simple controller collection\n" );
 448         return;
 449     }
 450     phy_usages.UsagePage = collections[collections[parent].Parent].LinkUsagePage;
 451     phy_usages.Usage = collections[collections[parent].Parent].LinkUsage;
 452
 453     status = HidP_InitializeReportForID( HidP_Feature, caps->ReportID, preparsed, report_buf, report_len );
 454     if (status != HIDP_STATUS_SUCCESS) WARN( "HidP_InitializeReportForID returned %#lx\n", status );
 455     if (!HidD_GetFeature( device, report_buf, report_len ))
 456     {
 457         WARN( "Failed to get waveform list report, error %lu\n", GetLastError() );
 458         return;
 459     }
 460
 461     status = HidP_GetUsageValue( HidP_Feature, caps->UsagePage, caps->LinkCollection,
 462                                  caps->NotRange.Usage, &waveform, preparsed, report_buf, report_len );
 463     if (status != HIDP_STATUS_SUCCESS) WARN( "HidP_GetUsageValue returned %#lx\n", status );
 464
 465     count = 1;
 466     status = HidP_GetSpecificValueCaps( HidP_Output, HID_USAGE_PAGE_HAPTICS, parent,
 467                                         HID_USAGE_HAPTICS_INTENSITY, &value_caps, &count, preparsed );
 468     if (status != HIDP_STATUS_SUCCESS || !count) WARN( "Failed to get waveform intensity caps, status %#lx\n", status );
 469     else if (phy_usages.UsagePage == HID_USAGE_PAGE_GENERIC && phy_usages.Usage == HID_USAGE_GENERIC_Z)
 470     {
 471         TRACE( "Found left rumble caps, report %u collection %u\n", value_caps.ReportID, value_caps.LinkCollection );
 472         provider->haptics_report = value_caps.ReportID;
 473         provider->haptics_left_caps = value_caps;
 474     }
 475     else if (phy_usages.UsagePage == HID_USAGE_PAGE_GENERIC && phy_usages.Usage == HID_USAGE_GENERIC_RZ)
 476     {
 477         TRACE( "Found right rumble caps, report %u collection %u\n", value_caps.ReportID, value_caps.LinkCollection );
 478         provider->haptics_report = value_caps.ReportID;
 479         provider->haptics_right_caps = value_caps;
 480     }
 481     else if (waveform == HID_USAGE_HAPTICS_WAVEFORM_RUMBLE)
 482     {
 483         TRACE( "Found rumble caps, report %u collection %u\n", value_caps.ReportID, value_caps.LinkCollection );
 484         provider->haptics_report = value_caps.ReportID;
 485         provider->haptics_rumble_caps = value_caps;
 486     }
 487     else if (waveform == HID_USAGE_HAPTICS_WAVEFORM_BUZZ)
 488     {
 489         TRACE( "Found buzz caps, report %u collection %u\n", value_caps.ReportID, value_caps.LinkCollection );
 490         provider->haptics_report = value_caps.ReportID;
 491         provider->haptics_buzz_caps = value_caps;
 492     }
 493     else FIXME( "Unsupported waveform type %#lx\n", waveform );
 494 }
 495
 496 static void open_haptics_device( struct provider *provider )
 497 {
 498     HIDP_LINK_COLLECTION_NODE *collections;
 499     PHIDP_PREPARSED_DATA preparsed = NULL;
 500     ULONG i, size, coll_count = 0;
 501     USHORT count, caps_count = 0;
 502     HIDP_VALUE_CAPS caps[8];
 503     NTSTATUS status;
 504     HANDLE device;
 505
 506     device = CreateFileW( provider->device_path, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
 507                           NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING, 0 );
 508     if (device == INVALID_HANDLE_VALUE) return;
 509
 510     if (!HidD_GetPreparsedData( device, &preparsed )) goto failed;
 511     if (HidP_GetCaps( preparsed, &provider->caps ) != HIDP_STATUS_SUCCESS) goto failed;
 512
 513     size = max( provider->caps.OutputReportByteLength, provider->caps.FeatureReportByteLength );
 514     if (!(provider->report_buf = malloc( size ))) goto failed;
 515
 516     coll_count = provider->caps.NumberLinkCollectionNodes;
 517     if (!(collections = malloc( sizeof(*collections) * coll_count ))) goto failed;
 518
 519     status = HidP_GetLinkCollectionNodes( collections, &coll_count, preparsed );
 520     if (status != HIDP_STATUS_SUCCESS) WARN( "HidP_GetLinkCollectionNodes returned %#lx\n", status );
 521     else for (i = 0; i < coll_count; ++i)
 522     {
 523         if (collections[i].LinkUsagePage != HID_USAGE_PAGE_HAPTICS) continue;
 524         if (collections[i].LinkUsage == HID_USAGE_HAPTICS_WAVEFORM_LIST)
 525         {
 526             count = ARRAY_SIZE(caps) - caps_count;
 527             status = HidP_GetSpecificValueCaps( HidP_Feature, HID_USAGE_PAGE_ORDINAL, i, 0,
 528                                                 caps + caps_count, &count, preparsed );
 529             if (status == HIDP_STATUS_SUCCESS) caps_count += count;
 530         }
 531     }
 532     for (i = 0; i < caps_count; ++i) check_haptics_caps( provider, device, preparsed, collections, caps + i );
 533     free( collections );
 534
 535     provider->preparsed = preparsed;
 536     provider->device = device;
 537     return;
 538
 539 failed:
 540     free( provider->report_buf );
 541     provider->report_buf = NULL;
 542     HidD_FreePreparsedData( preparsed );
 543     CloseHandle( device );
 544 }
 545
 546 void provider_create( const WCHAR *device_path )
 547 {
 548     IDirectInputDevice8W *dinput_device;
 549     IGameControllerProvider *provider;
 550     struct provider *impl, *entry;
 551     GUID guid = device_path_guid;
 552     IDirectInput8W *dinput;
 553     BOOL found = FALSE;
 554     const WCHAR *tmp;
 555     HRESULT hr;
 556
 557     if (wcsnicmp( device_path, L"\\\\?\\HID#", 8 )) return;
 558     if ((tmp = wcschr( device_path + 8, '#' )) && !wcsnicmp( tmp - 6, L"&IG_", 4 )) return;
 559
 560     TRACE( "device_path %s\n", debugstr_w( device_path ) );
 561
 562     *(const WCHAR **)&guid = device_path;
 563     if (FAILED(DirectInput8Create( windows_gaming_input, DIRECTINPUT_VERSION, &IID_IDirectInput8W,
 564                                    (void **)&dinput, NULL ))) return;
 565     hr = IDirectInput8_CreateDevice( dinput, &guid, &dinput_device, NULL );
 566     IDirectInput8_Release( dinput );
 567     if (FAILED(hr)) return;
 568
 569     if (FAILED(hr = IDirectInputDevice8_SetCooperativeLevel( dinput_device, 0, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE ))) goto done;
 570     if (FAILED(hr = IDirectInputDevice8_SetDataFormat( dinput_device, &c_dfDIJoystick2 ))) goto done;
 571     if (FAILED(hr = IDirectInputDevice8_Acquire( dinput_device ))) goto done;
 572
 573     if (!(impl = calloc( 1, sizeof(*impl) ))) goto done;
 574     impl->IWineGameControllerProvider_iface.lpVtbl = &wine_provider_vtbl;
 575     impl->IGameControllerProvider_iface.lpVtbl = &game_provider_vtbl;
 576     IDirectInputDevice_AddRef( dinput_device );
 577     impl->dinput_device = dinput_device;
 578     impl->ref = 1;
 579
 580     wcscpy( impl->device_path, device_path );
 581     list_init( &impl->entry );
 582     open_haptics_device( impl );
 583
 584     provider = &impl->IGameControllerProvider_iface;
 585     TRACE( "created WineGameControllerProvider %p\n", provider );
 586
 587     EnterCriticalSection( &provider_cs );
 588     LIST_FOR_EACH_ENTRY( entry, &provider_list, struct provider, entry )
 589         if ((found = !wcsicmp( entry->device_path, device_path ))) break;
 590     if (!found) list_add_tail( &provider_list, &impl->entry );
 591     LeaveCriticalSection( &provider_cs );
 592
 593     if (found) IGameControllerProvider_Release( provider );
 594     else manager_on_provider_created( provider );
 595 done:
 596     IDirectInputDevice_Release( dinput_device );
 597 }
 598
 599 void provider_remove( const WCHAR *device_path )
 600 {
 601     IGameControllerProvider *provider;
 602     struct provider *entry;
 603     BOOL found = FALSE;
 604
 605     TRACE( "device_path %s\n", debugstr_w( device_path ) );
 606
 607     EnterCriticalSection( &provider_cs );
 608     LIST_FOR_EACH_ENTRY( entry, &provider_list, struct provider, entry )
 609         if ((found = !wcsicmp( entry->device_path, device_path ))) break;
 610     if (found) list_remove( &entry->entry );
 611     LeaveCriticalSection( &provider_cs );
 612
 613     if (!found) WARN( "provider not found for device %s\n", debugstr_w( device_path ) );
 614     else
 615     {
 616         provider = &entry->IGameControllerProvider_iface;
 617         manager_on_provider_removed( provider );
 618         IGameControllerProvider_Release( provider );
 619     }
 620 }