winmm/tests: Don't use same buffer for both input and output.
[wine] / dlls / winejoystick.drv / joystick.c
1 /*
2  * joystick functions
3  *
4  * Copyright 1997 Andreas Mohr
5  * Copyright 2000 Wolfgang Schwotzer
6  * Copyright 2002 David Hagood
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  * NOTES:
23  *
24  * - nearly all joystick functions can be regarded as obsolete,
25  *   as Linux (2.1.x) now supports extended joysticks with a completely 
26  *   new joystick driver interface
27  *   New driver's documentation says:
28  *     "For backward compatibility the old interface is still included,
29  *     but will be dropped in the future."
30  *   Thus we should implement the new interface and at most keep the old
31  *   routines for backward compatibility.
32  * - better support of enhanced joysticks (Linux 2.2 interface is available)
33  * - support more joystick drivers (like the XInput extension)
34  * - should load joystick DLL as any other driver (instead of hardcoding)
35  *   the driver's name, and load it as any low lever driver.
36  */
37
38 #include "config.h"
39 #include "wine/port.h"
40
41 #ifdef HAVE_UNISTD_H
42 # include <unistd.h>
43 #endif
44 #include <stdarg.h>
45 #include <stdio.h>
46 #include <stdlib.h>
47 #include <string.h>
48 #include <fcntl.h>
49 #ifdef HAVE_SYS_IOCTL_H
50 #include <sys/ioctl.h>
51 #endif
52 #ifdef HAVE_LINUX_IOCTL_H
53 #include <linux/ioctl.h>
54 #endif
55 #ifdef HAVE_LINUX_JOYSTICK_H
56 #include <linux/joystick.h>
57 #ifdef SW_MAX
58 #undef SW_MAX
59 #endif
60 #define JOYDEV_NEW "/dev/input/js%d"
61 #define JOYDEV_OLD "/dev/js%d"
62 #endif
63 #ifdef HAVE_SYS_ERRNO_H
64 #include <sys/errno.h>
65 #endif
66
67 #include "windef.h"
68 #include "winbase.h"
69 #include "wingdi.h"
70 #include "winuser.h"
71 #include "winnls.h"
72 #include "mmddk.h"
73 #include "wine/debug.h"
74
75 #include "wine/unicode.h"
76
77 WINE_DEFAULT_DEBUG_CHANNEL(joystick);
78
79 #ifdef HAVE_LINUX_JOYSTICK_H
80
81 #define MAXJOYSTICK (JOYSTICKID2 + 30)
82
83 typedef struct tagWINE_JSTCK {
84     int         joyIntf;
85     int         in_use;
86     /* Some extra info we need to make this actually work under the
87        Linux 2.2 event api.
88        First of all, we cannot keep closing and reopening the device file -
89        that blows away the state of the stick device, and we lose events. So, we
90        need to open the low-level device once, and close it when we are done.
91
92        Secondly, the event API only gives us what's changed. However, Windows apps
93        want the whole state every time, so we have to cache the data.
94     */
95
96     int         dev; /* Linux level device file descriptor */
97     int         x;
98     int         y;
99     int         z;
100     int         r;
101     int         u;
102     int         v;
103     int         pov_x;
104     int         pov_y;
105     int         buttons;
106     char        axesMap[ABS_MAX + 1];
107 } WINE_JSTCK;
108
109 static  WINE_JSTCK      JSTCK_Data[MAXJOYSTICK];
110
111 /**************************************************************************
112  *                              JSTCK_drvGet                    [internal]
113  */
114 static WINE_JSTCK *JSTCK_drvGet(DWORD_PTR dwDevID)
115 {
116     int p;
117
118     if ((dwDevID - (DWORD_PTR)JSTCK_Data) % sizeof(JSTCK_Data[0]) != 0)
119         return NULL;
120     p = (dwDevID - (DWORD_PTR)JSTCK_Data) / sizeof(JSTCK_Data[0]);
121     if (p < 0 || p >= MAXJOYSTICK || !((WINE_JSTCK*)dwDevID)->in_use)
122         return NULL;
123
124     return (WINE_JSTCK*)dwDevID;
125 }
126
127 /**************************************************************************
128  *                              JSTCK_drvOpen                   [internal]
129  */
130 static LRESULT JSTCK_drvOpen(LPSTR str, DWORD dwIntf)
131 {
132     if (dwIntf >= MAXJOYSTICK || JSTCK_Data[dwIntf].in_use)
133         return 0;
134
135     JSTCK_Data[dwIntf].joyIntf = dwIntf;
136     JSTCK_Data[dwIntf].in_use = 1;
137     return (LRESULT)&JSTCK_Data[dwIntf];
138 }
139
140 /**************************************************************************
141  *                              JSTCK_drvClose                  [internal]
142  */
143 static LRESULT JSTCK_drvClose(DWORD_PTR dwDevID)
144 {
145     WINE_JSTCK* jstck = JSTCK_drvGet(dwDevID);
146
147     if (jstck == NULL)
148         return 0;
149     jstck->in_use = 0;
150     if (jstck->dev > 0)
151     {
152        close(jstck->dev);
153        jstck->dev = 0;
154     }
155     return 1;
156 }
157
158 struct js_status
159 {
160     int buttons;
161     int x;
162     int y;
163 };
164
165 /**************************************************************************
166  *                              JSTCK_OpenDevice           [internal]
167  */
168 static  int     JSTCK_OpenDevice(WINE_JSTCK* jstick)
169 {
170     char        buf[20];
171     int         flags;
172
173     if (jstick->dev > 0)
174       return jstick->dev;
175
176     sprintf(buf, JOYDEV_NEW, jstick->joyIntf);
177 #ifdef HAVE_LINUX_22_JOYSTICK_API
178     flags = O_RDONLY | O_NONBLOCK;
179 #else
180     flags = O_RDONLY;
181 #endif
182     if ((jstick->dev = open(buf, flags)) < 0) {
183         sprintf(buf, JOYDEV_OLD, jstick->joyIntf);
184         if ((jstick->dev = open(buf, flags)) < 0)
185             return jstick->dev;
186     }
187 #ifdef HAVE_LINUX_22_JOYSTICK_API
188     ioctl(jstick->dev, JSIOCGAXMAP, jstick->axesMap);
189 #endif
190     return jstick->dev;
191 }
192
193
194 /**************************************************************************
195  *                              JoyGetDevCaps           [MMSYSTEM.102]
196  */
197 static LRESULT JSTCK_GetDevCaps(DWORD_PTR dwDevID, LPJOYCAPSW lpCaps, DWORD dwSize)
198 {
199     WINE_JSTCK* jstck;
200 #ifdef HAVE_LINUX_22_JOYSTICK_API
201     int         dev;
202     char        nrOfAxes;
203     char        nrOfButtons;
204     char        identString[MAXPNAMELEN];
205     int         i;
206     int         driverVersion;
207 #else
208 static const WCHAR ini[] = {'W','i','n','e',' ','J','o','y','s','t','i','c','k',' ','D','r','i','v','e','r',0};
209 #endif
210
211     if ((jstck = JSTCK_drvGet(dwDevID)) == NULL)
212         return MMSYSERR_NODRIVER;
213
214 #ifdef HAVE_LINUX_22_JOYSTICK_API
215     if ((dev = JSTCK_OpenDevice(jstck)) < 0) return JOYERR_PARMS;
216     ioctl(dev, JSIOCGAXES, &nrOfAxes);
217     ioctl(dev, JSIOCGBUTTONS, &nrOfButtons);
218     ioctl(dev, JSIOCGVERSION, &driverVersion);
219     ioctl(dev, JSIOCGNAME(sizeof(identString)), identString);
220     TRACE("Driver: 0x%06x, Name: %s, #Axes: %d, #Buttons: %d\n",
221           driverVersion, identString, nrOfAxes, nrOfButtons);
222     lpCaps->wMid = MM_MICROSOFT;
223     lpCaps->wPid = MM_PC_JOYSTICK;
224     MultiByteToWideChar(CP_UNIXCP, 0, identString, -1, lpCaps->szPname, MAXPNAMELEN);
225     lpCaps->szPname[MAXPNAMELEN-1] = '\0';
226     lpCaps->wXmin = 0;
227     lpCaps->wXmax = 0xFFFF;
228     lpCaps->wYmin = 0;
229     lpCaps->wYmax = 0xFFFF;
230     lpCaps->wZmin = 0;
231     lpCaps->wZmax = (nrOfAxes >= 3) ? 0xFFFF : 0;
232 #ifdef BODGE_THE_HAT
233     /* Half-Life won't allow you to map an axis event to things like
234        "next weapon" and "use". Linux reports the hat on my stick as
235        axis U and V. So, IFF BODGE_THE_HAT is defined, lie through our
236        teeth and say we have 32 buttons, and we will map the axes to
237        the high buttons. Really, perhaps this should be a registry entry,
238        or even a parameter to the Linux joystick driver (which would completely
239        remove the need for this.)
240     */
241     lpCaps->wNumButtons = 32;
242 #else
243     lpCaps->wNumButtons = nrOfButtons;
244 #endif
245     if (dwSize == sizeof(JOYCAPSW)) {
246         /* complete 95 structure */
247         lpCaps->wRmin = 0;
248         lpCaps->wRmax = 0xFFFF;
249         lpCaps->wUmin = 0;
250         lpCaps->wUmax = 0xFFFF;
251         lpCaps->wVmin = 0;
252         lpCaps->wVmax = 0xFFFF;
253         lpCaps->wMaxAxes = 6; /* same as MS Joystick Driver */
254         lpCaps->wNumAxes = 0; /* nr of axes in use */
255         lpCaps->wMaxButtons = 32; /* same as MS Joystick Driver */
256         lpCaps->szRegKey[0] = 0;
257         lpCaps->szOEMVxD[0] = 0;
258         lpCaps->wCaps = 0;
259         for (i = 0; i < nrOfAxes; i++) {
260             switch (jstck->axesMap[i]) {
261             case 0: /* X */
262             case 1: /* Y */
263                 lpCaps->wNumAxes++;
264                 break;
265             case 2: /* Z */
266             case 6: /* Throttle */
267                 lpCaps->wNumAxes++;
268                 lpCaps->wCaps |= JOYCAPS_HASZ;
269                 break;
270             case 5: /* Rz */
271             case 7: /* Rudder */
272                 lpCaps->wNumAxes++;
273                 lpCaps->wCaps |= JOYCAPS_HASR;
274                 break;
275             case 3: /* Rx */
276                 lpCaps->wNumAxes++;
277                 lpCaps->wCaps |= JOYCAPS_HASU;
278                 break;
279             case 4: /* Ry */
280                 lpCaps->wNumAxes++;
281                 lpCaps->wCaps |= JOYCAPS_HASV;
282                 break;
283             case 16: /* Hat 0 X */
284             case 17: /* Hat 0 Y */
285                 lpCaps->wCaps |= JOYCAPS_HASPOV | JOYCAPS_POV4DIR;
286                 /* TODO: JOYCAPS_POVCTS handling */
287                 break;
288             default:
289                 WARN("Unknown axis %hhu(%u). Skipped.\n", jstck->axesMap[i], i);
290             }
291         }
292     }
293 #else
294     lpCaps->wMid = MM_MICROSOFT;
295     lpCaps->wPid = MM_PC_JOYSTICK;
296     strcpyW(lpCaps->szPname, ini); /* joystick product name */
297     lpCaps->wXmin = 0;
298     lpCaps->wXmax = 0xFFFF;
299     lpCaps->wYmin = 0;
300     lpCaps->wYmax = 0xFFFF;
301     lpCaps->wZmin = 0;
302     lpCaps->wZmax = 0;
303     lpCaps->wNumButtons = 2;
304     if (dwSize == sizeof(JOYCAPSW)) {
305         /* complete 95 structure */
306         lpCaps->wRmin = 0;
307         lpCaps->wRmax = 0;
308         lpCaps->wUmin = 0;
309         lpCaps->wUmax = 0;
310         lpCaps->wVmin = 0;
311         lpCaps->wVmax = 0;
312         lpCaps->wCaps = 0;
313         lpCaps->wMaxAxes = 2;
314         lpCaps->wNumAxes = 2;
315         lpCaps->wMaxButtons = 4;
316         lpCaps->szRegKey[0] = 0;
317         lpCaps->szOEMVxD[0] = 0;
318     }
319 #endif
320
321     return JOYERR_NOERROR;
322 }
323
324 /**************************************************************************
325  *                              JSTCK_GetPos                    [internal]
326  */
327 static LRESULT JSTCK_GetPosEx(DWORD_PTR dwDevID, LPJOYINFOEX lpInfo)
328 {
329     WINE_JSTCK*         jstck;
330     int                 dev;
331 #ifdef HAVE_LINUX_22_JOYSTICK_API
332     struct js_event     ev;
333 #else
334     struct js_status    js;
335     int                 dev_stat;
336 #endif
337
338     if ((jstck = JSTCK_drvGet(dwDevID)) == NULL)
339         return MMSYSERR_NODRIVER;
340
341     if ((dev = JSTCK_OpenDevice(jstck)) < 0) return JOYERR_PARMS;
342
343 #ifdef HAVE_LINUX_22_JOYSTICK_API
344     while ((read(dev, &ev, sizeof(struct js_event))) > 0) {
345         if (ev.type == (JS_EVENT_AXIS)) {
346             switch (jstck->axesMap[ev.number]) {
347             case 0: /* X */
348                 jstck->x = ev.value;
349                 break;
350             case 1: /* Y */
351                 jstck->y = ev.value;
352                 break;
353             case 2: /* Z */
354             case 6: /* Throttle */
355                 jstck->z = ev.value;
356                 break;
357             case 5: /* Rz */
358             case 7: /* Rudder */
359                 jstck->r = ev.value;
360                 break;
361             case 3: /* Rx */
362                 jstck->u = ev.value;
363                 break;
364             case 4: /* Ry */
365                 jstck->v = ev.value;
366                 break;
367             case 16: /* Hat 0 X */
368                 jstck->pov_x = ev.value;
369                 break;
370             case 17: /* Hat 0 Y */
371                 jstck->pov_y = ev.value;
372                 break;
373             default:
374                 FIXME("Unknown joystick event '%d'\n", ev.number);
375             }
376         } else if (ev.type == (JS_EVENT_BUTTON)) {
377             if (ev.value) {
378                     jstck->buttons |= (1 << ev.number);
379                     /* FIXME: what to do for this field when
380                      * multiple buttons are depressed ?
381                      */
382                     if (lpInfo->dwFlags & JOY_RETURNBUTTONS)
383                        lpInfo->dwButtonNumber = ev.number + 1;
384                 }
385              else
386                jstck->buttons  &= ~(1 << ev.number);
387         }
388     }
389     /* EAGAIN is returned when the queue is empty */
390     if (errno != EAGAIN) {
391         /* FIXME: error should not be ignored */
392         ERR("Error while reading joystick state (%s)\n", strerror(errno));
393     }
394     /* Now, copy the cached values into Window's structure... */
395     if (lpInfo->dwFlags & JOY_RETURNBUTTONS)
396        lpInfo->dwButtons = jstck->buttons;
397     if (lpInfo->dwFlags & JOY_RETURNX)
398        lpInfo->dwXpos   = jstck->x + 32767;
399     if (lpInfo->dwFlags & JOY_RETURNY)
400        lpInfo->dwYpos   = jstck->y + 32767;
401     if (lpInfo->dwFlags & JOY_RETURNZ)
402        lpInfo->dwZpos   = jstck->z + 32767;
403     if (lpInfo->dwFlags & JOY_RETURNR)
404        lpInfo->dwRpos   = jstck->r + 32767;
405 # ifdef BODGE_THE_HAT
406     else if (lpInfo->dwFlags & JOY_RETURNBUTTONS)
407     {
408          if (jstck->r > 0)
409             lpInfo->dwButtons |= 1<<7;
410          else if (jstck->r < 0)
411             lpInfo->dwButtons |= 1<<8;
412     }
413 # endif
414     if (lpInfo->dwFlags & JOY_RETURNU)
415         lpInfo->dwUpos   = jstck->u + 32767;
416 # ifdef BODGE_THE_HAT
417     else if (lpInfo->dwFlags & JOY_RETURNBUTTONS)
418     {
419        if (jstck->u > 0)
420           lpInfo->dwButtons |= 1<<9;
421         else if (jstck->u < 0)
422           lpInfo->dwButtons |= 1<<10;
423     }
424 # endif
425     if (lpInfo->dwFlags & JOY_RETURNV)
426        lpInfo->dwVpos   = jstck->v + 32767;
427     if (lpInfo->dwFlags & JOY_RETURNPOV) {
428         if (jstck->pov_y > 0) {
429             if (jstck->pov_x < 0)
430                 lpInfo->dwPOV = 22500; /* SW */
431             else if (jstck->pov_x > 0)
432                 lpInfo->dwPOV = 13500; /* SE */
433             else
434                 lpInfo->dwPOV = 18000; /* S, JOY_POVBACKWARD */
435         } else if (jstck->pov_y < 0) {
436             if (jstck->pov_x < 0)
437                 lpInfo->dwPOV = 31500; /* NW */
438             else if (jstck->pov_x > 0)
439                 lpInfo->dwPOV = 4500; /* NE */
440             else
441                 lpInfo->dwPOV = 0; /* N, JOY_POVFORWARD */
442         } else if (jstck->pov_x < 0)
443             lpInfo->dwPOV = 27000; /* W, JOY_POVLEFT */
444         else if (jstck->pov_x > 0)
445             lpInfo->dwPOV = 9000; /* E, JOY_POVRIGHT */
446         else
447             lpInfo->dwPOV = JOY_POVCENTERED; /* Center */
448     }
449
450 #else
451     dev_stat = read(dev, &js, sizeof(js));
452     if (dev_stat != sizeof(js)) {
453         return JOYERR_UNPLUGGED; /* FIXME: perhaps wrong, but what should I return else ? */
454     }
455     js.x = js.x<<8;
456     js.y = js.y<<8;
457     if (lpInfo->dwFlags & JOY_RETURNX)
458         lpInfo->dwXpos = js.x;   /* FIXME: perhaps multiply it somehow ? */
459     if (lpInfo->dwFlags & JOY_RETURNY)
460         lpInfo->dwYpos = js.y;
461     if (lpInfo->dwFlags & JOY_RETURNBUTTONS)
462         lpInfo->dwButtons = js.buttons;
463 #endif
464
465     TRACE("x: %d, y: %d, z: %d, r: %d, u: %d, v: %d, buttons: 0x%04x, flags: 0x%04x (fd %d)\n",
466           lpInfo->dwXpos, lpInfo->dwYpos, lpInfo->dwZpos,
467           lpInfo->dwRpos, lpInfo->dwUpos, lpInfo->dwVpos,
468           lpInfo->dwButtons, lpInfo->dwFlags, dev
469          );
470
471     return JOYERR_NOERROR;
472 }
473
474 /**************************************************************************
475  *                              JSTCK_GetPos                    [internal]
476  */
477 static LRESULT JSTCK_GetPos(DWORD_PTR dwDevID, LPJOYINFO lpInfo)
478 {
479     JOYINFOEX   ji;
480     LONG        ret;
481
482     memset(&ji, 0, sizeof(ji));
483
484     ji.dwSize = sizeof(ji);
485     ji.dwFlags = JOY_RETURNX | JOY_RETURNY | JOY_RETURNZ | JOY_RETURNBUTTONS;
486     ret = JSTCK_GetPosEx(dwDevID, &ji);
487     if (ret == JOYERR_NOERROR)  {
488         lpInfo->wXpos    = ji.dwXpos;
489         lpInfo->wYpos    = ji.dwYpos;
490         lpInfo->wZpos    = ji.dwZpos;
491         lpInfo->wButtons = ji.dwButtons;
492     }
493
494     return ret;
495 }
496
497 /**************************************************************************
498  *                              DriverProc (JOYSTICK.@)
499  */
500 LRESULT CALLBACK JSTCK_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
501                                   LPARAM dwParam1, LPARAM dwParam2)
502 {
503     /* EPP     TRACE("(%08lX, %04X, %08lX, %08lX, %08lX)\n",  */
504     /* EPP        dwDevID, hDriv, wMsg, dwParam1, dwParam2); */
505
506     switch(wMsg) {
507     case DRV_LOAD:              return 1;
508     case DRV_FREE:              return 1;
509     case DRV_OPEN:              return JSTCK_drvOpen((LPSTR)dwParam1, dwParam2);
510     case DRV_CLOSE:             return JSTCK_drvClose(dwDevID);
511     case DRV_ENABLE:            return 1;
512     case DRV_DISABLE:           return 1;
513     case DRV_QUERYCONFIGURE:    return 1;
514     case DRV_CONFIGURE:         MessageBoxA(0, "JoyStick MultiMedia Driver !", "JoyStick Driver", MB_OK);       return 1;
515     case DRV_INSTALL:           return DRVCNF_RESTART;
516     case DRV_REMOVE:            return DRVCNF_RESTART;
517
518     case JDD_GETNUMDEVS:        return 1;
519     case JDD_GETDEVCAPS:        return JSTCK_GetDevCaps(dwDevID, (LPJOYCAPSW)dwParam1, dwParam2);
520     case JDD_GETPOS:            return JSTCK_GetPos(dwDevID, (LPJOYINFO)dwParam1);
521     case JDD_SETCALIBRATION:
522     case JDD_CONFIGCHANGED:     return JOYERR_NOCANDO;
523     case JDD_GETPOSEX:          return JSTCK_GetPosEx(dwDevID, (LPJOYINFOEX)dwParam1);
524     default:
525         return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
526     }
527 }
528
529 #else
530
531 /**************************************************************************
532  *                              DriverProc (JOYSTICK.@)
533  */
534 LRESULT CALLBACK JSTCK_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
535                                   LPARAM dwParam1, LPARAM dwParam2)
536 {
537     /* EPP     TRACE("(%08lX, %04X, %08lX, %08lX, %08lX)\n",  */
538     /* EPP        dwDevID, hDriv, wMsg, dwParam1, dwParam2); */
539
540     switch(wMsg) {
541     case DRV_LOAD:
542     case DRV_FREE:
543     case DRV_OPEN:
544     case DRV_CLOSE:
545     case DRV_ENABLE:
546     case DRV_DISABLE:
547     case DRV_QUERYCONFIGURE:    return 0;
548     case DRV_CONFIGURE:         MessageBoxA(0, "JoyStick MultiMedia Driver !", "JoyStick Driver", MB_OK);       return 1;
549     case DRV_INSTALL:           return DRVCNF_RESTART;
550     case DRV_REMOVE:            return DRVCNF_RESTART;
551     default:
552         return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
553     }
554 }
555
556 #endif