git.oblomov.eu Git - wine/blob - dlls/dinput/joystick/linux.c

   1 /*              DirectInput Joystick device
   2  *
   3  * Copyright 1998 Marcus Meissner
   4  * Copyright 1998,1999 Lionel Ulmer
   5  * Copyright 2000-2001 TransGaming Technologies Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include "config.h"
  23
  24 #ifdef HAVE_LINUX_22_JOYSTICK_API
  25
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <time.h>
  29 #include <unistd.h>
  30 #include <sys/time.h>
  31 #include <sys/fcntl.h>
  32 #ifdef HAVE_SYS_IOCTL_H
  33 # include <sys/ioctl.h>
  34 #endif
  35 #include <errno.h>
  36 #ifdef HAVE_SYS_ERRNO_H
  37 # include <sys/errno.h>
  38 #endif
  39 #ifdef HAVE_LINUX_JOYSTICK_H
  40 # include <linux/joystick.h>
  41 #endif
  42 #define JOYDEV  "/dev/js0"
  43
  44 #include "wine/debug.h"
  45 #include "winbase.h"
  46 #include "winerror.h"
  47 #include "windef.h"
  48 #include "dinput.h"
  49
  50 #include "dinput_private.h"
  51 #include "device_private.h"
  52
  53 WINE_DEFAULT_DEBUG_CHANNEL(dinput);
  54
  55 /* Wine joystick driver object instances */
  56 #define WINE_JOYSTICK_AXIS_BASE   0
  57 #define WINE_JOYSTICK_BUTTON_BASE 8
  58
  59 typedef struct JoystickAImpl JoystickAImpl;
  60 static ICOM_VTABLE(IDirectInputDevice8A) JoystickAvt;
  61 struct JoystickAImpl
  62 {
  63         LPVOID                          lpVtbl;
  64         DWORD                           ref;
  65         GUID                            guid;
  66
  67         /* The 'parent' DInput */
  68         IDirectInputAImpl *dinput;
  69
  70         /* joystick private */
  71         int                             joyfd;
  72         LPDIDATAFORMAT                  df;
  73         HANDLE                          hEvent;
  74         LONG                            lMin,lMax,deadzone;
  75         LPDIDEVICEOBJECTDATA            data_queue;
  76         int                             queue_head, queue_tail, queue_len;
  77         DIJOYSTATE                      js;
  78 };
  79
  80 static GUID DInput_Wine_Joystick_GUID = { /* 9e573ed9-7734-11d2-8d4a-23903fb6bdf7 */
  81   0x9e573ed9,
  82   0x7734,
  83   0x11d2,
  84   {0x8d, 0x4a, 0x23, 0x90, 0x3f, 0xb6, 0xbd, 0xf7}
  85 };
  86
  87 static BOOL joydev_enum_device(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINSTANCEA lpddi)
  88 {
  89   int fd = -1;
  90
  91   if (dwFlags & DIEDFL_FORCEFEEDBACK)
  92     return FALSE;
  93
  94   if ((dwDevType==0) || (GET_DIDEVICE_TYPE(dwDevType)==DIDEVTYPE_JOYSTICK)) {
  95     /* check whether we have a joystick */
  96     if ((fd = open(JOYDEV,O_RDONLY) != -1) || (errno!=ENODEV && errno!=ENOENT)) {
  97       TRACE("Enumerating the linux Joystick device\n");
  98
  99       /* Return joystick */
 100       lpddi->guidInstance       = GUID_Joystick;
 101       lpddi->guidProduct        = DInput_Wine_Joystick_GUID;
 102       /* we only support traditional joysticks for now */
 103       lpddi->dwDevType  = DIDEVTYPE_JOYSTICK |
 104                          (DIDEVTYPEJOYSTICK_TRADITIONAL<<8);
 105       strcpy(lpddi->tszInstanceName,    "Joystick");
 106       /* ioctl JSIOCGNAME(len) */
 107       strcpy(lpddi->tszProductName,     "Wine Joystick");
 108
 109       lpddi->guidFFDriver = GUID_NULL;
 110       if (fd != -1)
 111         close(fd);
 112       return TRUE;
 113     }
 114   }
 115
 116   return FALSE;
 117 }
 118
 119 static JoystickAImpl *alloc_device(REFGUID rguid, LPVOID jvt, IDirectInputAImpl *dinput)
 120 {
 121   JoystickAImpl* newDevice;
 122
 123   newDevice = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(JoystickAImpl));
 124   newDevice->lpVtbl = jvt;
 125   newDevice->ref = 1;
 126   newDevice->joyfd = -1;
 127   newDevice->lMin = -32768;
 128   newDevice->lMax = +32767;
 129   newDevice->dinput = dinput;
 130   memcpy(&(newDevice->guid),rguid,sizeof(*rguid));
 131
 132   return newDevice;
 133 }
 134
 135 static HRESULT joydev_create_device(IDirectInputAImpl *dinput, REFGUID rguid, REFIID riid, LPDIRECTINPUTDEVICEA* pdev)
 136 {
 137   if ((IsEqualGUID(&GUID_Joystick,rguid)) ||
 138       (IsEqualGUID(&DInput_Wine_Joystick_GUID,rguid))) {
 139     if ((riid == NULL) ||
 140         IsEqualGUID(&IID_IDirectInputDeviceA,riid) ||
 141         IsEqualGUID(&IID_IDirectInputDevice2A,riid) ||
 142         IsEqualGUID(&IID_IDirectInputDevice7A,riid) ||
 143         IsEqualGUID(&IID_IDirectInputDevice8A,riid)) {
 144       *pdev=(IDirectInputDeviceA*) alloc_device(rguid, &JoystickAvt, dinput);
 145
 146       TRACE("Creating a Joystick device (%p)\n", *pdev);
 147       return DI_OK;
 148     } else
 149       return DIERR_NOINTERFACE;
 150   }
 151
 152   return DIERR_DEVICENOTREG;
 153 }
 154
 155 static dinput_device joydev = {
 156   10,
 157   joydev_enum_device,
 158   joydev_create_device
 159 };
 160
 161 DECL_GLOBAL_CONSTRUCTOR(joydev_register) { dinput_register_device(&joydev); }
 162
 163 /******************************************************************************
 164  *      Joystick
 165  */
 166 static ULONG WINAPI JoystickAImpl_Release(LPDIRECTINPUTDEVICE8A iface)
 167 {
 168         ICOM_THIS(JoystickAImpl,iface);
 169
 170         This->ref--;
 171         if (This->ref)
 172                 return This->ref;
 173
 174         /* Free the data queue */
 175         if (This->data_queue != NULL)
 176           HeapFree(GetProcessHeap(),0,This->data_queue);
 177
 178         /* Free the DataFormat */
 179         HeapFree(GetProcessHeap(), 0, This->df);
 180
 181         HeapFree(GetProcessHeap(),0,This);
 182         return 0;
 183 }
 184
 185 /******************************************************************************
 186   *   SetDataFormat : the application can choose the format of the data
 187   *   the device driver sends back with GetDeviceState.
 188   */
 189 static HRESULT WINAPI JoystickAImpl_SetDataFormat(
 190         LPDIRECTINPUTDEVICE8A iface,LPCDIDATAFORMAT df
 191 )
 192 {
 193   ICOM_THIS(JoystickAImpl,iface);
 194   int i;
 195
 196   TRACE("(this=%p,%p)\n",This,df);
 197
 198   TRACE("(df.dwSize=%ld)\n",df->dwSize);
 199   TRACE("(df.dwObjsize=%ld)\n",df->dwObjSize);
 200   TRACE("(df.dwFlags=0x%08lx)\n",df->dwFlags);
 201   TRACE("(df.dwDataSize=%ld)\n",df->dwDataSize);
 202   TRACE("(df.dwNumObjs=%ld)\n",df->dwNumObjs);
 203
 204   for (i=0;i<df->dwNumObjs;i++) {
 205     TRACE("df.rgodf[%d].guid %s (%p)\n",i,debugstr_guid(df->rgodf[i].pguid), df->rgodf[i].pguid);
 206     TRACE("df.rgodf[%d].dwOfs %ld\n",i,df->rgodf[i].dwOfs);
 207     TRACE("dwType 0x%02x,dwInstance %d\n",DIDFT_GETTYPE(df->rgodf[i].dwType),DIDFT_GETINSTANCE(df->rgodf[i].dwType));
 208     TRACE("df.rgodf[%d].dwFlags 0x%08lx\n",i,df->rgodf[i].dwFlags);
 209   }
 210
 211   /* Store the new data format */
 212   This->df = HeapAlloc(GetProcessHeap(),0,df->dwSize);
 213   memcpy(This->df, df, df->dwSize);
 214   This->df->rgodf = HeapAlloc(GetProcessHeap(),0,df->dwNumObjs*df->dwObjSize);
 215   memcpy(This->df->rgodf,df->rgodf,df->dwNumObjs*df->dwObjSize);
 216
 217   return 0;
 218 }
 219
 220 /******************************************************************************
 221   *     Acquire : gets exclusive control of the joystick
 222   */
 223 static HRESULT WINAPI JoystickAImpl_Acquire(LPDIRECTINPUTDEVICE8A iface)
 224 {
 225     ICOM_THIS(JoystickAImpl,iface);
 226
 227     TRACE("(this=%p)\n",This);
 228     if (This->joyfd!=-1)
 229         return 0;
 230     This->joyfd=open(JOYDEV,O_RDONLY);
 231     if (This->joyfd==-1)
 232         return DIERR_NOTFOUND;
 233     return 0;
 234 }
 235
 236 /******************************************************************************
 237   *     Unacquire : frees the joystick
 238   */
 239 static HRESULT WINAPI JoystickAImpl_Unacquire(LPDIRECTINPUTDEVICE8A iface)
 240 {
 241     ICOM_THIS(JoystickAImpl,iface);
 242
 243     TRACE("(this=%p)\n",This);
 244     if (This->joyfd!=-1) {
 245         close(This->joyfd);
 246         This->joyfd = -1;
 247     }
 248     return DI_OK;
 249 }
 250
 251 #define map_axis(val) ((val+32768)*(This->lMax-This->lMin)/65536+This->lMin)
 252
 253 static void joy_polldev(JoystickAImpl *This) {
 254     struct timeval tv;
 255     fd_set      readfds;
 256     struct      js_event jse;
 257
 258     if (This->joyfd==-1)
 259         return;
 260     while (1) {
 261         memset(&tv,0,sizeof(tv));
 262         FD_ZERO(&readfds);FD_SET(This->joyfd,&readfds);
 263         if (1>select(This->joyfd+1,&readfds,NULL,NULL,&tv))
 264             return;
 265         /* we have one event, so we can read */
 266         if (sizeof(jse)!=read(This->joyfd,&jse,sizeof(jse))) {
 267             return;
 268         }
 269         TRACE("js_event: type 0x%x, number %d, value %d\n",jse.type,jse.number,jse.value);
 270         if (jse.type & JS_EVENT_BUTTON) {
 271             GEN_EVENT(DIJOFS_BUTTON(jse.number),jse.value?0x80:0x00,jse.time,(This->dinput->evsequence)++);
 272             This->js.rgbButtons[jse.number] = jse.value?0x80:0x00;
 273         }
 274         if (jse.type & JS_EVENT_AXIS) {
 275             switch (jse.number) {
 276             case 0:
 277                 GEN_EVENT(jse.number*4,jse.value,jse.time,(This->dinput->evsequence)++);
 278                 This->js.lX = map_axis(jse.value);
 279                 break;
 280             case 1:
 281                 GEN_EVENT(jse.number*4,jse.value,jse.time,(This->dinput->evsequence)++);
 282                 This->js.lY = map_axis(jse.value);
 283                 break;
 284             case 2:
 285                 GEN_EVENT(jse.number*4,jse.value,jse.time,(This->dinput->evsequence)++);
 286                 This->js.lZ = map_axis(jse.value);
 287                 break;
 288             default:
 289                 FIXME("more than 3 axes (%d) not handled!\n",jse.number);
 290                 break;
 291             }
 292         }
 293     }
 294 }
 295
 296 /******************************************************************************
 297   *     GetDeviceState : returns the "state" of the joystick.
 298   *
 299   */
 300 static HRESULT WINAPI JoystickAImpl_GetDeviceState(
 301         LPDIRECTINPUTDEVICE8A iface,DWORD len,LPVOID ptr
 302 ) {
 303     ICOM_THIS(JoystickAImpl,iface);
 304
 305     joy_polldev(This);
 306     TRACE("(this=%p,0x%08lx,%p)\n",This,len,ptr);
 307     if (len != sizeof(DIJOYSTATE)) {
 308         FIXME("len %ld is not sizeof(DIJOYSTATE), unsupported format.\n",len);
 309     }
 310     memcpy(ptr,&(This->js),len);
 311     This->queue_head = 0;
 312     This->queue_tail = 0;
 313     return 0;
 314 }
 315
 316 /******************************************************************************
 317   *     GetDeviceData : gets buffered input data.
 318   */
 319 static HRESULT WINAPI JoystickAImpl_GetDeviceData(LPDIRECTINPUTDEVICE8A iface,
 320                                               DWORD dodsize,
 321                                               LPDIDEVICEOBJECTDATA dod,
 322                                               LPDWORD entries,
 323                                               DWORD flags
 324 ) {
 325   ICOM_THIS(JoystickAImpl,iface);
 326
 327   FIXME("(%p)->(dods=%ld,entries=%ld,fl=0x%08lx),STUB!\n",This,dodsize,*entries,flags);
 328
 329   joy_polldev(This);
 330   if (flags & DIGDD_PEEK)
 331     FIXME("DIGDD_PEEK\n");
 332
 333   if (dod == NULL) {
 334   } else {
 335   }
 336   return 0;
 337 }
 338
 339 /******************************************************************************
 340   *     SetProperty : change input device properties
 341   */
 342 static HRESULT WINAPI JoystickAImpl_SetProperty(LPDIRECTINPUTDEVICE8A iface,
 343                                             REFGUID rguid,
 344                                             LPCDIPROPHEADER ph)
 345 {
 346   ICOM_THIS(JoystickAImpl,iface);
 347
 348   FIXME("(this=%p,%s,%p)\n",This,debugstr_guid(rguid),ph);
 349   FIXME("ph.dwSize = %ld, ph.dwHeaderSize =%ld, ph.dwObj = %ld, ph.dwHow= %ld\n",ph->dwSize, ph->dwHeaderSize,ph->dwObj,ph->dwHow);
 350
 351   if (!HIWORD(rguid)) {
 352     switch ((DWORD)rguid) {
 353     case (DWORD) DIPROP_BUFFERSIZE: {
 354       LPCDIPROPDWORD    pd = (LPCDIPROPDWORD)ph;
 355
 356       FIXME("buffersize = %ld\n",pd->dwData);
 357       break;
 358     }
 359     case (DWORD)DIPROP_RANGE: {
 360       LPCDIPROPRANGE    pr = (LPCDIPROPRANGE)ph;
 361
 362       FIXME("proprange(%ld,%ld)\n",pr->lMin,pr->lMax);
 363       This->lMin = pr->lMin;
 364       This->lMax = pr->lMax;
 365       break;
 366     }
 367     case (DWORD)DIPROP_DEADZONE: {
 368       LPCDIPROPDWORD    pd = (LPCDIPROPDWORD)ph;
 369
 370       FIXME("deadzone(%ld)\n",pd->dwData);
 371       This->deadzone = pd->dwData;
 372       break;
 373     }
 374     default:
 375       FIXME("Unknown type %ld (%s)\n",(DWORD)rguid,debugstr_guid(rguid));
 376       break;
 377     }
 378   }
 379   return 0;
 380 }
 381
 382 /******************************************************************************
 383   *     SetEventNotification : specifies event to be sent on state change
 384   */
 385 static HRESULT WINAPI JoystickAImpl_SetEventNotification(
 386         LPDIRECTINPUTDEVICE8A iface, HANDLE hnd
 387 ) {
 388     ICOM_THIS(JoystickAImpl,iface);
 389
 390     TRACE("(this=%p,0x%08lx)\n",This,(DWORD)hnd);
 391     This->hEvent = hnd;
 392     return DI_OK;
 393 }
 394
 395 static HRESULT WINAPI JoystickAImpl_GetCapabilities(
 396         LPDIRECTINPUTDEVICE8A iface,
 397         LPDIDEVCAPS lpDIDevCaps)
 398 {
 399     ICOM_THIS(JoystickAImpl,iface);
 400     BYTE        axes,buttons;
 401     int         xfd = This->joyfd;
 402
 403     TRACE("%p->(%p)\n",iface,lpDIDevCaps);
 404     if (xfd==-1)
 405         xfd = open(JOYDEV,O_RDONLY);
 406     lpDIDevCaps->dwFlags        = DIDC_ATTACHED;
 407     lpDIDevCaps->dwDevType      = DIDEVTYPE_JOYSTICK;
 408 #ifdef JSIOCGAXES
 409     if (-1==ioctl(xfd,JSIOCGAXES,&axes))
 410         axes = 2;
 411     lpDIDevCaps->dwAxes = axes;
 412 #endif
 413 #ifdef JSIOCGBUTTONS
 414     if (-1==ioctl(xfd,JSIOCGAXES,&buttons))
 415         buttons = 2;
 416     lpDIDevCaps->dwButtons = buttons;
 417 #endif
 418     if (xfd!=This->joyfd)
 419         close(xfd);
 420     return DI_OK;
 421 }
 422 static HRESULT WINAPI JoystickAImpl_Poll(LPDIRECTINPUTDEVICE8A iface) {
 423     ICOM_THIS(JoystickAImpl,iface);
 424     TRACE("(),stub!\n");
 425
 426     joy_polldev(This);
 427     return DI_OK;
 428 }
 429
 430 /******************************************************************************
 431   *     EnumObjects : enumerate the different buttons and axis...
 432   */
 433 static HRESULT WINAPI JoystickAImpl_EnumObjects(
 434         LPDIRECTINPUTDEVICE8A iface,
 435         LPDIENUMDEVICEOBJECTSCALLBACKA lpCallback,
 436         LPVOID lpvRef,
 437         DWORD dwFlags)
 438 {
 439   ICOM_THIS(JoystickAImpl,iface);
 440   DIDEVICEOBJECTINSTANCEA ddoi;
 441   int xfd = This->joyfd;
 442
 443   TRACE("(this=%p,%p,%p,%08lx)\n", This, lpCallback, lpvRef, dwFlags);
 444   if (TRACE_ON(dinput)) {
 445     DPRINTF("  - flags = ");
 446     _dump_EnumObjects_flags(dwFlags);
 447     DPRINTF("\n");
 448   }
 449
 450   /* Only the fields till dwFFMaxForce are relevant */
 451   ddoi.dwSize = FIELD_OFFSET(DIDEVICEOBJECTINSTANCEA, dwFFMaxForce);
 452
 453   /* For the joystick, do as is done in the GetCapabilities function */
 454   if ((dwFlags == DIDFT_ALL) ||
 455       (dwFlags & DIDFT_AXIS)) {
 456     BYTE axes, i;
 457
 458 #ifdef JSIOCGAXES
 459     if (-1==ioctl(xfd,JSIOCGAXES,&axes))
 460       axes = 2;
 461 #endif
 462
 463     for (i = 0; i < axes; i++) {
 464       switch (i) {
 465       case 0:
 466         ddoi.guidType = GUID_XAxis;
 467         ddoi.dwOfs = DIJOFS_X;
 468         break;
 469       case 1:
 470         ddoi.guidType = GUID_YAxis;
 471         ddoi.dwOfs = DIJOFS_Y;
 472         break;
 473       case 2:
 474         ddoi.guidType = GUID_ZAxis;
 475         ddoi.dwOfs = DIJOFS_Z;
 476         break;
 477       default:
 478         ddoi.guidType = GUID_Unknown;
 479         ddoi.dwOfs = DIJOFS_Z + (i - 2) * sizeof(LONG);
 480       }
 481       ddoi.dwType = DIDFT_MAKEINSTANCE((0x0001 << i) << WINE_JOYSTICK_AXIS_BASE) | DIDFT_ABSAXIS;
 482       sprintf(ddoi.tszName, "%d-Axis", i);
 483       _dump_OBJECTINSTANCEA(&ddoi);
 484       if (lpCallback(&ddoi, lpvRef) != DIENUM_CONTINUE) return DI_OK;
 485     }
 486   }
 487
 488   if ((dwFlags == DIDFT_ALL) ||
 489       (dwFlags & DIDFT_BUTTON)) {
 490     BYTE buttons, i;
 491
 492 #ifdef JSIOCGBUTTONS
 493     if (-1==ioctl(xfd,JSIOCGAXES,&buttons))
 494       buttons = 2;
 495 #endif
 496
 497     /* The DInput SDK says that GUID_Button is only for mouse buttons but well... */
 498     ddoi.guidType = GUID_Button;
 499
 500     for (i = 0; i < buttons; i++) {
 501       ddoi.dwOfs = DIJOFS_BUTTON(i);
 502       ddoi.dwType = DIDFT_MAKEINSTANCE((0x0001 << i) << WINE_JOYSTICK_BUTTON_BASE) | DIDFT_PSHBUTTON;
 503       sprintf(ddoi.tszName, "%d-Button", i);
 504       _dump_OBJECTINSTANCEA(&ddoi);
 505       if (lpCallback(&ddoi, lpvRef) != DIENUM_CONTINUE) return DI_OK;
 506     }
 507   }
 508
 509   if (xfd!=This->joyfd)
 510     close(xfd);
 511
 512   return DI_OK;
 513 }
 514
 515 /******************************************************************************
 516   *     GetProperty : get input device properties
 517   */
 518 static HRESULT WINAPI JoystickAImpl_GetProperty(LPDIRECTINPUTDEVICE8A iface,
 519                                                 REFGUID rguid,
 520                                                 LPDIPROPHEADER pdiph)
 521 {
 522   ICOM_THIS(JoystickAImpl,iface);
 523
 524   TRACE("(this=%p,%s,%p): stub!\n",
 525         iface, debugstr_guid(rguid), pdiph);
 526
 527   if (TRACE_ON(dinput))
 528     _dump_DIPROPHEADER(pdiph);
 529
 530   if (!HIWORD(rguid)) {
 531     switch ((DWORD)rguid) {
 532     case (DWORD) DIPROP_BUFFERSIZE: {
 533       LPDIPROPDWORD     pd = (LPDIPROPDWORD)pdiph;
 534
 535       TRACE(" return buffersize = %d\n",This->queue_len);
 536       pd->dwData = This->queue_len;
 537       break;
 538     }
 539
 540     case (DWORD) DIPROP_RANGE: {
 541       LPDIPROPRANGE pr = (LPDIPROPRANGE) pdiph;
 542
 543       if ((pdiph->dwHow == DIPH_BYID) &&
 544           (pdiph->dwObj & DIDFT_ABSAXIS)) {
 545         /* The app is querying the current range of the axis : return the lMin and lMax values */
 546         pr->lMin = This->lMin;
 547         pr->lMax = This->lMax;
 548       }
 549
 550       break;
 551     }
 552
 553     default:
 554       FIXME("Unknown type %ld (%s)\n",(DWORD)rguid,debugstr_guid(rguid));
 555       break;
 556     }
 557   }
 558
 559
 560   return DI_OK;
 561 }
 562
 563 static ICOM_VTABLE(IDirectInputDevice8A) JoystickAvt =
 564 {
 565         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 566         IDirectInputDevice2AImpl_QueryInterface,
 567         IDirectInputDevice2AImpl_AddRef,
 568         JoystickAImpl_Release,
 569         JoystickAImpl_GetCapabilities,
 570         JoystickAImpl_EnumObjects,
 571         JoystickAImpl_GetProperty,
 572         JoystickAImpl_SetProperty,
 573         JoystickAImpl_Acquire,
 574         JoystickAImpl_Unacquire,
 575         JoystickAImpl_GetDeviceState,
 576         JoystickAImpl_GetDeviceData,
 577         JoystickAImpl_SetDataFormat,
 578         JoystickAImpl_SetEventNotification,
 579         IDirectInputDevice2AImpl_SetCooperativeLevel,
 580         IDirectInputDevice2AImpl_GetObjectInfo,
 581         IDirectInputDevice2AImpl_GetDeviceInfo,
 582         IDirectInputDevice2AImpl_RunControlPanel,
 583         IDirectInputDevice2AImpl_Initialize,
 584         IDirectInputDevice2AImpl_CreateEffect,
 585         IDirectInputDevice2AImpl_EnumEffects,
 586         IDirectInputDevice2AImpl_GetEffectInfo,
 587         IDirectInputDevice2AImpl_GetForceFeedbackState,
 588         IDirectInputDevice2AImpl_SendForceFeedbackCommand,
 589         IDirectInputDevice2AImpl_EnumCreatedEffectObjects,
 590         IDirectInputDevice2AImpl_Escape,
 591         JoystickAImpl_Poll,
 592         IDirectInputDevice2AImpl_SendDeviceData,
 593         IDirectInputDevice7AImpl_EnumEffectsInFile,
 594         IDirectInputDevice7AImpl_WriteEffectToFile,
 595         IDirectInputDevice8AImpl_BuildActionMap,
 596         IDirectInputDevice8AImpl_SetActionMap,
 597         IDirectInputDevice8AImpl_GetImageInfo
 598 };
 599
 600 #endif  /* HAVE_LINUX_22_JOYSTICK_API */