?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push ab680a7236c9c9956912834ac5e9ecad31a71bf2
[wine/hacks.git] / dlls / dinput / joystick_linuxinput.c
blobf5dc542df20da63a745cccdef4ea224707eb408d
1 /* DirectInput Joystick device
2 *
3 * Copyright 1998,2000 Marcus Meissner
4 * Copyright 1998,1999 Lionel Ulmer
5 * Copyright 2000-2001 TransGaming Technologies Inc.
6 * Copyright 2005 Daniel Remenak
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <assert.h>
27 #include <stdarg.h>
28 #include <stdio.h>
29 #include <string.h>
30 #include <time.h>
31 #ifdef HAVE_UNISTD_H
32 # include <unistd.h>
33 #endif
34 #ifdef HAVE_SYS_TIME_H
35 # include <sys/time.h>
36 #endif
37 #include <fcntl.h>
38 #ifdef HAVE_SYS_IOCTL_H
39 # include <sys/ioctl.h>
40 #endif
41 #include <errno.h>
42 #ifdef HAVE_SYS_ERRNO_H
43 # include <sys/errno.h>
44 #endif
45 #ifdef HAVE_LINUX_INPUT_H
46 # include <linux/input.h>
47 # undef SW_MAX
48 # if defined(EVIOCGBIT) && defined(EV_ABS) && defined(BTN_PINKIE)
49 # define HAVE_CORRECT_LINUXINPUT_H
50 # endif
51 #endif
52 #ifdef HAVE_SYS_POLL_H
53 # include <sys/poll.h>
54 #endif
55
56 #include "wine/debug.h"
57 #include "wine/unicode.h"
58 #include "wine/list.h"
59 #include "windef.h"
60 #include "winbase.h"
61 #include "winerror.h"
62 #include "winreg.h"
63 #include "dinput.h"
64
65 #include "dinput_private.h"
66 #include "device_private.h"
67 #include "joystick_private.h"
68
69 WINE_DEFAULT_DEBUG_CHANNEL(dinput);
70
71 #ifdef HAVE_CORRECT_LINUXINPUT_H
72
73 #define EVDEVPREFIX "/dev/input/event"
74
75 /* Wine joystick driver object instances */
76 #define WINE_JOYSTICK_MAX_AXES 8
77 #define WINE_JOYSTICK_MAX_POVS 4
78 #define WINE_JOYSTICK_MAX_BUTTONS 128
79
80 struct wine_input_absinfo {
81 LONG value;
82 LONG minimum;
83 LONG maximum;
84 LONG fuzz;
85 LONG flat;
86 };
87
88 /* implemented in effect_linuxinput.c */
89 HRESULT linuxinput_create_effect(int* fd, REFGUID rguid, struct list *parent_list_entry, LPDIRECTINPUTEFFECT* peff);
90 HRESULT linuxinput_get_info_A(int fd, REFGUID rguid, LPDIEFFECTINFOA info);
91 HRESULT linuxinput_get_info_W(int fd, REFGUID rguid, LPDIEFFECTINFOW info);
92
93 typedef struct JoystickImpl JoystickImpl;
94 static const IDirectInputDevice8AVtbl JoystickAvt;
95 static const IDirectInputDevice8WVtbl JoystickWvt;
96
97 struct JoyDev {
98 char *device;
99 char *name;
100 GUID guid;
101
102 int has_ff;
103 int num_effects;
104
105 /* data returned by EVIOCGBIT for caps, EV_ABS, EV_KEY, and EV_FF */
106 BYTE evbits[(EV_MAX+7)/8];
107 BYTE absbits[(ABS_MAX+7)/8];
108 BYTE keybits[(KEY_MAX+7)/8];
109 BYTE ffbits[(FF_MAX+7)/8];
110
111 /* data returned by the EVIOCGABS() ioctl */
112 struct wine_input_absinfo axes[ABS_MAX];
113 };
114
115 struct JoystickImpl
116 {
117 struct IDirectInputDevice2AImpl base;
118
119 struct JoyDev *joydev;
120
121 /* joystick private */
122 int joyfd;
123
124 DIJOYSTATE2 js;
125
126 ObjProps props[ABS_MAX];
127
128 int axes[ABS_MAX];
129 POINTL povs[4];
130
131 /* LUT for KEY_ to offset in rgbButtons */
132 BYTE buttons[KEY_MAX];
133
134 DWORD numAxes;
135 DWORD numPOVs;
136 DWORD numButtons;
137
138 /* Force feedback variables */
139 struct list ff_effects;
140 int ff_state;
141 int ff_autocenter;
142 int ff_gain;
143 };
144
145 static void fake_current_js_state(JoystickImpl *ji);
146 static void find_joydevs(void);
147
148 /* This GUID is slightly different from the linux joystick one. Take note. */
149 static const GUID DInput_Wine_Joystick_Base_GUID = { /* 9e573eda-7734-11d2-8d4a-23903fb6bdf7 */
150 0x9e573eda,
151 0x7734,
152 0x11d2,
153 {0x8d, 0x4a, 0x23, 0x90, 0x3f, 0xb6, 0xbd, 0xf7}
154 };
155
156 #define test_bit(arr,bit) (((BYTE*)(arr))[(bit)>>3]&(1<<((bit)&7)))
157
158 #define MAX_JOYDEV 64
159
160 static int have_joydevs = -1;
161 static struct JoyDev *joydevs = NULL;
162
163 static void find_joydevs(void)
164 {
165 int i;
166
167 if (InterlockedCompareExchange(&have_joydevs, 0, -1) != -1)
168 /* Someone beat us to it */
169 return;
170
171 for (i = 0; i < MAX_JOYDEV; i++)
172 {
173 char buf[MAX_PATH];
174 struct JoyDev joydev = {0};
175 int fd;
176 int no_ff_check = 0;
177 int j;
178 struct JoyDev *new_joydevs;
179
180 snprintf(buf, sizeof(buf), EVDEVPREFIX"%d", i);
181
182 if ((fd = open(buf, O_RDWR)) == -1)
183 {
184 fd = open(buf, O_RDONLY);
185 no_ff_check = 1;
186 }
187
188 if (fd == -1)
189 {
190 WARN("Failed to open \"%s\": %d %s\n", buf, errno, strerror(errno));
191 continue;
192 }
193
194 if (ioctl(fd, EVIOCGBIT(0, sizeof(joydev.evbits)), joydev.evbits) == -1)
195 {
196 WARN("ioct(EVIOCGBIT, 0) failed: %d %s\n", errno, strerror(errno));
197 close(fd);
198 continue;
199 }
200 if (ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(joydev.absbits)), joydev.absbits) == -1)
201 {
202 WARN("ioct(EVIOCGBIT, EV_ABS) failed: %d %s\n", errno, strerror(errno));
203 close(fd);
204 continue;
205 }
206 if (ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(joydev.keybits)), joydev.keybits) == -1)
207 {
208 WARN("ioct(EVIOCGBIT, EV_KEY) failed: %d %s\n", errno, strerror(errno));
209 close(fd);
210 continue;
211 }
212
213 /* A true joystick has at least axis X and Y, and at least 1
214 * button. copied from linux/drivers/input/joydev.c */
215 if (!test_bit(joydev.absbits, ABS_X) || !test_bit(joydev.absbits, ABS_Y) ||
216 !(test_bit(joydev.keybits, BTN_TRIGGER) ||
217 test_bit(joydev.keybits, BTN_A) ||
218 test_bit(joydev.keybits, BTN_1)))
219 {
220 close(fd);
221 continue;
222 }
223
224 if (!(joydev.device = HeapAlloc(GetProcessHeap(), 0, strlen(buf) + 1)))
225 {
226 close(fd);
227 continue;
228 }
229 strcpy(joydev.device, buf);
230
231 buf[MAX_PATH - 1] = 0;
232 if (ioctl(fd, EVIOCGNAME(MAX_PATH - 1), buf) != -1 &&
233 (joydev.name = HeapAlloc(GetProcessHeap(), 0, strlen(buf) + 1)))
234 strcpy(joydev.name, buf);
235 else
236 joydev.name = joydev.device;
237
238 joydev.guid = DInput_Wine_Joystick_Base_GUID;
239 joydev.guid.Data3 += have_joydevs;
240
241 TRACE("Found a joystick on %s: %s (%s)\n",
242 joydev.device, joydev.name,
243 debugstr_guid(&joydev.guid)
244 );
245
246 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
247 if (!no_ff_check &&
248 test_bit(joydev.evbits, EV_FF) &&
249 ioctl(fd, EVIOCGBIT(EV_FF, sizeof(joydev.ffbits)), joydev.ffbits) != -1 &&
250 ioctl(fd, EVIOCGEFFECTS, &joydev.num_effects) != -1 &&
251 joydev.num_effects > 0)
252 {
253 TRACE(" ... with force feedback\n");
254 joydev.has_ff = 1;
255 }
256 #endif
257
258 for (j = 0; j < ABS_MAX;j ++)
259 {
260 if (!test_bit(joydev.absbits, j)) continue;
261 if (ioctl(fd, EVIOCGABS(j), &(joydev.axes[j])) != -1)
262 {
263 TRACE(" ... with axis %d: cur=%d, min=%d, max=%d, fuzz=%d, flat=%d\n",
264 j,
265 joydev.axes[j].value,
266 joydev.axes[j].minimum,
267 joydev.axes[j].maximum,
268 joydev.axes[j].fuzz,
269 joydev.axes[j].flat
270 );
271 }
272 }
273
274 if (!have_joydevs)
275 new_joydevs = HeapAlloc(GetProcessHeap(), 0, sizeof(struct JoyDev));
276 else
277 new_joydevs = HeapReAlloc(GetProcessHeap(), 0, joydevs, (1 + have_joydevs) * sizeof(struct JoyDev));
278
279 if (!new_joydevs)
280 {
281 close(fd);
282 continue;
283 }
284 joydevs = new_joydevs;
285 memcpy(joydevs + have_joydevs, &joydev, sizeof(joydev));
286 have_joydevs++;
287
288 close(fd);
289 }
290 }
291
292 static void fill_joystick_dideviceinstanceA(LPDIDEVICEINSTANCEA lpddi, DWORD version, int id)
293 {
294 DWORD dwSize = lpddi->dwSize;
295
296 TRACE("%d %p\n", dwSize, lpddi);
297 memset(lpddi, 0, dwSize);
298
299 lpddi->dwSize = dwSize;
300 lpddi->guidInstance = joydevs[id].guid;
301 lpddi->guidProduct = DInput_Wine_Joystick_Base_GUID;
302 lpddi->guidFFDriver = GUID_NULL;
303
304 if (version >= 0x0800)
305 lpddi->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
306 else
307 lpddi->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
308
309 strcpy(lpddi->tszInstanceName, joydevs[id].name);
310 strcpy(lpddi->tszProductName, joydevs[id].device);
311 }
312
313 static void fill_joystick_dideviceinstanceW(LPDIDEVICEINSTANCEW lpddi, DWORD version, int id)
314 {
315 DWORD dwSize = lpddi->dwSize;
316
317 TRACE("%d %p\n", dwSize, lpddi);
318 memset(lpddi, 0, dwSize);
319
320 lpddi->dwSize = dwSize;
321 lpddi->guidInstance = joydevs[id].guid;
322 lpddi->guidProduct = DInput_Wine_Joystick_Base_GUID;
323 lpddi->guidFFDriver = GUID_NULL;
324
325 if (version >= 0x0800)
326 lpddi->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
327 else
328 lpddi->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
329
330 MultiByteToWideChar(CP_ACP, 0, joydevs[id].name, -1, lpddi->tszInstanceName, MAX_PATH);
331 MultiByteToWideChar(CP_ACP, 0, joydevs[id].device, -1, lpddi->tszProductName, MAX_PATH);
332 }
333
334 static BOOL joydev_enum_deviceA(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINSTANCEA lpddi, DWORD version, int id)
335 {
336 find_joydevs();
337
338 if (id >= have_joydevs) {
339 return FALSE;
340 }
341
342 if (!((dwDevType == 0) ||
343 ((dwDevType == DIDEVTYPE_JOYSTICK) && (version > 0x0300 && version < 0x0800)) ||
344 (((dwDevType == DI8DEVCLASS_GAMECTRL) || (dwDevType == DI8DEVTYPE_JOYSTICK)) && (version >= 0x0800))))
345 return FALSE;
346
347 #ifndef HAVE_STRUCT_FF_EFFECT_DIRECTION
348 if (dwFlags & DIEDFL_FORCEFEEDBACK)
349 return FALSE;
350 #endif
351
352 if (!(dwFlags & DIEDFL_FORCEFEEDBACK) || joydevs[id].has_ff) {
353 fill_joystick_dideviceinstanceA(lpddi, version, id);
354 return TRUE;
355 }
356 return FALSE;
357 }
358
359 static BOOL joydev_enum_deviceW(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINSTANCEW lpddi, DWORD version, int id)
360 {
361 find_joydevs();
362
363 if (id >= have_joydevs) {
364 return FALSE;
365 }
366
367 if (!((dwDevType == 0) ||
368 ((dwDevType == DIDEVTYPE_JOYSTICK) && (version > 0x0300 && version < 0x0800)) ||
369 (((dwDevType == DI8DEVCLASS_GAMECTRL) || (dwDevType == DI8DEVTYPE_JOYSTICK)) && (version >= 0x0800))))
370 return FALSE;
371
372 #ifndef HAVE_STRUCT_FF_EFFECT_DIRECTION
373 if (dwFlags & DIEDFL_FORCEFEEDBACK)
374 return FALSE;
375 #endif
376
377 if (!(dwFlags & DIEDFL_FORCEFEEDBACK) || joydevs[id].has_ff) {
378 fill_joystick_dideviceinstanceW(lpddi, version, id);
379 return TRUE;
380 }
381 return FALSE;
382 }
383
384 static JoystickImpl *alloc_device(REFGUID rguid, const void *jvt, IDirectInputImpl *dinput, unsigned short index)
385 {
386 JoystickImpl* newDevice;
387 LPDIDATAFORMAT df = NULL;
388 int i, idx = 0;
389 char buffer[MAX_PATH+16];
390 HKEY hkey, appkey;
391 LONG def_deadzone = 0;
392
393 newDevice = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(JoystickImpl));
394 if (!newDevice) return NULL;
395
396 newDevice->base.lpVtbl = jvt;
397 newDevice->base.ref = 1;
398 newDevice->base.guid = *rguid;
399 newDevice->base.dinput = dinput;
400 newDevice->joyfd = -1;
401 newDevice->joydev = &joydevs[index];
402 list_init(&newDevice->ff_effects);
403 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
404 newDevice->ff_state = FF_STATUS_STOPPED;
405 #endif
406 /* There is no way in linux to query force feedback autocenter status.
407 Instead, track it with ff_autocenter, and assume it's initialy
408 enabled. */
409 newDevice->ff_autocenter = 1;
410 newDevice->ff_gain = 0xFFFF;
411 InitializeCriticalSection(&newDevice->base.crit);
412 newDevice->base.crit.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": JoystickImpl*->base.crit");
413
414 /* get options */
415 get_app_key(&hkey, &appkey);
416
417 if (!get_config_key(hkey, appkey, "DefaultDeadZone", buffer, MAX_PATH))
418 {
419 def_deadzone = atoi(buffer);
420 TRACE("setting default deadzone to: %d\n", def_deadzone);
421 }
422 if (appkey) RegCloseKey(appkey);
423 if (hkey) RegCloseKey(hkey);
424
425 /* Create copy of default data format */
426 if (!(df = HeapAlloc(GetProcessHeap(), 0, c_dfDIJoystick2.dwSize))) goto failed;
427 memcpy(df, &c_dfDIJoystick2, c_dfDIJoystick2.dwSize);
428 if (!(df->rgodf = HeapAlloc(GetProcessHeap(), 0, df->dwNumObjs * df->dwObjSize))) goto failed;
429
430 /* Supported Axis & POVs should map 1-to-1 */
431 for (i = 0; i < WINE_JOYSTICK_MAX_AXES; i++)
432 {
433 if (!test_bit(newDevice->joydev->absbits, i)) {
434 newDevice->axes[i] = -1;
435 continue;
436 }
437
438 memcpy(&df->rgodf[idx], &c_dfDIJoystick2.rgodf[i], df->dwObjSize);
439 newDevice->axes[i] = idx;
440 newDevice->props[idx].lDevMin = newDevice->joydev->axes[i].minimum;
441 newDevice->props[idx].lDevMax = newDevice->joydev->axes[i].maximum;
442 newDevice->props[idx].lMin = 0;
443 newDevice->props[idx].lMax = 0xffff;
444 newDevice->props[idx].lSaturation = 0;
445 newDevice->props[idx].lDeadZone = def_deadzone;
446
447 /* Linux supports force-feedback on X & Y axes only */
448 if (newDevice->joydev->has_ff && (i == 0 || i == 1))
449 df->rgodf[idx].dwFlags |= DIDOI_FFACTUATOR;
450
451 df->rgodf[idx++].dwType = DIDFT_MAKEINSTANCE(newDevice->numAxes++) | DIDFT_ABSAXIS;
452 }
453
454 for (i = 0; i < WINE_JOYSTICK_MAX_POVS; i++)
455 {
456 if (!test_bit(newDevice->joydev->absbits, ABS_HAT0X + i * 2) ||
457 !test_bit(newDevice->joydev->absbits, ABS_HAT0Y + i * 2)) {
458 newDevice->axes[ABS_HAT0X + i * 2] = newDevice->axes[ABS_HAT0Y + i * 2] = -1;
459 continue;
460 }
461
462 memcpy(&df->rgodf[idx], &c_dfDIJoystick2.rgodf[i + WINE_JOYSTICK_MAX_AXES], df->dwObjSize);
463 newDevice->axes[ABS_HAT0X + i * 2] = newDevice->axes[ABS_HAT0Y + i * 2] = i;
464 df->rgodf[idx++].dwType = DIDFT_MAKEINSTANCE(newDevice->numPOVs++) | DIDFT_POV;
465 }
466
467 /* Buttons can be anywhere, so check all */
468 for (i = 0; i < KEY_MAX && newDevice->numButtons < WINE_JOYSTICK_MAX_BUTTONS; i++)
469 {
470 if (!test_bit(newDevice->joydev->keybits, i)) continue;
471
472 memcpy(&df->rgodf[idx], &c_dfDIJoystick2.rgodf[newDevice->numButtons + WINE_JOYSTICK_MAX_AXES + WINE_JOYSTICK_MAX_POVS], df->dwObjSize);
473 newDevice->buttons[i] = 0x80 | newDevice->numButtons;
474 df->rgodf[idx ].pguid = &GUID_Button;
475 df->rgodf[idx++].dwType = DIDFT_MAKEINSTANCE(newDevice->numButtons++) | DIDFT_PSHBUTTON;
476 }
477 df->dwNumObjs = idx;
478
479 fake_current_js_state(newDevice);
480
481 newDevice->base.data_format.wine_df = df;
482 IDirectInput_AddRef((LPDIRECTINPUTDEVICE8A)newDevice->base.dinput);
483 return newDevice;
484
485 failed:
486 if (df) HeapFree(GetProcessHeap(), 0, df->rgodf);
487 HeapFree(GetProcessHeap(), 0, df);
488 HeapFree(GetProcessHeap(), 0, newDevice);
489 return NULL;
490 }
491
492 /******************************************************************************
493 * get_joystick_index : Get the joystick index from a given GUID
494 */
495 static unsigned short get_joystick_index(REFGUID guid)
496 {
497 GUID wine_joystick = DInput_Wine_Joystick_Base_GUID;
498 GUID dev_guid = *guid;
499
500 wine_joystick.Data3 = 0;
501 dev_guid.Data3 = 0;
502
503 /* for the standard joystick GUID use index 0 */
504 if(IsEqualGUID(&GUID_Joystick,guid)) return 0;
505
506 /* for the wine joystick GUIDs use the index stored in Data3 */
507 if(IsEqualGUID(&wine_joystick, &dev_guid)) return guid->Data3 - DInput_Wine_Joystick_Base_GUID.Data3;
508
509 return MAX_JOYDEV;
510 }
511
512 static HRESULT joydev_create_deviceA(IDirectInputImpl *dinput, REFGUID rguid, REFIID riid, LPDIRECTINPUTDEVICEA* pdev)
513 {
514 unsigned short index;
515
516 find_joydevs();
517
518 if ((index = get_joystick_index(rguid)) < MAX_JOYDEV &&
519 have_joydevs && index < have_joydevs)
520 {
521 if ((riid == NULL) ||
522 IsEqualGUID(&IID_IDirectInputDeviceA, riid) ||
523 IsEqualGUID(&IID_IDirectInputDevice2A, riid) ||
524 IsEqualGUID(&IID_IDirectInputDevice7A, riid) ||
525 IsEqualGUID(&IID_IDirectInputDevice8A, riid))
526 {
527 *pdev = (IDirectInputDeviceA*) alloc_device(rguid, &JoystickAvt, dinput, index);
528 TRACE("Created a Joystick device (%p)\n", *pdev);
529
530 if (*pdev == NULL)
531 {
532 ERR("out of memory\n");
533 return DIERR_OUTOFMEMORY;
534 }
535 return DI_OK;
536 }
537
538 WARN("no interface\n");
539 return DIERR_NOINTERFACE;
540 }
541
542 return DIERR_DEVICENOTREG;
543 }
544
545
546 static HRESULT joydev_create_deviceW(IDirectInputImpl *dinput, REFGUID rguid, REFIID riid, LPDIRECTINPUTDEVICEW* pdev)
547 {
548 unsigned short index;
549
550 find_joydevs();
551
552 if ((index = get_joystick_index(rguid)) < MAX_JOYDEV &&
553 have_joydevs && index < have_joydevs)
554 {
555 if ((riid == NULL) ||
556 IsEqualGUID(&IID_IDirectInputDeviceW, riid) ||
557 IsEqualGUID(&IID_IDirectInputDevice2W, riid) ||
558 IsEqualGUID(&IID_IDirectInputDevice7W, riid) ||
559 IsEqualGUID(&IID_IDirectInputDevice8W, riid))
560 {
561 *pdev = (IDirectInputDeviceW*) alloc_device(rguid, &JoystickWvt, dinput, index);
562 TRACE("Created a Joystick device (%p)\n", *pdev);
563
564 if (*pdev == NULL)
565 {
566 ERR("out of memory\n");
567 return DIERR_OUTOFMEMORY;
568 }
569 return DI_OK;
570 }
571 WARN("no interface\n");
572 return DIERR_NOINTERFACE;
573 }
574
575 WARN("invalid device GUID\n");
576 return DIERR_DEVICENOTREG;
577 }
578
579 const struct dinput_device joystick_linuxinput_device = {
580 "Wine Linux-input joystick driver",
581 joydev_enum_deviceA,
582 joydev_enum_deviceW,
583 joydev_create_deviceA,
584 joydev_create_deviceW
585 };
586
587 /******************************************************************************
588 * Acquire : gets exclusive control of the joystick
589 */
590 static HRESULT WINAPI JoystickAImpl_Acquire(LPDIRECTINPUTDEVICE8A iface)
591 {
592 JoystickImpl *This = (JoystickImpl *)iface;
593 HRESULT res;
594
595 TRACE("(this=%p)\n",This);
596
597 if ((res = IDirectInputDevice2AImpl_Acquire(iface)) != DI_OK)
598 {
599 WARN("Failed to acquire: %x\n", res);
600 return res;
601 }
602
603 if ((This->joyfd = open(This->joydev->device, O_RDWR)) == -1)
604 {
605 if ((This->joyfd = open(This->joydev->device, O_RDONLY)) == -1)
606 {
607 /* Couldn't open the device at all */
608 ERR("Failed to open device %s: %d %s\n", This->joydev->device, errno, strerror(errno));
609 IDirectInputDevice2AImpl_Unacquire(iface);
610 return DIERR_NOTFOUND;
611 }
612 else
613 {
614 /* Couldn't open in r/w but opened in read-only. */
615 WARN("Could not open %s in read-write mode. Force feedback will be disabled.\n", This->joydev->device);
616 }
617 }
618 else
619 {
620 struct input_event event;
621
622 event.type = EV_FF;
623 event.code = FF_GAIN;
624 event.value = This->ff_gain;
625 if (write(This->joyfd, &event, sizeof(event)) == -1)
626 ERR("Failed to set gain (%i): %d %s\n", This->ff_gain, errno, strerror(errno));
627 if (!This->ff_autocenter)
628 {
629 /* Disable autocenter. */
630 event.code = FF_AUTOCENTER;
631 event.value = 0;
632 if (write(This->joyfd, &event, sizeof(event)) == -1)
633 ERR("Failed disabling autocenter: %d %s\n", errno, strerror(errno));
634 }
635 }
636
637 return DI_OK;
638 }
639
640 /******************************************************************************
641 * Unacquire : frees the joystick
642 */
643 static HRESULT WINAPI JoystickAImpl_Unacquire(LPDIRECTINPUTDEVICE8A iface)
644 {
645 JoystickImpl *This = (JoystickImpl *)iface;
646 HRESULT res;
647
648 TRACE("(this=%p)\n",This);
649 res = IDirectInputDevice2AImpl_Unacquire(iface);
650 if (res==DI_OK && This->joyfd!=-1) {
651 effect_list_item *itr;
652 struct input_event event;
653
654 /* For each known effect:
655 * - stop it
656 * - unload it
657 * But, unlike DISFFC_RESET, do not release the effect.
658 */
659 LIST_FOR_EACH_ENTRY(itr, &This->ff_effects, effect_list_item, entry) {
660 IDirectInputEffect_Stop(itr->ref);
661 IDirectInputEffect_Unload(itr->ref);
662 }
663
664 /* Enable autocenter. */
665 event.type = EV_FF;
666 event.code = FF_AUTOCENTER;
667 /* TODO: Read autocenter strengh before disabling it, and use it here
668 * instead of 0xFFFF (maximum strengh).
669 */
670 event.value = 0xFFFF;
671 if (write(This->joyfd, &event, sizeof(event)) == -1)
672 ERR("Failed to set autocenter to %04x: %d %s\n", event.value, errno, strerror(errno));
673
674 close(This->joyfd);
675 This->joyfd = -1;
676 }
677 return res;
678 }
679
680 /*
681 * set the current state of the js device as it would be with the middle
682 * values on the axes
683 */
684 #define CENTER_AXIS(a) \
685 (ji->axes[a] == -1 ? 0 : joystick_map_axis( &ji->props[ji->axes[a]], \
686 ji->joydev->axes[a].value ))
687 static void fake_current_js_state(JoystickImpl *ji)
688 {
689 int i;
690
691 /* center the axes */
692 ji->js.lX = CENTER_AXIS(ABS_X);
693 ji->js.lY = CENTER_AXIS(ABS_Y);
694 ji->js.lZ = CENTER_AXIS(ABS_Z);
695 ji->js.lRx = CENTER_AXIS(ABS_RX);
696 ji->js.lRy = CENTER_AXIS(ABS_RY);
697 ji->js.lRz = CENTER_AXIS(ABS_RZ);
698 ji->js.rglSlider[0] = CENTER_AXIS(ABS_THROTTLE);
699 ji->js.rglSlider[1] = CENTER_AXIS(ABS_RUDDER);
700
701 /* POV center is -1 */
702 for (i = 0; i < 4; i++)
703 ji->js.rgdwPOV[i] = -1;
704 }
705 #undef CENTER_AXIS
706
707 /* convert wine format offset to user format object index */
708 static void joy_polldev(JoystickImpl *This)
709 {
710 struct pollfd plfd;
711 struct input_event ie;
712
713 if (This->joyfd==-1)
714 return;
715
716 while (1)
717 {
718 LONG value = 0;
719 int inst_id = -1;
720
721 plfd.fd = This->joyfd;
722 plfd.events = POLLIN;
723
724 if (poll(&plfd,1,0) != 1)
725 return;
726
727 /* we have one event, so we can read */
728 if (sizeof(ie)!=read(This->joyfd,&ie,sizeof(ie)))
729 return;
730
731 TRACE("input_event: type %d, code %d, value %d\n",ie.type,ie.code,ie.value);
732 switch (ie.type) {
733 case EV_KEY: /* button */
734 {
735 int btn = This->buttons[ie.code];
736
737 TRACE("(%p) %d -> %d\n", This, ie.code, btn);
738 if (btn & 0x80)
739 {
740 btn &= 0x7F;
741 inst_id = DIDFT_MAKEINSTANCE(btn) | DIDFT_PSHBUTTON;
742 This->js.rgbButtons[btn] = value = ie.value ? 0x80 : 0x00;
743 }
744 break;
745 }
746 case EV_ABS:
747 {
748 int axis = This->axes[ie.code];
749 if (axis==-1) {
750 break;
751 }
752 inst_id = DIDFT_MAKEINSTANCE(axis) | (ie.code < ABS_HAT0X ? DIDFT_ABSAXIS : DIDFT_POV);
753 value = joystick_map_axis(&This->props[id_to_object(This->base.data_format.wine_df, inst_id)], ie.value);
754
755 switch (ie.code) {
756 case ABS_X: This->js.lX = value; break;
757 case ABS_Y: This->js.lY = value; break;
758 case ABS_Z: This->js.lZ = value; break;
759 case ABS_RX: This->js.lRx = value; break;
760 case ABS_RY: This->js.lRy = value; break;
761 case ABS_RZ: This->js.lRz = value; break;
762 case ABS_THROTTLE: This->js.rglSlider[0] = value; break;
763 case ABS_RUDDER: This->js.rglSlider[1] = value; break;
764 case ABS_HAT0X: case ABS_HAT0Y: case ABS_HAT1X: case ABS_HAT1Y:
765 case ABS_HAT2X: case ABS_HAT2Y: case ABS_HAT3X: case ABS_HAT3Y:
766 {
767 int idx = (ie.code - ABS_HAT0X) / 2;
768
769 if (ie.code % 2)
770 This->povs[idx].y = ie.value;
771 else
772 This->povs[idx].x = ie.value;
773
774 This->js.rgdwPOV[idx] = value = joystick_map_pov(&This->povs[idx]);
775 break;
776 }
777 default:
778 FIXME("unhandled joystick axis event (code %d, value %d)\n",ie.code,ie.value);
779 }
780 break;
781 }
782 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
783 case EV_FF_STATUS:
784 This->ff_state = ie.value;
785 break;
786 #endif
787 #ifdef EV_SYN
788 case EV_SYN:
789 /* there is nothing to do */
790 break;
791 #endif
792 default:
793 FIXME("joystick cannot handle type %d event (code %d)\n",ie.type,ie.code);
794 break;
795 }
796 if (inst_id >= 0)
797 queue_event((LPDIRECTINPUTDEVICE8A)This,
798 id_to_offset(&This->base.data_format, inst_id),
799 value, ie.time.tv_usec, This->base.dinput->evsequence++);
800 }
801 }
802
803 /******************************************************************************
804 * GetDeviceState : returns the "state" of the joystick.
805 *
806 */
807 static HRESULT WINAPI JoystickAImpl_GetDeviceState(
808 LPDIRECTINPUTDEVICE8A iface,DWORD len,LPVOID ptr
809 ) {
810 JoystickImpl *This = (JoystickImpl *)iface;
811
812 TRACE("(this=%p,0x%08x,%p)\n", This, len, ptr);
813
814 if (!This->base.acquired)
815 {
816 WARN("not acquired\n");
817 return DIERR_NOTACQUIRED;
818 }
819
820 joy_polldev(This);
821
822 /* convert and copy data to user supplied buffer */
823 fill_DataFormat(ptr, len, &This->js, &This->base.data_format);
824
825 return DI_OK;
826 }
827
828 /******************************************************************************
829 * SetProperty : change input device properties
830 */
831 static HRESULT WINAPI JoystickAImpl_SetProperty(LPDIRECTINPUTDEVICE8A iface,
832 REFGUID rguid,
833 LPCDIPROPHEADER ph)
834 {
835 JoystickImpl *This = (JoystickImpl *)iface;
836
837 if (!ph) {
838 WARN("invalid argument\n");
839 return DIERR_INVALIDPARAM;
840 }
841
842 TRACE("(this=%p,%s,%p)\n",This,debugstr_guid(rguid),ph);
843 TRACE("ph.dwSize = %d, ph.dwHeaderSize =%d, ph.dwObj = %d, ph.dwHow= %d\n",
844 ph->dwSize, ph->dwHeaderSize, ph->dwObj, ph->dwHow);
845
846 if (!HIWORD(rguid)) {
847 switch (LOWORD(rguid)) {
848 case (DWORD_PTR)DIPROP_RANGE: {
849 LPCDIPROPRANGE pr = (LPCDIPROPRANGE)ph;
850
851 if (ph->dwHow == DIPH_DEVICE) {
852 DWORD i;
853 TRACE("proprange(%d,%d) all\n", pr->lMin, pr->lMax);
854 for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++) {
855 /* Scale dead-zone */
856 This->props[i].lDeadZone = MulDiv(This->props[i].lDeadZone, pr->lMax - pr->lMin,
857 This->props[i].lMax - This->props[i].lMin);
858 This->props[i].lMin = pr->lMin;
859 This->props[i].lMax = pr->lMax;
860 }
861 } else {
862 int obj = find_property(&This->base.data_format, ph);
863
864 TRACE("proprange(%d,%d) obj=%d\n", pr->lMin, pr->lMax, obj);
865 if (obj >= 0) {
866 /* Scale dead-zone */
867 This->props[obj].lDeadZone = MulDiv(This->props[obj].lDeadZone, pr->lMax - pr->lMin,
868 This->props[obj].lMax - This->props[obj].lMin);
869 This->props[obj].lMin = pr->lMin;
870 This->props[obj].lMax = pr->lMax;
871 }
872 }
873 fake_current_js_state(This);
874 break;
875 }
876 case (DWORD_PTR)DIPROP_DEADZONE: {
877 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
878 if (ph->dwHow == DIPH_DEVICE) {
879 DWORD i;
880 TRACE("deadzone(%d) all\n", pd->dwData);
881 for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++) {
882 This->props[i].lDeadZone = pd->dwData;
883 }
884 } else {
885 int obj = find_property(&This->base.data_format, ph);
886
887 TRACE("deadzone(%d) obj=%d\n", pd->dwData, obj);
888 if (obj >= 0) {
889 This->props[obj].lDeadZone = pd->dwData;
890 }
891 }
892 fake_current_js_state(This);
893 break;
894 }
895 case (DWORD_PTR)DIPROP_CALIBRATIONMODE: {
896 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
897 FIXME("DIPROP_CALIBRATIONMODE(%d)\n", pd->dwData);
898 break;
899 }
900 case (DWORD_PTR)DIPROP_AUTOCENTER: {
901 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
902
903 TRACE("autocenter(%d)\n", pd->dwData);
904 This->ff_autocenter = pd->dwData == DIPROPAUTOCENTER_ON;
905
906 break;
907 }
908 case (DWORD_PTR)DIPROP_SATURATION: {
909 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
910
911 if (ph->dwHow == DIPH_DEVICE) {
912 DWORD i;
913
914 TRACE("saturation(%d) all\n", pd->dwData);
915 for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++)
916 This->props[i].lSaturation = pd->dwData;
917 } else {
918 int obj = find_property(&This->base.data_format, ph);
919
920 if (obj < 0) return DIERR_OBJECTNOTFOUND;
921
922 TRACE("saturation(%d) obj=%d\n", pd->dwData, obj);
923 This->props[obj].lSaturation = pd->dwData;
924 }
925 fake_current_js_state(This);
926 break;
927 }
928 case (DWORD_PTR)DIPROP_FFGAIN: {
929 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
930
931 TRACE("DIPROP_FFGAIN(%d)\n", pd->dwData);
932 This->ff_gain = MulDiv(pd->dwData, 0xFFFF, 10000);
933 if (This->base.acquired) {
934 /* Update immediately. */
935 struct input_event event;
936
937 event.type = EV_FF;
938 event.code = FF_GAIN;
939 event.value = This->ff_gain;
940 if (write(This->joyfd, &event, sizeof(event)) == -1)
941 ERR("Failed to set gain (%i): %d %s\n", This->ff_gain, errno, strerror(errno));
942 }
943 break;
944 }
945 default:
946 return IDirectInputDevice2AImpl_SetProperty(iface, rguid, ph);
947 }
948 }
949 return DI_OK;
950 }
951
952 static HRESULT WINAPI JoystickAImpl_GetCapabilities(
953 LPDIRECTINPUTDEVICE8A iface,
954 LPDIDEVCAPS lpDIDevCaps)
955 {
956 JoystickImpl *This = (JoystickImpl *)iface;
957
958 TRACE("%p->(%p)\n",iface,lpDIDevCaps);
959
960 if (!lpDIDevCaps) {
961 WARN("invalid pointer\n");
962 return E_POINTER;
963 }
964
965 if (lpDIDevCaps->dwSize != sizeof(DIDEVCAPS)) {
966 WARN("invalid argument\n");
967 return DIERR_INVALIDPARAM;
968 }
969
970 lpDIDevCaps->dwFlags = DIDC_ATTACHED;
971 if (This->base.dinput->dwVersion >= 0x0800)
972 lpDIDevCaps->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
973 else
974 lpDIDevCaps->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
975
976 if (This->joydev->has_ff)
977 lpDIDevCaps->dwFlags |= DIDC_FORCEFEEDBACK;
978
979 lpDIDevCaps->dwAxes = This->numAxes;
980 lpDIDevCaps->dwButtons = This->numButtons;
981 lpDIDevCaps->dwPOVs = This->numPOVs;
982
983 return DI_OK;
984 }
985
986 static HRESULT WINAPI JoystickAImpl_Poll(LPDIRECTINPUTDEVICE8A iface)
987 {
988 JoystickImpl *This = (JoystickImpl *)iface;
989
990 TRACE("(%p)\n",This);
991
992 if (!This->base.acquired)
993 return DIERR_NOTACQUIRED;
994
995 joy_polldev(This);
996 return DI_OK;
997 }
998
999 /******************************************************************************
1000 * GetProperty : get input device properties
1001 */
1002 static HRESULT WINAPI JoystickAImpl_GetProperty(LPDIRECTINPUTDEVICE8A iface,
1003 REFGUID rguid,
1004 LPDIPROPHEADER pdiph)
1005 {
1006 JoystickImpl *This = (JoystickImpl *)iface;
1007
1008 TRACE("(this=%p,%s,%p)\n", iface, debugstr_guid(rguid), pdiph);
1009 _dump_DIPROPHEADER(pdiph);
1010
1011 if (HIWORD(rguid)) return DI_OK;
1012
1013 switch (LOWORD(rguid)) {
1014 case (DWORD_PTR) DIPROP_RANGE:
1015 {
1016 LPDIPROPRANGE pr = (LPDIPROPRANGE) pdiph;
1017 int obj = find_property(&This->base.data_format, pdiph);
1018
1019 if (obj < 0) return DIERR_OBJECTNOTFOUND;
1020
1021 pr->lMin = This->props[obj].lMin;
1022 pr->lMax = This->props[obj].lMax;
1023 TRACE("range(%d, %d) obj=%d\n", pr->lMin, pr->lMax, obj);
1024 break;
1025 }
1026 case (DWORD_PTR) DIPROP_DEADZONE:
1027 {
1028 LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
1029 int obj = find_property(&This->base.data_format, pdiph);
1030
1031 if (obj < 0) return DIERR_OBJECTNOTFOUND;
1032
1033 pd->dwData = This->props[obj].lDeadZone;
1034 TRACE("deadzone(%d) obj=%d\n", pd->dwData, obj);
1035 break;
1036 }
1037 case (DWORD_PTR) DIPROP_SATURATION:
1038 {
1039 LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
1040 int obj = find_property(&This->base.data_format, pdiph);
1041
1042 if (obj < 0) return DIERR_OBJECTNOTFOUND;
1043
1044 pd->dwData = This->props[obj].lSaturation;
1045 TRACE("saturation(%d) obj=%d\n", pd->dwData, obj);
1046 break;
1047 }
1048 case (DWORD_PTR) DIPROP_AUTOCENTER:
1049 {
1050 LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
1051
1052 pd->dwData = This->ff_autocenter ? DIPROPAUTOCENTER_ON : DIPROPAUTOCENTER_OFF;
1053 TRACE("autocenter(%d)\n", pd->dwData);
1054 break;
1055 }
1056 case (DWORD_PTR) DIPROP_FFGAIN:
1057 {
1058 LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
1059
1060 pd->dwData = MulDiv(This->ff_gain, 10000, 0xFFFF);
1061 TRACE("DIPROP_FFGAIN(%d)\n", pd->dwData);
1062 break;
1063 }
1064
1065 default:
1066 return IDirectInputDevice2AImpl_GetProperty(iface, rguid, pdiph);
1067 }
1068
1069 return DI_OK;
1070 }
1071
1072 /******************************************************************************
1073 * CreateEffect - Create a new FF effect with the specified params
1074 */
1075 static HRESULT WINAPI JoystickAImpl_CreateEffect(LPDIRECTINPUTDEVICE8A iface,
1076 REFGUID rguid,
1077 LPCDIEFFECT lpeff,
1078 LPDIRECTINPUTEFFECT *ppdef,
1079 LPUNKNOWN pUnkOuter)
1080 {
1081 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1082 effect_list_item* new_effect = NULL;
1083 HRESULT retval = DI_OK;
1084 #endif
1085
1086 JoystickImpl* This = (JoystickImpl*)iface;
1087 TRACE("(this=%p,%p,%p,%p,%p)\n", This, rguid, lpeff, ppdef, pUnkOuter);
1088
1089 #ifndef HAVE_STRUCT_FF_EFFECT_DIRECTION
1090 TRACE("not available (compiled w/o ff support)\n");
1091 *ppdef = NULL;
1092 return DI_OK;
1093 #else
1094
1095 if (!(new_effect = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_effect))))
1096 return DIERR_OUTOFMEMORY;
1097
1098 retval = linuxinput_create_effect(&This->joyfd, rguid, &new_effect->entry, &new_effect->ref);
1099 if (retval != DI_OK)
1100 {
1101 HeapFree(GetProcessHeap(), 0, new_effect);
1102 return retval;
1103 }
1104
1105 if (lpeff != NULL)
1106 {
1107 retval = IDirectInputEffect_SetParameters(new_effect->ref, lpeff, 0);
1108
1109 if (retval != DI_OK && retval != DI_DOWNLOADSKIPPED)
1110 {
1111 HeapFree(GetProcessHeap(), 0, new_effect);
1112 return retval;
1113 }
1114 }
1115
1116 list_add_tail(&This->ff_effects, &new_effect->entry);
1117 *ppdef = new_effect->ref;
1118
1119 if (pUnkOuter != NULL)
1120 FIXME("Interface aggregation not implemented.\n");
1121
1122 return DI_OK;
1123
1124 #endif /* HAVE_STRUCT_FF_EFFECT_DIRECTION */
1125 }
1126
1127 /*******************************************************************************
1128 * EnumEffects - Enumerate available FF effects
1129 */
1130 static HRESULT WINAPI JoystickAImpl_EnumEffects(LPDIRECTINPUTDEVICE8A iface,
1131 LPDIENUMEFFECTSCALLBACKA lpCallback,
1132 LPVOID pvRef,
1133 DWORD dwEffType)
1134 {
1135 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1136 DIEFFECTINFOA dei; /* feif */
1137 DWORD type = DIEFT_GETTYPE(dwEffType);
1138 JoystickImpl* This = (JoystickImpl*)iface;
1139
1140 TRACE("(this=%p,%p,%d) type=%d\n", This, pvRef, dwEffType, type);
1141
1142 dei.dwSize = sizeof(DIEFFECTINFOA);
1143
1144 if ((type == DIEFT_ALL || type == DIEFT_CONSTANTFORCE)
1145 && test_bit(This->joydev->ffbits, FF_CONSTANT)) {
1146 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_ConstantForce);
1147 (*lpCallback)(&dei, pvRef);
1148 }
1149
1150 if ((type == DIEFT_ALL || type == DIEFT_PERIODIC)
1151 && test_bit(This->joydev->ffbits, FF_PERIODIC)) {
1152 if (test_bit(This->joydev->ffbits, FF_SQUARE)) {
1153 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Square);
1154 (*lpCallback)(&dei, pvRef);
1155 }
1156 if (test_bit(This->joydev->ffbits, FF_SINE)) {
1157 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Sine);
1158 (*lpCallback)(&dei, pvRef);
1159 }
1160 if (test_bit(This->joydev->ffbits, FF_TRIANGLE)) {
1161 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Triangle);
1162 (*lpCallback)(&dei, pvRef);
1163 }
1164 if (test_bit(This->joydev->ffbits, FF_SAW_UP)) {
1165 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_SawtoothUp);
1166 (*lpCallback)(&dei, pvRef);
1167 }
1168 if (test_bit(This->joydev->ffbits, FF_SAW_DOWN)) {
1169 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_SawtoothDown);
1170 (*lpCallback)(&dei, pvRef);
1171 }
1172 }
1173
1174 if ((type == DIEFT_ALL || type == DIEFT_RAMPFORCE)
1175 && test_bit(This->joydev->ffbits, FF_RAMP)) {
1176 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_RampForce);
1177 (*lpCallback)(&dei, pvRef);
1178 }
1179
1180 if (type == DIEFT_ALL || type == DIEFT_CONDITION) {
1181 if (test_bit(This->joydev->ffbits, FF_SPRING)) {
1182 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Spring);
1183 (*lpCallback)(&dei, pvRef);
1184 }
1185 if (test_bit(This->joydev->ffbits, FF_DAMPER)) {
1186 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Damper);
1187 (*lpCallback)(&dei, pvRef);
1188 }
1189 if (test_bit(This->joydev->ffbits, FF_INERTIA)) {
1190 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Inertia);
1191 (*lpCallback)(&dei, pvRef);
1192 }
1193 if (test_bit(This->joydev->ffbits, FF_FRICTION)) {
1194 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Friction);
1195 (*lpCallback)(&dei, pvRef);
1196 }
1197 }
1198
1199 #endif
1200
1201 return DI_OK;
1202 }
1203
1204 static HRESULT WINAPI JoystickWImpl_EnumEffects(LPDIRECTINPUTDEVICE8W iface,
1205 LPDIENUMEFFECTSCALLBACKW lpCallback,
1206 LPVOID pvRef,
1207 DWORD dwEffType)
1208 {
1209 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1210 /* seems silly to duplicate all this code but all the structures and functions
1211 * are actually different (A/W) */
1212 DIEFFECTINFOW dei; /* feif */
1213 DWORD type = DIEFT_GETTYPE(dwEffType);
1214 JoystickImpl* This = (JoystickImpl*)iface;
1215 int xfd = This->joyfd;
1216
1217 TRACE("(this=%p,%p,%d) type=%d fd=%d\n", This, pvRef, dwEffType, type, xfd);
1218
1219 dei.dwSize = sizeof(DIEFFECTINFOW);
1220
1221 if ((type == DIEFT_ALL || type == DIEFT_CONSTANTFORCE)
1222 && test_bit(This->joydev->ffbits, FF_CONSTANT)) {
1223 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_ConstantForce);
1224 (*lpCallback)(&dei, pvRef);
1225 }
1226
1227 if ((type == DIEFT_ALL || type == DIEFT_PERIODIC)
1228 && test_bit(This->joydev->ffbits, FF_PERIODIC)) {
1229 if (test_bit(This->joydev->ffbits, FF_SQUARE)) {
1230 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Square);
1231 (*lpCallback)(&dei, pvRef);
1232 }
1233 if (test_bit(This->joydev->ffbits, FF_SINE)) {
1234 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Sine);
1235 (*lpCallback)(&dei, pvRef);
1236 }
1237 if (test_bit(This->joydev->ffbits, FF_TRIANGLE)) {
1238 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Triangle);
1239 (*lpCallback)(&dei, pvRef);
1240 }
1241 if (test_bit(This->joydev->ffbits, FF_SAW_UP)) {
1242 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_SawtoothUp);
1243 (*lpCallback)(&dei, pvRef);
1244 }
1245 if (test_bit(This->joydev->ffbits, FF_SAW_DOWN)) {
1246 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_SawtoothDown);
1247 (*lpCallback)(&dei, pvRef);
1248 }
1249 }
1250
1251 if ((type == DIEFT_ALL || type == DIEFT_RAMPFORCE)
1252 && test_bit(This->joydev->ffbits, FF_RAMP)) {
1253 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_RampForce);
1254 (*lpCallback)(&dei, pvRef);
1255 }
1256
1257 if (type == DIEFT_ALL || type == DIEFT_CONDITION) {
1258 if (test_bit(This->joydev->ffbits, FF_SPRING)) {
1259 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Spring);
1260 (*lpCallback)(&dei, pvRef);
1261 }
1262 if (test_bit(This->joydev->ffbits, FF_DAMPER)) {
1263 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Damper);
1264 (*lpCallback)(&dei, pvRef);
1265 }
1266 if (test_bit(This->joydev->ffbits, FF_INERTIA)) {
1267 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Inertia);
1268 (*lpCallback)(&dei, pvRef);
1269 }
1270 if (test_bit(This->joydev->ffbits, FF_FRICTION)) {
1271 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Friction);
1272 (*lpCallback)(&dei, pvRef);
1273 }
1274 }
1275
1276 /* return to unacquired state if that's where it was */
1277 if (xfd == -1)
1278 IDirectInputDevice8_Unacquire(iface);
1279 #endif
1280
1281 return DI_OK;
1282 }
1283
1284 /*******************************************************************************
1285 * GetEffectInfo - Get information about a particular effect
1286 */
1287 static HRESULT WINAPI JoystickAImpl_GetEffectInfo(LPDIRECTINPUTDEVICE8A iface,
1288 LPDIEFFECTINFOA pdei,
1289 REFGUID guid)
1290 {
1291 JoystickImpl* This = (JoystickImpl*)iface;
1292
1293 TRACE("(this=%p,%p,%s)\n", This, pdei, _dump_dinput_GUID(guid));
1294
1295 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1296 return linuxinput_get_info_A(This->joyfd, guid, pdei);
1297 #else
1298 return DI_OK;
1299 #endif
1300 }
1301
1302 static HRESULT WINAPI JoystickWImpl_GetEffectInfo(LPDIRECTINPUTDEVICE8W iface,
1303 LPDIEFFECTINFOW pdei,
1304 REFGUID guid)
1305 {
1306 JoystickImpl* This = (JoystickImpl*)iface;
1307
1308 TRACE("(this=%p,%p,%s)\n", This, pdei, _dump_dinput_GUID(guid));
1309
1310 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1311 return linuxinput_get_info_W(This->joyfd, guid, pdei);
1312 #else
1313 return DI_OK;
1314 #endif
1315 }
1316
1317 /*******************************************************************************
1318 * GetForceFeedbackState - Get information about the device's FF state
1319 */
1320 static HRESULT WINAPI JoystickAImpl_GetForceFeedbackState(
1321 LPDIRECTINPUTDEVICE8A iface,
1322 LPDWORD pdwOut)
1323 {
1324 JoystickImpl* This = (JoystickImpl*)iface;
1325
1326 TRACE("(this=%p,%p)\n", This, pdwOut);
1327
1328 (*pdwOut) = 0;
1329
1330 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1331 /* DIGFFS_STOPPED is the only mandatory flag to report */
1332 if (This->ff_state == FF_STATUS_STOPPED)
1333 (*pdwOut) |= DIGFFS_STOPPED;
1334 #endif
1335
1336 return DI_OK;
1337 }
1338
1339 /*******************************************************************************
1340 * SendForceFeedbackCommand - Send a command to the device's FF system
1341 */
1342 static HRESULT WINAPI JoystickAImpl_SendForceFeedbackCommand(
1343 LPDIRECTINPUTDEVICE8A iface,
1344 DWORD dwFlags)
1345 {
1346 JoystickImpl* This = (JoystickImpl*)iface;
1347 TRACE("(this=%p,%d)\n", This, dwFlags);
1348
1349 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1350 switch (dwFlags)
1351 {
1352 case DISFFC_STOPALL:
1353 {
1354 /* Stop all effects */
1355 effect_list_item *itr;
1356
1357 LIST_FOR_EACH_ENTRY(itr, &This->ff_effects, effect_list_item, entry)
1358 IDirectInputEffect_Stop(itr->ref);
1359 break;
1360 }
1361
1362 case DISFFC_RESET:
1363 {
1364 effect_list_item *itr, *ptr;
1365
1366 /* Stop, unload, release and free all effects */
1367 /* This returns the device to its "bare" state */
1368 LIST_FOR_EACH_ENTRY_SAFE(itr, ptr, &This->ff_effects, effect_list_item, entry)
1369 IDirectInputEffect_Release(itr->ref);
1370 break;
1371 }
1372 case DISFFC_PAUSE:
1373 case DISFFC_CONTINUE:
1374 FIXME("No support for Pause or Continue in linux\n");
1375 break;
1376
1377 case DISFFC_SETACTUATORSOFF:
1378 case DISFFC_SETACTUATORSON:
1379 FIXME("No direct actuator control in linux\n");
1380 break;
1381
1382 default:
1383 FIXME("Unknown Force Feedback Command!\n");
1384 return DIERR_INVALIDPARAM;
1385 }
1386 return DI_OK;
1387 #else
1388 return DIERR_UNSUPPORTED;
1389 #endif
1390 }
1391
1392 /*******************************************************************************
1393 * EnumCreatedEffectObjects - Enumerate all the effects that have been
1394 * created for this device.
1395 */
1396 static HRESULT WINAPI JoystickAImpl_EnumCreatedEffectObjects(
1397 LPDIRECTINPUTDEVICE8A iface,
1398 LPDIENUMCREATEDEFFECTOBJECTSCALLBACK lpCallback,
1399 LPVOID pvRef,
1400 DWORD dwFlags)
1401 {
1402 /* this function is safe to call on non-ff-enabled builds */
1403 JoystickImpl* This = (JoystickImpl*)iface;
1404 effect_list_item *itr, *ptr;
1405
1406 TRACE("(this=%p,%p,%p,%d)\n", This, lpCallback, pvRef, dwFlags);
1407
1408 if (!lpCallback)
1409 return DIERR_INVALIDPARAM;
1410
1411 if (dwFlags != 0)
1412 FIXME("Flags specified, but no flags exist yet (DX9)!\n");
1413
1414 LIST_FOR_EACH_ENTRY_SAFE(itr, ptr, &This->ff_effects, effect_list_item, entry)
1415 (*lpCallback)(itr->ref, pvRef);
1416
1417 return DI_OK;
1418 }
1419
1420 /******************************************************************************
1421 * GetDeviceInfo : get information about a device's identity
1422 */
1423 static HRESULT WINAPI JoystickAImpl_GetDeviceInfo(LPDIRECTINPUTDEVICE8A iface,
1424 LPDIDEVICEINSTANCEA pdidi)
1425 {
1426 JoystickImpl *This = (JoystickImpl *)iface;
1427
1428 TRACE("(%p) %p\n", This, pdidi);
1429
1430 if (pdidi == NULL) return E_POINTER;
1431 if ((pdidi->dwSize != sizeof(DIDEVICEINSTANCE_DX3A)) &&
1432 (pdidi->dwSize != sizeof(DIDEVICEINSTANCEA)))
1433 return DIERR_INVALIDPARAM;
1434
1435 fill_joystick_dideviceinstanceA(pdidi, This->base.dinput->dwVersion,
1436 get_joystick_index(&This->base.guid));
1437 return DI_OK;
1438 }
1439
1440 static HRESULT WINAPI JoystickWImpl_GetDeviceInfo(LPDIRECTINPUTDEVICE8W iface,
1441 LPDIDEVICEINSTANCEW pdidi)
1442 {
1443 JoystickImpl *This = (JoystickImpl *)iface;
1444
1445 TRACE("(%p) %p\n", This, pdidi);
1446
1447 if (pdidi == NULL) return E_POINTER;
1448 if ((pdidi->dwSize != sizeof(DIDEVICEINSTANCE_DX3W)) &&
1449 (pdidi->dwSize != sizeof(DIDEVICEINSTANCEW)))
1450 return DIERR_INVALIDPARAM;
1451
1452 fill_joystick_dideviceinstanceW(pdidi, This->base.dinput->dwVersion,
1453 get_joystick_index(&This->base.guid));
1454 return DI_OK;
1455 }
1456
1457 static const IDirectInputDevice8AVtbl JoystickAvt =
1458 {
1459 IDirectInputDevice2AImpl_QueryInterface,
1460 IDirectInputDevice2AImpl_AddRef,
1461 IDirectInputDevice2AImpl_Release,
1462 JoystickAImpl_GetCapabilities,
1463 IDirectInputDevice2AImpl_EnumObjects,
1464 JoystickAImpl_GetProperty,
1465 JoystickAImpl_SetProperty,
1466 JoystickAImpl_Acquire,
1467 JoystickAImpl_Unacquire,
1468 JoystickAImpl_GetDeviceState,
1469 IDirectInputDevice2AImpl_GetDeviceData,
1470 IDirectInputDevice2AImpl_SetDataFormat,
1471 IDirectInputDevice2AImpl_SetEventNotification,
1472 IDirectInputDevice2AImpl_SetCooperativeLevel,
1473 JoystickAGenericImpl_GetObjectInfo,
1474 JoystickAImpl_GetDeviceInfo,
1475 IDirectInputDevice2AImpl_RunControlPanel,
1476 IDirectInputDevice2AImpl_Initialize,
1477 JoystickAImpl_CreateEffect,
1478 JoystickAImpl_EnumEffects,
1479 JoystickAImpl_GetEffectInfo,
1480 JoystickAImpl_GetForceFeedbackState,
1481 JoystickAImpl_SendForceFeedbackCommand,
1482 JoystickAImpl_EnumCreatedEffectObjects,
1483 IDirectInputDevice2AImpl_Escape,
1484 JoystickAImpl_Poll,
1485 IDirectInputDevice2AImpl_SendDeviceData,
1486 IDirectInputDevice7AImpl_EnumEffectsInFile,
1487 IDirectInputDevice7AImpl_WriteEffectToFile,
1488 IDirectInputDevice8AImpl_BuildActionMap,
1489 IDirectInputDevice8AImpl_SetActionMap,
1490 IDirectInputDevice8AImpl_GetImageInfo
1491 };
1492
1493 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
1494 # define XCAST(fun) (typeof(JoystickWvt.fun))
1495 #else
1496 # define XCAST(fun) (void*)
1497 #endif
1498
1499 static const IDirectInputDevice8WVtbl JoystickWvt =
1500 {
1501 IDirectInputDevice2WImpl_QueryInterface,
1502 XCAST(AddRef)IDirectInputDevice2AImpl_AddRef,
1503 XCAST(Release)IDirectInputDevice2AImpl_Release,
1504 XCAST(GetCapabilities)JoystickAImpl_GetCapabilities,
1505 IDirectInputDevice2WImpl_EnumObjects,
1506 XCAST(GetProperty)JoystickAImpl_GetProperty,
1507 XCAST(SetProperty)JoystickAImpl_SetProperty,
1508 XCAST(Acquire)JoystickAImpl_Acquire,
1509 XCAST(Unacquire)JoystickAImpl_Unacquire,
1510 XCAST(GetDeviceState)JoystickAImpl_GetDeviceState,
1511 XCAST(GetDeviceData)IDirectInputDevice2AImpl_GetDeviceData,
1512 XCAST(SetDataFormat)IDirectInputDevice2AImpl_SetDataFormat,
1513 XCAST(SetEventNotification)IDirectInputDevice2AImpl_SetEventNotification,
1514 XCAST(SetCooperativeLevel)IDirectInputDevice2AImpl_SetCooperativeLevel,
1515 JoystickWGenericImpl_GetObjectInfo,
1516 JoystickWImpl_GetDeviceInfo,
1517 XCAST(RunControlPanel)IDirectInputDevice2AImpl_RunControlPanel,
1518 XCAST(Initialize)IDirectInputDevice2AImpl_Initialize,
1519 XCAST(CreateEffect)JoystickAImpl_CreateEffect,
1520 JoystickWImpl_EnumEffects,
1521 JoystickWImpl_GetEffectInfo,
1522 XCAST(GetForceFeedbackState)JoystickAImpl_GetForceFeedbackState,
1523 XCAST(SendForceFeedbackCommand)JoystickAImpl_SendForceFeedbackCommand,
1524 XCAST(EnumCreatedEffectObjects)JoystickAImpl_EnumCreatedEffectObjects,
1525 XCAST(Escape)IDirectInputDevice2AImpl_Escape,
1526 XCAST(Poll)JoystickAImpl_Poll,
1527 XCAST(SendDeviceData)IDirectInputDevice2AImpl_SendDeviceData,
1528 IDirectInputDevice7WImpl_EnumEffectsInFile,
1529 IDirectInputDevice7WImpl_WriteEffectToFile,
1530 IDirectInputDevice8WImpl_BuildActionMap,
1531 IDirectInputDevice8WImpl_SetActionMap,
1532 IDirectInputDevice8WImpl_GetImageInfo
1533 };
1534 #undef XCAST
1535
1536 #else /* HAVE_CORRECT_LINUXINPUT_H */
1537
1538 const struct dinput_device joystick_linuxinput_device = {
1539 "Wine Linux-input joystick driver",
1540 NULL,
1541 NULL,
1542 NULL,
1543 NULL
1544 };
1545
1546 #endif /* HAVE_CORRECT_LINUXINPUT_H */
useful hacks and other patches not (yet) suitable for mainline