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