?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winebus.sys: Implement SDL Haptic for controller vibration.
[wine.git] / dlls / winebus.sys / bus_sdl.c
blob3a98fa71ffbbf8fcf1cfa86274acd4ad25cc8f1d
1 /*
2 * Plug and Play support for hid devices found through SDL2
3 *
4 * Copyright 2017 CodeWeavers, Aric Stewart
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "config.h"
22 #include "wine/port.h"
23 #include <errno.h>
24 #include <fcntl.h>
25 #include <stdarg.h>
26 #include <stdlib.h>
27 #ifdef HAVE_UNISTD_H
28 # include <unistd.h>
29 #endif
30 #ifdef HAVE_SDL2_SDL_H
31 # include <SDL2/SDL.h>
32 #endif
33
34 #define NONAMELESSUNION
35
36 #include "ntstatus.h"
37 #define WIN32_NO_STATUS
38 #include "windef.h"
39 #include "winbase.h"
40 #include "winnls.h"
41 #include "winternl.h"
42 #include "ddk/wdm.h"
43 #include "ddk/hidtypes.h"
44 #include "wine/library.h"
45 #include "wine/debug.h"
46 #include "wine/unicode.h"
47 #include "hidusage.h"
48 #include "controller.h"
49
50 #ifdef WORDS_BIGENDIAN
51 # define LE_WORD(x) RtlUshortByteSwap(x)
52 #else
53 # define LE_WORD(x) (x)
54 #endif
55
56 #include "bus.h"
57
58 WINE_DEFAULT_DEBUG_CHANNEL(plugplay);
59
60 #ifdef SONAME_LIBSDL2
61
62 #define VID_MICROSOFT 0x045e
63
64 static const WORD PID_XBOX_CONTROLLERS[] = {
65 0x0202, /* Xbox Controller */
66 0x0285, /* Xbox Controller S */
67 0x0289, /* Xbox Controller S */
68 0x028e, /* Xbox360 Controller */
69 0x028f, /* Xbox360 Wireless Controller */
70 0x02d1, /* Xbox One Controller */
71 0x02dd, /* Xbox One Controller (Covert Forces/Firmware 2015) */
72 0x02e3, /* Xbox One Elite Controller */
73 0x02e6, /* Wireless XBox Controller Dongle */
74 0x02ea, /* Xbox One S Controller */
75 0x0719, /* Xbox 360 Wireless Adapter */
76 };
77
78 WINE_DECLARE_DEBUG_CHANNEL(hid_report);
79
80 static DRIVER_OBJECT *sdl_driver_obj = NULL;
81
82 static const WCHAR sdl_busidW[] = {'S','D','L','J','O','Y',0};
83
84 static DWORD map_controllers = 0;
85
86 #include "initguid.h"
87 DEFINE_GUID(GUID_DEVCLASS_SDL, 0x463d60b5,0x802b,0x4bb2,0x8f,0xdb,0x7d,0xa9,0xb9,0x96,0x04,0xd8);
88
89 static void *sdl_handle = NULL;
90
91 #ifdef SONAME_LIBSDL2
92 #define MAKE_FUNCPTR(f) static typeof(f) * p##f = NULL
93 MAKE_FUNCPTR(SDL_GetError);
94 MAKE_FUNCPTR(SDL_Init);
95 MAKE_FUNCPTR(SDL_JoystickEventState);
96 MAKE_FUNCPTR(SDL_JoystickGetGUID);
97 MAKE_FUNCPTR(SDL_JoystickGetGUIDString);
98 MAKE_FUNCPTR(SDL_JoystickInstanceID);
99 MAKE_FUNCPTR(SDL_JoystickName);
100 MAKE_FUNCPTR(SDL_JoystickNumAxes);
101 MAKE_FUNCPTR(SDL_JoystickOpen);
102 MAKE_FUNCPTR(SDL_WaitEvent);
103 MAKE_FUNCPTR(SDL_JoystickNumButtons);
104 MAKE_FUNCPTR(SDL_JoystickNumBalls);
105 MAKE_FUNCPTR(SDL_JoystickNumHats);
106 MAKE_FUNCPTR(SDL_JoystickGetAxis);
107 MAKE_FUNCPTR(SDL_JoystickGetHat);
108 MAKE_FUNCPTR(SDL_IsGameController);
109 MAKE_FUNCPTR(SDL_GameControllerGetAxis);
110 MAKE_FUNCPTR(SDL_GameControllerName);
111 MAKE_FUNCPTR(SDL_GameControllerOpen);
112 MAKE_FUNCPTR(SDL_GameControllerEventState);
113 MAKE_FUNCPTR(SDL_HapticClose);
114 MAKE_FUNCPTR(SDL_HapticDestroyEffect);
115 MAKE_FUNCPTR(SDL_HapticNewEffect);
116 MAKE_FUNCPTR(SDL_HapticOpenFromJoystick);
117 MAKE_FUNCPTR(SDL_HapticQuery);
118 MAKE_FUNCPTR(SDL_HapticRumbleInit);
119 MAKE_FUNCPTR(SDL_HapticRumblePlay);
120 MAKE_FUNCPTR(SDL_HapticRumbleSupported);
121 MAKE_FUNCPTR(SDL_HapticRunEffect);
122 MAKE_FUNCPTR(SDL_HapticStopAll);
123 MAKE_FUNCPTR(SDL_JoystickIsHaptic);
124 MAKE_FUNCPTR(SDL_memset);
125 #endif
126 static Uint16 (*pSDL_JoystickGetProduct)(SDL_Joystick * joystick);
127 static Uint16 (*pSDL_JoystickGetProductVersion)(SDL_Joystick * joystick);
128 static Uint16 (*pSDL_JoystickGetVendor)(SDL_Joystick * joystick);
129
130 struct platform_private
131 {
132 SDL_Joystick *sdl_joystick;
133 SDL_GameController *sdl_controller;
134 SDL_JoystickID id;
135
136 int axis_start;
137 int ball_start;
138 int hat_start;
139
140 int report_descriptor_size;
141 BYTE *report_descriptor;
142
143 int buffer_length;
144 BYTE *report_buffer;
145
146 SDL_Haptic *sdl_haptic;
147 int haptic_effect_id;
148 };
149
150 static inline struct platform_private *impl_from_DEVICE_OBJECT(DEVICE_OBJECT *device)
151 {
152 return (struct platform_private *)get_platform_private(device);
153 }
154
155 static const BYTE REPORT_AXIS_TAIL[] = {
156 0x16, 0x00, 0x80, /* LOGICAL_MINIMUM (-32768) */
157 0x26, 0xff, 0x7f, /* LOGICAL_MAXIMUM (32767) */
158 0x36, 0x00, 0x80, /* PHYSICAL_MINIMUM (-32768) */
159 0x46, 0xff, 0x7f, /* PHYSICAL_MAXIMUM (32767) */
160 0x75, 0x10, /* REPORT_SIZE (16) */
161 0x95, 0x00, /* REPORT_COUNT (?) */
162 0x81, 0x02, /* INPUT (Data,Var,Abs) */
163 };
164 #define IDX_ABS_AXIS_COUNT 15
165
166 static const BYTE CONTROLLER_BUTTONS[] = {
167 0x05, 0x09, /* USAGE_PAGE (Button) */
168 0x19, 0x01, /* USAGE_MINIMUM (Button 1) */
169 0x29, 0x0f, /* USAGE_MAXIMUM (Button 15) */
170 0x15, 0x00, /* LOGICAL_MINIMUM (0) */
171 0x25, 0x01, /* LOGICAL_MAXIMUM (1) */
172 0x35, 0x00, /* LOGICAL_MINIMUM (0) */
173 0x45, 0x01, /* LOGICAL_MAXIMUM (1) */
174 0x95, 0x0f, /* REPORT_COUNT (15) */
175 0x75, 0x01, /* REPORT_SIZE (1) */
176 0x81, 0x02, /* INPUT (Data,Var,Abs) */
177 /* padding */
178 0x95, 0x01, /* REPORT_COUNT (1) */
179 0x75, 0x01, /* REPORT_SIZE (1) */
180 0x81, 0x03, /* INPUT (Cnst,Var,Abs) */
181 };
182
183 static const BYTE CONTROLLER_AXIS [] = {
184 0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */
185 0x09, 0x30, /* USAGE (X) */
186 0x09, 0x31, /* USAGE (Y) */
187 0x09, 0x33, /* USAGE (RX) */
188 0x09, 0x34, /* USAGE (RY) */
189 0x16, 0x00, 0x80, /* LOGICAL_MINIMUM (-32768) */
190 0x26, 0xff, 0x7f, /* LOGICAL_MAXIMUM (32767) */
191 0x36, 0x00, 0x80, /* PHYSICAL_MINIMUM (-32768) */
192 0x46, 0xff, 0x7f, /* PHYSICAL_MAXIMUM (32767) */
193 0x75, 0x10, /* REPORT_SIZE (16) */
194 0x95, 0x04, /* REPORT_COUNT (4) */
195 0x81, 0x02, /* INPUT (Data,Var,Abs) */
196 };
197
198 static const BYTE CONTROLLER_TRIGGERS [] = {
199 0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */
200 0x09, 0x32, /* USAGE (Z) */
201 0x09, 0x35, /* USAGE (RZ) */
202 0x16, 0x00, 0x00, /* LOGICAL_MINIMUM (0) */
203 0x26, 0xff, 0x7f, /* LOGICAL_MAXIMUM (32767) */
204 0x36, 0x00, 0x00, /* PHYSICAL_MINIMUM (0) */
205 0x46, 0xff, 0x7f, /* PHYSICAL_MAXIMUM (32767) */
206 0x75, 0x10, /* REPORT_SIZE (16) */
207 0x95, 0x02, /* REPORT_COUNT (2) */
208 0x81, 0x02, /* INPUT (Data,Var,Abs) */
209 };
210
211 static const BYTE HAPTIC_RUMBLE[] = {
212 0x06, 0x00, 0xff, /* USAGE PAGE (vendor-defined) */
213 0x09, 0x01, /* USAGE (1) */
214 0x85, 0x00, /* REPORT_ID (0) */
215 /* padding */
216 0x95, 0x02, /* REPORT_COUNT (2) */
217 0x75, 0x08, /* REPORT_SIZE (8) */
218 0x91, 0x02, /* OUTPUT (Data,Var,Abs) */
219 /* actuators */
220 0x15, 0x00, /* LOGICAL MINIMUM (0) */
221 0x25, 0xff, /* LOGICAL MAXIMUM (255) */
222 0x35, 0x00, /* PHYSICAL MINIMUM (0) */
223 0x45, 0xff, /* PHYSICAL MAXIMUM (255) */
224 0x75, 0x08, /* REPORT_SIZE (8) */
225 0x95, 0x02, /* REPORT_COUNT (2) */
226 0x91, 0x02, /* OUTPUT (Data,Var,Abs) */
227 /* padding */
228 0x95, 0x02, /* REPORT_COUNT (3) */
229 0x75, 0x08, /* REPORT_SIZE (8) */
230 0x91, 0x02, /* OUTPUT (Data,Var,Abs) */
231 };
232
233 static BYTE *add_axis_block(BYTE *report_ptr, BYTE count, BYTE page, const BYTE *usages, BOOL absolute)
234 {
235 int i;
236 memcpy(report_ptr, REPORT_AXIS_HEADER, sizeof(REPORT_AXIS_HEADER));
237 report_ptr[IDX_AXIS_PAGE] = page;
238 report_ptr += sizeof(REPORT_AXIS_HEADER);
239 for (i = 0; i < count; i++)
240 {
241 memcpy(report_ptr, REPORT_AXIS_USAGE, sizeof(REPORT_AXIS_USAGE));
242 report_ptr[IDX_AXIS_USAGE] = usages[i];
243 report_ptr += sizeof(REPORT_AXIS_USAGE);
244 }
245 if (absolute)
246 {
247 memcpy(report_ptr, REPORT_AXIS_TAIL, sizeof(REPORT_AXIS_TAIL));
248 report_ptr[IDX_ABS_AXIS_COUNT] = count;
249 report_ptr += sizeof(REPORT_AXIS_TAIL);
250 }
251 else
252 {
253 memcpy(report_ptr, REPORT_REL_AXIS_TAIL, sizeof(REPORT_REL_AXIS_TAIL));
254 report_ptr[IDX_REL_AXIS_COUNT] = count;
255 report_ptr += sizeof(REPORT_REL_AXIS_TAIL);
256 }
257 return report_ptr;
258 }
259
260 static void set_axis_value(struct platform_private *ext, int index, short value)
261 {
262 int offset;
263 offset = ext->axis_start + index * 2;
264 *((WORD*)&ext->report_buffer[offset]) = LE_WORD(value);
265 }
266
267 static void set_ball_value(struct platform_private *ext, int index, int value1, int value2)
268 {
269 int offset;
270 offset = ext->ball_start + (index * 2);
271 if (value1 > 127) value1 = 127;
272 if (value1 < -127) value1 = -127;
273 if (value2 > 127) value2 = 127;
274 if (value2 < -127) value2 = -127;
275 ext->report_buffer[offset] = value1;
276 ext->report_buffer[offset + 1] = value2;
277 }
278
279 static void set_hat_value(struct platform_private *ext, int index, int value)
280 {
281 int offset;
282 offset = ext->hat_start + index;
283 switch (value)
284 {
285 case SDL_HAT_CENTERED: ext->report_buffer[offset] = 8; break;
286 case SDL_HAT_UP: ext->report_buffer[offset] = 0; break;
287 case SDL_HAT_RIGHTUP: ext->report_buffer[offset] = 1; break;
288 case SDL_HAT_RIGHT: ext->report_buffer[offset] = 2; break;
289 case SDL_HAT_RIGHTDOWN: ext->report_buffer[offset] = 3; break;
290 case SDL_HAT_DOWN: ext->report_buffer[offset] = 4; break;
291 case SDL_HAT_LEFTDOWN: ext->report_buffer[offset] = 5; break;
292 case SDL_HAT_LEFT: ext->report_buffer[offset] = 6; break;
293 case SDL_HAT_LEFTUP: ext->report_buffer[offset] = 7; break;
294 }
295 }
296
297 static int test_haptic(struct platform_private *ext)
298 {
299 int rc = 0;
300 if (pSDL_JoystickIsHaptic(ext->sdl_joystick))
301 {
302 ext->sdl_haptic = pSDL_HapticOpenFromJoystick(ext->sdl_joystick);
303 if (ext->sdl_haptic &&
304 ((pSDL_HapticQuery(ext->sdl_haptic) & SDL_HAPTIC_LEFTRIGHT) != 0 ||
305 pSDL_HapticRumbleSupported(ext->sdl_haptic)))
306 {
307 pSDL_HapticStopAll(ext->sdl_haptic);
308 pSDL_HapticRumbleInit(ext->sdl_haptic);
309 rc = sizeof(HAPTIC_RUMBLE);
310 ext->haptic_effect_id = -1;
311 }
312 else
313 {
314 pSDL_HapticClose(ext->sdl_haptic);
315 ext->sdl_haptic = NULL;
316 }
317 }
318 return rc;
319 }
320
321 static int build_haptic(struct platform_private *ext, BYTE *report_ptr)
322 {
323 if (ext->sdl_haptic)
324 {
325 memcpy(report_ptr, HAPTIC_RUMBLE, sizeof(HAPTIC_RUMBLE));
326 return (sizeof(HAPTIC_RUMBLE));
327 }
328 return 0;
329 }
330
331 static BOOL build_report_descriptor(struct platform_private *ext)
332 {
333 BYTE *report_ptr;
334 INT i, descript_size;
335 INT report_size;
336 INT button_count, axis_count, ball_count, hat_count;
337 static const BYTE device_usage[2] = {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_GAMEPAD};
338 static const BYTE controller_usages[] = {
339 HID_USAGE_GENERIC_X,
340 HID_USAGE_GENERIC_Y,
341 HID_USAGE_GENERIC_Z,
342 HID_USAGE_GENERIC_RX,
343 HID_USAGE_GENERIC_RY,
344 HID_USAGE_GENERIC_RZ,
345 HID_USAGE_GENERIC_SLIDER,
346 HID_USAGE_GENERIC_DIAL,
347 HID_USAGE_GENERIC_WHEEL};
348 static const BYTE joystick_usages[] = {
349 HID_USAGE_GENERIC_X,
350 HID_USAGE_GENERIC_Y,
351 HID_USAGE_GENERIC_Z,
352 HID_USAGE_GENERIC_RZ,
353 HID_USAGE_GENERIC_RX,
354 HID_USAGE_GENERIC_RY,
355 HID_USAGE_GENERIC_SLIDER,
356 HID_USAGE_GENERIC_DIAL,
357 HID_USAGE_GENERIC_WHEEL};
358
359 descript_size = sizeof(REPORT_HEADER) + sizeof(REPORT_TAIL);
360 report_size = 0;
361
362 /* For now lump all buttons just into incremental usages, Ignore Keys */
363 button_count = pSDL_JoystickNumButtons(ext->sdl_joystick);
364 if (button_count)
365 {
366 descript_size += sizeof(REPORT_BUTTONS);
367 if (button_count % 8)
368 descript_size += sizeof(REPORT_PADDING);
369 report_size = (button_count + 7) / 8;
370 }
371
372 axis_count = pSDL_JoystickNumAxes(ext->sdl_joystick);
373 if (axis_count > 6)
374 {
375 FIXME("Clamping joystick to 6 axis\n");
376 axis_count = 6;
377 }
378
379 ext->axis_start = report_size;
380 if (axis_count)
381 {
382 descript_size += sizeof(REPORT_AXIS_HEADER);
383 descript_size += (sizeof(REPORT_AXIS_USAGE) * axis_count);
384 descript_size += sizeof(REPORT_AXIS_TAIL);
385 report_size += (2 * axis_count);
386 }
387
388 ball_count = pSDL_JoystickNumBalls(ext->sdl_joystick);
389 ext->ball_start = report_size;
390 if (ball_count)
391 {
392 if ((ball_count*2) + axis_count > 9)
393 {
394 FIXME("Capping ball + axis at 9\n");
395 ball_count = (9-axis_count)/2;
396 }
397 descript_size += sizeof(REPORT_AXIS_HEADER);
398 descript_size += (sizeof(REPORT_AXIS_USAGE) * ball_count * 2);
399 descript_size += sizeof(REPORT_REL_AXIS_TAIL);
400 report_size += (2*ball_count);
401 }
402
403 hat_count = pSDL_JoystickNumHats(ext->sdl_joystick);
404 ext->hat_start = report_size;
405 if (hat_count)
406 {
407 descript_size += sizeof(REPORT_HATSWITCH);
408 for (i = 0; i < hat_count; i++)
409 report_size++;
410 }
411
412 descript_size += test_haptic(ext);
413
414 TRACE("Report Descriptor will be %i bytes\n", descript_size);
415 TRACE("Report will be %i bytes\n", report_size);
416
417 ext->report_descriptor = HeapAlloc(GetProcessHeap(), 0, descript_size);
418 if (!ext->report_descriptor)
419 {
420 ERR("Failed to alloc report descriptor\n");
421 return FALSE;
422 }
423 report_ptr = ext->report_descriptor;
424
425 memcpy(report_ptr, REPORT_HEADER, sizeof(REPORT_HEADER));
426 report_ptr[IDX_HEADER_PAGE] = device_usage[0];
427 report_ptr[IDX_HEADER_USAGE] = device_usage[1];
428 report_ptr += sizeof(REPORT_HEADER);
429 if (button_count)
430 {
431 report_ptr = add_button_block(report_ptr, 1, button_count);
432 if (button_count % 8)
433 {
434 BYTE padding = 8 - (button_count % 8);
435 report_ptr = add_padding_block(report_ptr, padding);
436 }
437 }
438 if (axis_count)
439 {
440 if (axis_count == 6 && button_count >= 14)
441 report_ptr = add_axis_block(report_ptr, axis_count, HID_USAGE_PAGE_GENERIC, controller_usages, TRUE);
442 else
443 report_ptr = add_axis_block(report_ptr, axis_count, HID_USAGE_PAGE_GENERIC, joystick_usages, TRUE);
444
445 }
446 if (ball_count)
447 {
448 report_ptr = add_axis_block(report_ptr, ball_count * 2, HID_USAGE_PAGE_GENERIC, &joystick_usages[axis_count], FALSE);
449 }
450 if (hat_count)
451 report_ptr = add_hatswitch(report_ptr, hat_count);
452
453 report_ptr += build_haptic(ext, report_ptr);
454 memcpy(report_ptr, REPORT_TAIL, sizeof(REPORT_TAIL));
455
456 ext->report_descriptor_size = descript_size;
457 ext->buffer_length = report_size;
458 ext->report_buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, report_size);
459 if (ext->report_buffer == NULL)
460 {
461 ERR("Failed to alloc report buffer\n");
462 HeapFree(GetProcessHeap(), 0, ext->report_descriptor);
463 return FALSE;
464 }
465
466 /* Initialize axis in the report */
467 for (i = 0; i < axis_count; i++)
468 set_axis_value(ext, i, pSDL_JoystickGetAxis(ext->sdl_joystick, i));
469 for (i = 0; i < hat_count; i++)
470 set_hat_value(ext, i, pSDL_JoystickGetHat(ext->sdl_joystick, i));
471
472 return TRUE;
473 }
474
475 static BOOL build_mapped_report_descriptor(struct platform_private *ext)
476 {
477 BYTE *report_ptr;
478 INT i, descript_size;
479
480 descript_size = sizeof(REPORT_HEADER) + sizeof(REPORT_TAIL);
481 descript_size += sizeof(CONTROLLER_BUTTONS);
482 descript_size += sizeof(CONTROLLER_AXIS);
483 descript_size += sizeof(CONTROLLER_TRIGGERS);
484 descript_size += test_haptic(ext);
485
486 ext->axis_start = 2;
487 ext->buffer_length = 14;
488
489 TRACE("Report Descriptor will be %i bytes\n", descript_size);
490 TRACE("Report will be %i bytes\n", ext->buffer_length);
491
492 ext->report_descriptor = HeapAlloc(GetProcessHeap(), 0, descript_size);
493 if (!ext->report_descriptor)
494 {
495 ERR("Failed to alloc report descriptor\n");
496 return FALSE;
497 }
498 report_ptr = ext->report_descriptor;
499
500 memcpy(report_ptr, REPORT_HEADER, sizeof(REPORT_HEADER));
501 report_ptr[IDX_HEADER_PAGE] = HID_USAGE_PAGE_GENERIC;
502 report_ptr[IDX_HEADER_USAGE] = HID_USAGE_GENERIC_GAMEPAD;
503 report_ptr += sizeof(REPORT_HEADER);
504 memcpy(report_ptr, CONTROLLER_BUTTONS, sizeof(CONTROLLER_BUTTONS));
505 report_ptr += sizeof(CONTROLLER_BUTTONS);
506 memcpy(report_ptr, CONTROLLER_AXIS, sizeof(CONTROLLER_AXIS));
507 report_ptr += sizeof(CONTROLLER_AXIS);
508 memcpy(report_ptr, CONTROLLER_TRIGGERS, sizeof(CONTROLLER_TRIGGERS));
509 report_ptr += sizeof(CONTROLLER_TRIGGERS);
510 report_ptr += build_haptic(ext, report_ptr);
511 memcpy(report_ptr, REPORT_TAIL, sizeof(REPORT_TAIL));
512
513 ext->report_descriptor_size = descript_size;
514 ext->report_buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ext->buffer_length);
515 if (ext->report_buffer == NULL)
516 {
517 ERR("Failed to alloc report buffer\n");
518 HeapFree(GetProcessHeap(), 0, ext->report_descriptor);
519 return FALSE;
520 }
521
522 /* Initialize axis in the report */
523 for (i = SDL_CONTROLLER_AXIS_LEFTX; i < SDL_CONTROLLER_AXIS_MAX; i++)
524 set_axis_value(ext, i, pSDL_GameControllerGetAxis(ext->sdl_controller, i));
525
526 return TRUE;
527 }
528
529 static int compare_platform_device(DEVICE_OBJECT *device, void *platform_dev)
530 {
531 SDL_JoystickID id1 = impl_from_DEVICE_OBJECT(device)->id;
532 SDL_JoystickID id2 = PtrToUlong(platform_dev);
533 return (id1 != id2);
534 }
535
536 static NTSTATUS get_reportdescriptor(DEVICE_OBJECT *device, BYTE *buffer, DWORD length, DWORD *out_length)
537 {
538 struct platform_private *ext = impl_from_DEVICE_OBJECT(device);
539
540 *out_length = ext->report_descriptor_size;
541
542 if (length < ext->report_descriptor_size)
543 return STATUS_BUFFER_TOO_SMALL;
544
545 memcpy(buffer, ext->report_descriptor, ext->report_descriptor_size);
546
547 return STATUS_SUCCESS;
548 }
549
550 static NTSTATUS get_string(DEVICE_OBJECT *device, DWORD index, WCHAR *buffer, DWORD length)
551 {
552 struct platform_private *ext = impl_from_DEVICE_OBJECT(device);
553 const char* str = NULL;
554
555 switch (index)
556 {
557 case HID_STRING_ID_IPRODUCT:
558 if (ext->sdl_controller)
559 str = pSDL_GameControllerName(ext->sdl_controller);
560 else
561 str = pSDL_JoystickName(ext->sdl_joystick);
562 break;
563 case HID_STRING_ID_IMANUFACTURER:
564 str = "SDL";
565 break;
566 case HID_STRING_ID_ISERIALNUMBER:
567 str = "000000";
568 break;
569 default:
570 ERR("Unhandled string index %i\n", index);
571 }
572
573 if (str && str[0])
574 MultiByteToWideChar(CP_ACP, 0, str, -1, buffer, length);
575 else
576 buffer[0] = 0;
577
578 return STATUS_SUCCESS;
579 }
580
581 static NTSTATUS begin_report_processing(DEVICE_OBJECT *device)
582 {
583 return STATUS_SUCCESS;
584 }
585
586 static NTSTATUS set_output_report(DEVICE_OBJECT *device, UCHAR id, BYTE *report, DWORD length, ULONG_PTR *written)
587 {
588 struct platform_private *ext = impl_from_DEVICE_OBJECT(device);
589
590 if (ext->sdl_haptic && id == 0)
591 {
592 WORD left = report[2] * 128;
593 WORD right = report[3] * 128;
594
595 if (ext->haptic_effect_id >= 0)
596 {
597 pSDL_HapticDestroyEffect(ext->sdl_haptic, ext->haptic_effect_id);
598 ext->haptic_effect_id = -1;
599 }
600 pSDL_HapticStopAll(ext->sdl_haptic);
601 if (left != 0 || right != 0)
602 {
603 SDL_HapticEffect effect;
604
605 pSDL_memset( &effect, 0, sizeof(SDL_HapticEffect) );
606 effect.type = SDL_HAPTIC_LEFTRIGHT;
607 effect.leftright.length = -1;
608 effect.leftright.large_magnitude = left;
609 effect.leftright.small_magnitude = right;
610
611 ext->haptic_effect_id = pSDL_HapticNewEffect(ext->sdl_haptic, &effect);
612 if (ext->haptic_effect_id >= 0)
613 {
614 pSDL_HapticRunEffect(ext->sdl_haptic, ext->haptic_effect_id, 1);
615 }
616 else
617 {
618 float i = (float)((left + right)/2.0) / 32767.0;
619 pSDL_HapticRumblePlay(ext->sdl_haptic, i, -1);
620 }
621 }
622 *written = length;
623 return STATUS_SUCCESS;
624 }
625 else
626 {
627 *written = 0;
628 return STATUS_NOT_IMPLEMENTED;
629 }
630 }
631
632 static NTSTATUS get_feature_report(DEVICE_OBJECT *device, UCHAR id, BYTE *report, DWORD length, ULONG_PTR *read)
633 {
634 *read = 0;
635 return STATUS_NOT_IMPLEMENTED;
636 }
637
638 static NTSTATUS set_feature_report(DEVICE_OBJECT *device, UCHAR id, BYTE *report, DWORD length, ULONG_PTR *written)
639 {
640 *written = 0;
641 return STATUS_NOT_IMPLEMENTED;
642 }
643
644 static const platform_vtbl sdl_vtbl =
645 {
646 compare_platform_device,
647 get_reportdescriptor,
648 get_string,
649 begin_report_processing,
650 set_output_report,
651 get_feature_report,
652 set_feature_report,
653 };
654
655 static BOOL set_report_from_event(SDL_Event *event)
656 {
657 DEVICE_OBJECT *device;
658 struct platform_private *private;
659 /* All the events coming in will have 'which' as a 3rd field */
660 SDL_JoystickID index = ((SDL_JoyButtonEvent*)event)->which;
661
662 device = bus_find_hid_device(&sdl_vtbl, ULongToPtr(index));
663 if (!device)
664 {
665 ERR("Failed to find device at index %i\n",index);
666 return FALSE;
667 }
668 private = impl_from_DEVICE_OBJECT(device);
669 if (private->sdl_controller)
670 {
671 /* We want mapped events */
672 return TRUE;
673 }
674
675 switch(event->type)
676 {
677 case SDL_JOYBUTTONDOWN:
678 case SDL_JOYBUTTONUP:
679 {
680 SDL_JoyButtonEvent *ie = &event->jbutton;
681
682 set_button_value(ie->button, ie->state, private->report_buffer);
683
684 process_hid_report(device, private->report_buffer, private->buffer_length);
685 break;
686 }
687 case SDL_JOYAXISMOTION:
688 {
689 SDL_JoyAxisEvent *ie = &event->jaxis;
690
691 if (ie->axis < 6)
692 {
693 set_axis_value(private, ie->axis, ie->value);
694 process_hid_report(device, private->report_buffer, private->buffer_length);
695 }
696 break;
697 }
698 case SDL_JOYBALLMOTION:
699 {
700 SDL_JoyBallEvent *ie = &event->jball;
701
702 set_ball_value(private, ie->ball, ie->xrel, ie->yrel);
703 process_hid_report(device, private->report_buffer, private->buffer_length);
704 break;
705 }
706 case SDL_JOYHATMOTION:
707 {
708 SDL_JoyHatEvent *ie = &event->jhat;
709
710 set_hat_value(private, ie->hat, ie->value);
711 process_hid_report(device, private->report_buffer, private->buffer_length);
712 break;
713 }
714 default:
715 ERR("TODO: Process Report (0x%x)\n",event->type);
716 }
717 return FALSE;
718 }
719
720 static BOOL set_mapped_report_from_event(SDL_Event *event)
721 {
722 DEVICE_OBJECT *device;
723 struct platform_private *private;
724 /* All the events coming in will have 'which' as a 3rd field */
725 int index = ((SDL_ControllerButtonEvent*)event)->which;
726 device = bus_find_hid_device(&sdl_vtbl, ULongToPtr(index));
727 if (!device)
728 {
729 ERR("Failed to find device at index %i\n",index);
730 return FALSE;
731 }
732 private = impl_from_DEVICE_OBJECT(device);
733
734 switch(event->type)
735 {
736 case SDL_CONTROLLERBUTTONDOWN:
737 case SDL_CONTROLLERBUTTONUP:
738 {
739 int usage = -1;
740 SDL_ControllerButtonEvent *ie = &event->cbutton;
741
742 switch (ie->button)
743 {
744 case SDL_CONTROLLER_BUTTON_A: usage = 0; break;
745 case SDL_CONTROLLER_BUTTON_B: usage = 1; break;
746 case SDL_CONTROLLER_BUTTON_X: usage = 2; break;
747 case SDL_CONTROLLER_BUTTON_Y: usage = 3; break;
748 case SDL_CONTROLLER_BUTTON_LEFTSHOULDER: usage = 4; break;
749 case SDL_CONTROLLER_BUTTON_RIGHTSHOULDER: usage = 5; break;
750 case SDL_CONTROLLER_BUTTON_LEFTSTICK: usage = 6; break;
751 case SDL_CONTROLLER_BUTTON_RIGHTSTICK: usage = 7; break;
752 case SDL_CONTROLLER_BUTTON_START: usage = 8; break;
753 case SDL_CONTROLLER_BUTTON_BACK: usage = 9; break;
754 case SDL_CONTROLLER_BUTTON_GUIDE: usage = 10; break;
755 case SDL_CONTROLLER_BUTTON_DPAD_UP: usage = 11; break;
756 case SDL_CONTROLLER_BUTTON_DPAD_DOWN: usage = 12; break;
757 case SDL_CONTROLLER_BUTTON_DPAD_LEFT: usage = 13; break;
758 case SDL_CONTROLLER_BUTTON_DPAD_RIGHT: usage = 14; break;
759 default:
760 ERR("Unknown Button %i\n",ie->button);
761 }
762
763 if (usage >= 0)
764 {
765 set_button_value(usage, ie->state, private->report_buffer);
766 process_hid_report(device, private->report_buffer, private->buffer_length);
767 }
768 break;
769 }
770 case SDL_CONTROLLERAXISMOTION:
771 {
772 SDL_ControllerAxisEvent *ie = &event->caxis;
773
774 set_axis_value(private, ie->axis, ie->value);
775 process_hid_report(device, private->report_buffer, private->buffer_length);
776 break;
777 }
778 default:
779 ERR("TODO: Process Report (%x)\n",event->type);
780 }
781 return FALSE;
782 }
783
784 static void try_remove_device(SDL_JoystickID index)
785 {
786 DEVICE_OBJECT *device = NULL;
787
788 device = bus_find_hid_device(&sdl_vtbl, ULongToPtr(index));
789 if (!device) return;
790
791 IoInvalidateDeviceRelations(device, RemovalRelations);
792
793 bus_remove_hid_device(device);
794 }
795
796 static void try_add_device(SDL_JoystickID index)
797 {
798 DWORD vid = 0, pid = 0, version = 0;
799 DEVICE_OBJECT *device = NULL;
800 WCHAR serial[34] = {0};
801 char guid_str[34];
802 BOOL is_xbox_gamepad;
803
804 SDL_Joystick* joystick;
805 SDL_JoystickID id;
806 SDL_JoystickGUID guid;
807 SDL_GameController *controller = NULL;
808
809 if ((joystick = pSDL_JoystickOpen(index)) == NULL)
810 {
811 WARN("Unable to open sdl device %i: %s\n", index, pSDL_GetError());
812 return;
813 }
814
815 if (map_controllers && pSDL_IsGameController(index))
816 controller = pSDL_GameControllerOpen(index);
817
818 id = index;
819 if (controller)
820 {
821 vid = VID_MICROSOFT;
822 pid = PID_XBOX_CONTROLLERS[3];
823 version = 0x01;
824 }
825 else
826 {
827 if (pSDL_JoystickGetProductVersion != NULL) {
828 vid = pSDL_JoystickGetVendor(joystick);
829 pid = pSDL_JoystickGetProduct(joystick);
830 version = pSDL_JoystickGetProductVersion(joystick);
831 }
832 else
833 {
834 vid = 0x01;
835 pid = pSDL_JoystickInstanceID(joystick) + 1;
836 version = 0;
837 }
838 }
839
840 guid = pSDL_JoystickGetGUID(joystick);
841 pSDL_JoystickGetGUIDString(guid, guid_str, sizeof(guid_str));
842 MultiByteToWideChar(CP_ACP, 0, guid_str, -1, serial, sizeof(guid_str));
843
844 if (controller)
845 {
846 TRACE("Found sdl game controller %i (vid %04x, pid %04x, version %u, serial %s)\n",
847 index, vid, pid, version, debugstr_w(serial));
848 is_xbox_gamepad = TRUE;
849 }
850 else
851 {
852 int button_count, axis_count;
853
854 TRACE("Found sdl device %i (vid %04x, pid %04x, version %u, serial %s)\n",
855 index, vid, pid, version, debugstr_w(serial));
856
857 axis_count = pSDL_JoystickNumAxes(joystick);
858 button_count = pSDL_JoystickNumAxes(joystick);
859 is_xbox_gamepad = (axis_count == 6 && button_count >= 14);
860 }
861
862 device = bus_create_hid_device(sdl_driver_obj, sdl_busidW, vid, pid, version, 0, serial, is_xbox_gamepad, &GUID_DEVCLASS_SDL, &sdl_vtbl, sizeof(struct platform_private));
863
864 if (device)
865 {
866 BOOL rc;
867 struct platform_private *private = impl_from_DEVICE_OBJECT(device);
868 private->sdl_joystick = joystick;
869 private->sdl_controller = controller;
870 private->id = id;
871 if (controller)
872 rc = build_mapped_report_descriptor(private);
873 else
874 rc = build_report_descriptor(private);
875 if (!rc)
876 {
877 ERR("Building report descriptor failed, removing device\n");
878 bus_remove_hid_device(device);
879 HeapFree(GetProcessHeap(), 0, serial);
880 return;
881 }
882 IoInvalidateDeviceRelations(device, BusRelations);
883 }
884 else
885 {
886 WARN("Ignoring device %i\n", index);
887 }
888 }
889
890 static void process_device_event(SDL_Event *event)
891 {
892 TRACE_(hid_report)("Received action %x\n", event->type);
893
894 if (event->type == SDL_JOYDEVICEADDED)
895 try_add_device(((SDL_JoyDeviceEvent*)event)->which);
896 else if (event->type == SDL_JOYDEVICEREMOVED)
897 try_remove_device(((SDL_JoyDeviceEvent*)event)->which);
898 else if (event->type >= SDL_JOYAXISMOTION && event->type <= SDL_JOYBUTTONUP)
899 set_report_from_event(event);
900 else if (event->type >= SDL_CONTROLLERAXISMOTION && event->type <= SDL_CONTROLLERBUTTONUP)
901 set_mapped_report_from_event(event);
902 }
903
904 static DWORD CALLBACK deviceloop_thread(void *args)
905 {
906 HANDLE init_done = args;
907 SDL_Event event;
908
909 if (pSDL_Init(SDL_INIT_GAMECONTROLLER|SDL_INIT_HAPTIC) < 0)
910 {
911 ERR("Can't Init SDL\n");
912 return STATUS_UNSUCCESSFUL;
913 }
914
915 pSDL_JoystickEventState(SDL_ENABLE);
916 pSDL_GameControllerEventState(SDL_ENABLE);
917
918 SetEvent(init_done);
919
920 while (1)
921 while (pSDL_WaitEvent(&event) != 0)
922 process_device_event(&event);
923
924 TRACE("Device thread exiting\n");
925 return 0;
926 }
927
928 NTSTATUS WINAPI sdl_driver_init(DRIVER_OBJECT *driver, UNICODE_STRING *registry_path)
929 {
930 static const WCHAR controller_modeW[] = {'M','a','p',' ','C','o','n','t','r','o','l','l','e','r','s',0};
931 static const UNICODE_STRING controller_mode = {sizeof(controller_modeW) - sizeof(WCHAR), sizeof(controller_modeW), (WCHAR*)controller_modeW};
932
933 HANDLE events[2];
934 DWORD result;
935
936 TRACE("(%p, %s)\n", driver, debugstr_w(registry_path->Buffer));
937 if (sdl_handle == NULL)
938 {
939 sdl_handle = wine_dlopen(SONAME_LIBSDL2, RTLD_NOW, NULL, 0);
940 if (!sdl_handle) {
941 WARN("could not load %s\n", SONAME_LIBSDL2);
942 sdl_driver_obj = NULL;
943 return STATUS_UNSUCCESSFUL;
944 }
945 #define LOAD_FUNCPTR(f) if((p##f = wine_dlsym(sdl_handle, #f, NULL, 0)) == NULL){WARN("Can't find symbol %s\n", #f); goto sym_not_found;}
946 LOAD_FUNCPTR(SDL_GetError);
947 LOAD_FUNCPTR(SDL_Init);
948 LOAD_FUNCPTR(SDL_JoystickEventState);
949 LOAD_FUNCPTR(SDL_JoystickGetGUID);
950 LOAD_FUNCPTR(SDL_JoystickGetGUIDString);
951 LOAD_FUNCPTR(SDL_JoystickInstanceID);
952 LOAD_FUNCPTR(SDL_JoystickName);
953 LOAD_FUNCPTR(SDL_JoystickNumAxes);
954 LOAD_FUNCPTR(SDL_JoystickOpen);
955 LOAD_FUNCPTR(SDL_WaitEvent);
956 LOAD_FUNCPTR(SDL_JoystickNumButtons);
957 LOAD_FUNCPTR(SDL_JoystickNumBalls);
958 LOAD_FUNCPTR(SDL_JoystickNumHats);
959 LOAD_FUNCPTR(SDL_JoystickGetAxis);
960 LOAD_FUNCPTR(SDL_JoystickGetHat);
961 LOAD_FUNCPTR(SDL_IsGameController);
962 LOAD_FUNCPTR(SDL_GameControllerGetAxis);
963 LOAD_FUNCPTR(SDL_GameControllerName);
964 LOAD_FUNCPTR(SDL_GameControllerOpen);
965 LOAD_FUNCPTR(SDL_GameControllerEventState);
966 LOAD_FUNCPTR(SDL_HapticClose);
967 LOAD_FUNCPTR(SDL_HapticDestroyEffect);
968 LOAD_FUNCPTR(SDL_HapticNewEffect);
969 LOAD_FUNCPTR(SDL_HapticOpenFromJoystick);
970 LOAD_FUNCPTR(SDL_HapticQuery);
971 LOAD_FUNCPTR(SDL_HapticRumbleInit);
972 LOAD_FUNCPTR(SDL_HapticRumblePlay);
973 LOAD_FUNCPTR(SDL_HapticRumbleSupported);
974 LOAD_FUNCPTR(SDL_HapticRunEffect);
975 LOAD_FUNCPTR(SDL_HapticStopAll);
976 LOAD_FUNCPTR(SDL_JoystickIsHaptic);
977 LOAD_FUNCPTR(SDL_memset);
978 #undef LOAD_FUNCPTR
979 pSDL_JoystickGetProduct = wine_dlsym(sdl_handle, "SDL_JoystickGetProduct", NULL, 0);
980 pSDL_JoystickGetProductVersion = wine_dlsym(sdl_handle, "SDL_JoystickGetProductVersion", NULL, 0);
981 pSDL_JoystickGetVendor = wine_dlsym(sdl_handle, "SDL_JoystickGetVendor", NULL, 0);
982 }
983
984 sdl_driver_obj = driver;
985 driver->MajorFunction[IRP_MJ_PNP] = common_pnp_dispatch;
986 driver->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = hid_internal_dispatch;
987
988 map_controllers = check_bus_option(registry_path, &controller_mode, 1);
989
990 if (!(events[0] = CreateEventW(NULL, TRUE, FALSE, NULL)))
991 goto error;
992 if (!(events[1] = CreateThread(NULL, 0, deviceloop_thread, events[0], 0, NULL)))
993 {
994 CloseHandle(events[0]);
995 goto error;
996 }
997
998 result = WaitForMultipleObjects(2, events, FALSE, INFINITE);
999 CloseHandle(events[0]);
1000 CloseHandle(events[1]);
1001 if (result == WAIT_OBJECT_0)
1002 {
1003 TRACE("Initialization successful\n");
1004 return STATUS_SUCCESS;
1005 }
1006
1007 error:
1008 sdl_driver_obj = NULL;
1009 return STATUS_UNSUCCESSFUL;
1010 sym_not_found:
1011 wine_dlclose(sdl_handle, NULL, 0);
1012 sdl_handle = NULL;
1013 return STATUS_UNSUCCESSFUL;
1014 }
1015
1016 #else
1017
1018 NTSTATUS WINAPI sdl_driver_init(DRIVER_OBJECT *driver, UNICODE_STRING *registry_path)
1019 {
1020 WARN("compiled without SDL support\n");
1021 return STATUS_NOT_IMPLEMENTED;
1022 }
1023
1024 #endif /* SONAME_LIBSDL2 */
Windows API implementation