joystick.c 15.1 KB
Newer Older
1 2 3 4
/*
 * joystick functions
 *
 * Copyright 1997 Andreas Mohr
5 6
 * Copyright 2000 Wolfgang Schwotzer
 * Copyright 2002 David Hagood
7
 *
8 9 10 11 12 13 14 15 16 17 18 19
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * 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
 *
 * NOTES:
 *
24 25 26
 * - nearly all joystick functions can be regarded as obsolete,
 *   as Linux (2.1.x) now supports extended joysticks with a completely 
 *   new joystick driver interface
Austin English's avatar
Austin English committed
27
 *   New driver's documentation says:
28 29 30 31 32 33 34 35
 *     "For backward compatibility the old interface is still included,
 *     but will be dropped in the future."
 *   Thus we should implement the new interface and at most keep the old
 *   routines for backward compatibility.
 * - better support of enhanced joysticks (Linux 2.2 interface is available)
 * - support more joystick drivers (like the XInput extension)
 * - should load joystick DLL as any other driver (instead of hardcoding)
 *   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 42 43
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
44
#include <stdarg.h>
45 46 47 48
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
49
#ifdef HAVE_SYS_IOCTL_H
50
#include <sys/ioctl.h>
51
#endif
52 53 54
#ifdef HAVE_LINUX_IOCTL_H
#include <linux/ioctl.h>
#endif
55 56
#ifdef HAVE_LINUX_JOYSTICK_H
#include <linux/joystick.h>
57 58 59
#ifdef SW_MAX
#undef SW_MAX
#endif
60 61
#define JOYDEV_NEW "/dev/input/js%d"
#define JOYDEV_OLD "/dev/js%d"
62 63 64 65
#endif
#ifdef HAVE_SYS_ERRNO_H
#include <sys/errno.h>
#endif
66

67
#include "windef.h"
68
#include "winbase.h"
69 70
#include "wingdi.h"
#include "winuser.h"
71
#include "winnls.h"
72
#include "mmddk.h"
73
#include "wine/debug.h"
74

Edgar Hucek's avatar
Edgar Hucek committed
75 76
#include "wine/unicode.h"

77
WINE_DEFAULT_DEBUG_CHANNEL(joystick);
78

79
#define MAXJOYSTICK (JOYSTICKID2 + 30)
80

81 82 83
typedef struct tagWINE_JSTCK {
    int		joyIntf;
    int		in_use;
Austin English's avatar
Austin English committed
84
    /* Some extra info we need to make this actually work under the
85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
       Linux 2.2 event api.
       First of all, we cannot keep closing and reopening the device file -
       that blows away the state of the stick device, and we lose events. So, we
       need to open the low-level device once, and close it when we are done.

       Secondly, the event API only gives us what's changed. However, Windows apps
       want the whole state every time, so we have to cache the data.
    */

    int         dev; /* Linux level device file descriptor */
    int         x;
    int         y;
    int         z;
    int         r;
    int         u;
    int         v;
101 102
    int         pov_x;
    int         pov_y;
103
    int         buttons;
104
    char        axesMap[ABS_MAX + 1];
105 106 107 108 109
} WINE_JSTCK;

static	WINE_JSTCK	JSTCK_Data[MAXJOYSTICK];

/**************************************************************************
110
 * 				JSTCK_drvGet			[internal]
111
 */
112
static WINE_JSTCK *JSTCK_drvGet(DWORD_PTR dwDevID)
113 114 115
{
    int	p;

116
    if ((dwDevID - (DWORD_PTR)JSTCK_Data) % sizeof(JSTCK_Data[0]) != 0)
117
	return NULL;
118
    p = (dwDevID - (DWORD_PTR)JSTCK_Data) / sizeof(JSTCK_Data[0]);
119 120 121 122 123
    if (p < 0 || p >= MAXJOYSTICK || !((WINE_JSTCK*)dwDevID)->in_use)
	return NULL;

    return (WINE_JSTCK*)dwDevID;
}
124 125

/**************************************************************************
126
 * 				JSTCK_drvOpen			[internal]
127
 */
128
static LRESULT JSTCK_drvOpen(LPSTR str, DWORD dwIntf)
129
{
130
    if (dwIntf >= MAXJOYSTICK || JSTCK_Data[dwIntf].in_use)
131
	return 0;
132 133 134

    JSTCK_Data[dwIntf].joyIntf = dwIntf;
    JSTCK_Data[dwIntf].in_use = 1;
135
    return (LRESULT)&JSTCK_Data[dwIntf];
136 137 138
}

/**************************************************************************
139
 * 				JSTCK_drvClose			[internal]
140
 */
141
static LRESULT JSTCK_drvClose(DWORD_PTR dwDevID)
142
{
143 144 145 146 147
    WINE_JSTCK*	jstck = JSTCK_drvGet(dwDevID);

    if (jstck == NULL)
	return 0;
    jstck->in_use = 0;
148 149 150 151 152
    if (jstck->dev > 0)
    {
       close(jstck->dev);
       jstck->dev = 0;
    }
153
    return 1;
154 155 156 157 158 159 160 161 162 163 164 165
}

struct js_status
{
    int buttons;
    int x;
    int y;
};

/**************************************************************************
 *                              JSTCK_OpenDevice           [internal]
 */
166
static	int	JSTCK_OpenDevice(WINE_JSTCK* jstick)
167 168 169 170
{
    char	buf[20];
    int		flags;

171 172 173
    if (jstick->dev > 0)
      return jstick->dev;

174
    sprintf(buf, JOYDEV_NEW, jstick->joyIntf);
175 176 177 178 179
#ifdef HAVE_LINUX_22_JOYSTICK_API
    flags = O_RDONLY | O_NONBLOCK;
#else
    flags = O_RDONLY;
#endif
180 181
    if ((jstick->dev = open(buf, flags)) < 0) {
        sprintf(buf, JOYDEV_OLD, jstick->joyIntf);
182 183
        if ((jstick->dev = open(buf, flags)) < 0)
            return jstick->dev;
184
    }
185 186 187
#ifdef HAVE_LINUX_22_JOYSTICK_API
    ioctl(jstick->dev, JSIOCGAXMAP, jstick->axesMap);
#endif
188
    return jstick->dev;
189 190
}

191

192 193 194
/**************************************************************************
 * 				JoyGetDevCaps		[MMSYSTEM.102]
 */
195
static LRESULT JSTCK_GetDevCaps(DWORD_PTR dwDevID, LPJOYCAPSW lpCaps, DWORD dwSize)
196
{
197
    WINE_JSTCK*	jstck;
198 199 200 201 202
#ifdef HAVE_LINUX_22_JOYSTICK_API
    int		dev;
    char	nrOfAxes;
    char	nrOfButtons;
    char	identString[MAXPNAMELEN];
203
    int		i;
204
    int		driverVersion;
205 206
#else
static const WCHAR ini[] = {'W','i','n','e',' ','J','o','y','s','t','i','c','k',' ','D','r','i','v','e','r',0};
207 208
#endif

209 210
    if ((jstck = JSTCK_drvGet(dwDevID)) == NULL)
	return MMSYSERR_NODRIVER;
211 212

#ifdef HAVE_LINUX_22_JOYSTICK_API
213
    if ((dev = JSTCK_OpenDevice(jstck)) < 0) return JOYERR_PARMS;
214 215 216
    ioctl(dev, JSIOCGAXES, &nrOfAxes);
    ioctl(dev, JSIOCGBUTTONS, &nrOfButtons);
    ioctl(dev, JSIOCGVERSION, &driverVersion);
217
    ioctl(dev, JSIOCGNAME(sizeof(identString)), identString);
218 219 220 221
    TRACE("Driver: 0x%06x, Name: %s, #Axes: %d, #Buttons: %d\n",
	  driverVersion, identString, nrOfAxes, nrOfButtons);
    lpCaps->wMid = MM_MICROSOFT;
    lpCaps->wPid = MM_PC_JOYSTICK;
222
    MultiByteToWideChar(CP_UNIXCP, 0, identString, -1, lpCaps->szPname, MAXPNAMELEN);
223 224 225 226 227 228 229
    lpCaps->szPname[MAXPNAMELEN-1] = '\0';
    lpCaps->wXmin = 0;
    lpCaps->wXmax = 0xFFFF;
    lpCaps->wYmin = 0;
    lpCaps->wYmax = 0xFFFF;
    lpCaps->wZmin = 0;
    lpCaps->wZmax = (nrOfAxes >= 3) ? 0xFFFF : 0;
230
#ifdef BODGE_THE_HAT
231
    /* Half-Life won't allow you to map an axis event to things like
232 233
       "next weapon" and "use". Linux reports the hat on my stick as
       axis U and V. So, IFF BODGE_THE_HAT is defined, lie through our
234
       teeth and say we have 32 buttons, and we will map the axes to
235 236 237 238 239 240
       the high buttons. Really, perhaps this should be a registry entry,
       or even a parameter to the Linux joystick driver (which would completely
       remove the need for this.)
    */
    lpCaps->wNumButtons = 32;
#else
241
    lpCaps->wNumButtons = nrOfButtons;
242
#endif
243
    if (dwSize == sizeof(JOYCAPSW)) {
244 245
	/* complete 95 structure */
	lpCaps->wRmin = 0;
246
	lpCaps->wRmax = 0xFFFF;
247
	lpCaps->wUmin = 0;
248
	lpCaps->wUmax = 0xFFFF;
249
	lpCaps->wVmin = 0;
250
	lpCaps->wVmax = 0xFFFF;
251
	lpCaps->wMaxAxes = 6; /* same as MS Joystick Driver */
252
	lpCaps->wNumAxes = 0; /* nr of axes in use */
253
	lpCaps->wMaxButtons = 32; /* same as MS Joystick Driver */
254 255
	lpCaps->szRegKey[0] = 0;
	lpCaps->szOEMVxD[0] = 0;
256
	lpCaps->wCaps = 0;
257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280
        for (i = 0; i < nrOfAxes; i++) {
	    switch (jstck->axesMap[i]) {
	    case 0: /* X */
	    case 1: /* Y */
		lpCaps->wNumAxes++;
		break;
	    case 2: /* Z */
	    case 6: /* Throttle */
		lpCaps->wNumAxes++;
		lpCaps->wCaps |= JOYCAPS_HASZ;
		break;
	    case 5: /* Rz */
	    case 7: /* Rudder */
		lpCaps->wNumAxes++;
		lpCaps->wCaps |= JOYCAPS_HASR;
		break;
	    case 3: /* Rx */
		lpCaps->wNumAxes++;
		lpCaps->wCaps |= JOYCAPS_HASU;
		break;
	    case 4: /* Ry */
		lpCaps->wNumAxes++;
		lpCaps->wCaps |= JOYCAPS_HASV;
		break;
281 282 283 284 285
	    case 16: /* Hat 0 X */
	    case 17: /* Hat 0 Y */
		lpCaps->wCaps |= JOYCAPS_HASPOV | JOYCAPS_POV4DIR;
		/* TODO: JOYCAPS_POVCTS handling */
		break;
286
	    default:
287
		WARN("Unknown axis %hhu(%u). Skipped.\n", jstck->axesMap[i], i);
288
	    }
289 290 291 292 293
	}
    }
#else
    lpCaps->wMid = MM_MICROSOFT;
    lpCaps->wPid = MM_PC_JOYSTICK;
294
    strcpyW(lpCaps->szPname, ini); /* joystick product name */
295 296 297 298 299 300 301
    lpCaps->wXmin = 0;
    lpCaps->wXmax = 0xFFFF;
    lpCaps->wYmin = 0;
    lpCaps->wYmax = 0xFFFF;
    lpCaps->wZmin = 0;
    lpCaps->wZmax = 0;
    lpCaps->wNumButtons = 2;
302
    if (dwSize == sizeof(JOYCAPSW)) {
303 304 305 306 307 308 309 310 311 312 313
	/* complete 95 structure */
	lpCaps->wRmin = 0;
	lpCaps->wRmax = 0;
	lpCaps->wUmin = 0;
	lpCaps->wUmax = 0;
	lpCaps->wVmin = 0;
	lpCaps->wVmax = 0;
	lpCaps->wCaps = 0;
	lpCaps->wMaxAxes = 2;
	lpCaps->wNumAxes = 2;
	lpCaps->wMaxButtons = 4;
314 315
	lpCaps->szRegKey[0] = 0;
	lpCaps->szOEMVxD[0] = 0;
316 317 318 319 320 321 322 323 324
    }
#endif

    return JOYERR_NOERROR;
}

/**************************************************************************
 * 				JSTCK_GetPos			[internal]
 */
325
static LRESULT JSTCK_GetPosEx(DWORD_PTR dwDevID, LPJOYINFOEX lpInfo)
326
{
327
    WINE_JSTCK*		jstck;
328 329 330 331 332 333 334
    int			dev;
#ifdef HAVE_LINUX_22_JOYSTICK_API
    struct js_event 	ev;
#else
    struct js_status 	js;
    int    		dev_stat;
#endif
335

336 337 338 339
    if ((jstck = JSTCK_drvGet(dwDevID)) == NULL)
	return MMSYSERR_NODRIVER;

    if ((dev = JSTCK_OpenDevice(jstck)) < 0) return JOYERR_PARMS;
340 341 342

#ifdef HAVE_LINUX_22_JOYSTICK_API
    while ((read(dev, &ev, sizeof(struct js_event))) > 0) {
343
	if (ev.type == (JS_EVENT_AXIS)) {
344 345
	    switch (jstck->axesMap[ev.number]) {
	    case 0: /* X */
346
		jstck->x = ev.value;
347
		break;
348
	    case 1: /* Y */
349
		jstck->y = ev.value;
350
		break;
351 352
	    case 2: /* Z */
	    case 6: /* Throttle */
353
		jstck->z = ev.value;
354
		break;
355 356
	    case 5: /* Rz */
	    case 7: /* Rudder */
357 358
		jstck->r = ev.value;
		break;
359
	    case 3: /* Rx */
360 361
		jstck->u = ev.value;
		break;
362
	    case 4: /* Ry */
363
		jstck->v = ev.value;
364
		break;
365 366 367 368 369 370
	    case 16: /* Hat 0 X */
		jstck->pov_x = ev.value;
		break;
	    case 17: /* Hat 0 Y */
		jstck->pov_y = ev.value;
		break;
371
	    default:
372 373
		FIXME("Unknown joystick event '%d'\n", ev.number);
	    }
374 375 376
	} else if (ev.type == (JS_EVENT_BUTTON)) {
	    if (ev.value) {
		    jstck->buttons |= (1 << ev.number);
377
		    /* FIXME: what to do for this field when
378 379
		     * multiple buttons are depressed ?
		     */
380 381
		    if (lpInfo->dwFlags & JOY_RETURNBUTTONS)
                       lpInfo->dwButtonNumber = ev.number + 1;
382
		}
383 384
             else
               jstck->buttons  &= ~(1 << ev.number);
385 386 387 388 389
	}
    }
    /* EAGAIN is returned when the queue is empty */
    if (errno != EAGAIN) {
	/* FIXME: error should not be ignored */
390
	ERR("Error while reading joystick state (%s)\n", strerror(errno));
391
    }
392 393 394 395 396 397 398 399 400 401 402
    /* Now, copy the cached values into Window's structure... */
    if (lpInfo->dwFlags & JOY_RETURNBUTTONS)
       lpInfo->dwButtons = jstck->buttons;
    if (lpInfo->dwFlags & JOY_RETURNX)
       lpInfo->dwXpos   = jstck->x + 32767;
    if (lpInfo->dwFlags & JOY_RETURNY)
       lpInfo->dwYpos   = jstck->y + 32767;
    if (lpInfo->dwFlags & JOY_RETURNZ)
       lpInfo->dwZpos   = jstck->z + 32767;
    if (lpInfo->dwFlags & JOY_RETURNR)
       lpInfo->dwRpos   = jstck->r + 32767;
403
# ifdef BODGE_THE_HAT
404 405 406 407 408 409 410
    else if (lpInfo->dwFlags & JOY_RETURNBUTTONS)
    {
         if (jstck->r > 0)
            lpInfo->dwButtons |= 1<<7;
         else if (jstck->r < 0)
            lpInfo->dwButtons |= 1<<8;
    }
411
# endif
412 413
    if (lpInfo->dwFlags & JOY_RETURNU)
	lpInfo->dwUpos   = jstck->u + 32767;
414
# ifdef BODGE_THE_HAT
415 416 417 418 419 420 421
    else if (lpInfo->dwFlags & JOY_RETURNBUTTONS)
    {
       if (jstck->u > 0)
          lpInfo->dwButtons |= 1<<9;
        else if (jstck->u < 0)
          lpInfo->dwButtons |= 1<<10;
    }
422
# endif
423 424
    if (lpInfo->dwFlags & JOY_RETURNV)
       lpInfo->dwVpos   = jstck->v + 32767;
425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446
    if (lpInfo->dwFlags & JOY_RETURNPOV) {
	if (jstck->pov_y > 0) {
	    if (jstck->pov_x < 0)
		lpInfo->dwPOV = 22500; /* SW */
	    else if (jstck->pov_x > 0)
		lpInfo->dwPOV = 13500; /* SE */
	    else
		lpInfo->dwPOV = 18000; /* S, JOY_POVBACKWARD */
	} else if (jstck->pov_y < 0) {
	    if (jstck->pov_x < 0)
		lpInfo->dwPOV = 31500; /* NW */
	    else if (jstck->pov_x > 0)
		lpInfo->dwPOV = 4500; /* NE */
	    else
		lpInfo->dwPOV = 0; /* N, JOY_POVFORWARD */
	} else if (jstck->pov_x < 0)
	    lpInfo->dwPOV = 27000; /* W, JOY_POVLEFT */
	else if (jstck->pov_x > 0)
	    lpInfo->dwPOV = 9000; /* E, JOY_POVRIGHT */
	else
	    lpInfo->dwPOV = JOY_POVCENTERED; /* Center */
    }
447

448 449 450 451 452 453 454 455 456 457 458 459 460 461 462
#else
    dev_stat = read(dev, &js, sizeof(js));
    if (dev_stat != sizeof(js)) {
	return JOYERR_UNPLUGGED; /* FIXME: perhaps wrong, but what should I return else ? */
    }
    js.x = js.x<<8;
    js.y = js.y<<8;
    if (lpInfo->dwFlags & JOY_RETURNX)
	lpInfo->dwXpos = js.x;   /* FIXME: perhaps multiply it somehow ? */
    if (lpInfo->dwFlags & JOY_RETURNY)
	lpInfo->dwYpos = js.y;
    if (lpInfo->dwFlags & JOY_RETURNBUTTONS)
	lpInfo->dwButtons = js.buttons;
#endif

463
    TRACE("x: %d, y: %d, z: %d, r: %d, u: %d, v: %d, buttons: 0x%04x, flags: 0x%04x (fd %d)\n",
464 465
	  lpInfo->dwXpos, lpInfo->dwYpos, lpInfo->dwZpos,
	  lpInfo->dwRpos, lpInfo->dwUpos, lpInfo->dwVpos,
466
	  lpInfo->dwButtons, lpInfo->dwFlags, dev
467
         );
468 469 470 471 472 473 474

    return JOYERR_NOERROR;
}

/**************************************************************************
 * 				JSTCK_GetPos			[internal]
 */
475
static LRESULT JSTCK_GetPos(DWORD_PTR dwDevID, LPJOYINFO lpInfo)
476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495
{
    JOYINFOEX	ji;
    LONG	ret;

    memset(&ji, 0, sizeof(ji));

    ji.dwSize = sizeof(ji);
    ji.dwFlags = JOY_RETURNX | JOY_RETURNY | JOY_RETURNZ | JOY_RETURNBUTTONS;
    ret = JSTCK_GetPosEx(dwDevID, &ji);
    if (ret == JOYERR_NOERROR)	{
	lpInfo->wXpos    = ji.dwXpos;
	lpInfo->wYpos    = ji.dwYpos;
	lpInfo->wZpos    = ji.dwZpos;
	lpInfo->wButtons = ji.dwButtons;
    }

    return ret;
}

/**************************************************************************
Patrik Stridvall's avatar
Patrik Stridvall committed
496
 * 				DriverProc (JOYSTICK.@)
497
 */
498 499
LRESULT CALLBACK JSTCK_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
                                  LPARAM dwParam1, LPARAM dwParam2)
500 501 502
{
    /* EPP     TRACE("(%08lX, %04X, %08lX, %08lX, %08lX)\n",  */
    /* EPP 	  dwDevID, hDriv, wMsg, dwParam1, dwParam2); */
503

504 505 506
    switch(wMsg) {
    case DRV_LOAD:		return 1;
    case DRV_FREE:		return 1;
507
    case DRV_OPEN:		return JSTCK_drvOpen((LPSTR)dwParam1, dwParam2);
508 509 510 511 512 513 514 515
    case DRV_CLOSE:		return JSTCK_drvClose(dwDevID);
    case DRV_ENABLE:		return 1;
    case DRV_DISABLE:		return 1;
    case DRV_QUERYCONFIGURE:	return 1;
    case DRV_CONFIGURE:		MessageBoxA(0, "JoyStick MultiMedia Driver !", "JoyStick Driver", MB_OK);	return 1;
    case DRV_INSTALL:		return DRVCNF_RESTART;
    case DRV_REMOVE:		return DRVCNF_RESTART;

516
    case JDD_GETNUMDEVS:	return 1;
517
    case JDD_GETDEVCAPS:	return JSTCK_GetDevCaps(dwDevID, (LPJOYCAPSW)dwParam1, dwParam2);
518
    case JDD_GETPOS:		return JSTCK_GetPos(dwDevID, (LPJOYINFO)dwParam1);
519
    case JDD_SETCALIBRATION:
520 521 522 523 524 525
    case JDD_CONFIGCHANGED:	return JOYERR_NOCANDO;
    case JDD_GETPOSEX:		return JSTCK_GetPosEx(dwDevID, (LPJOYINFOEX)dwParam1);
    default:
	return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
    }
}