multimedia/joystick.c

   1 /*
   2  * joystick functions
   3  *
   4  * Copyright 1997 Andreas Mohr
   5  *
   6  * nearly all joystick functions can be regarded as obsolete,
   7  * as Linux (2.1.x) now supports extended joysticks
   8  * with a completely new joystick driver interface
   9  * new driver's docu says:
  10  * "For backward compatibility the old interface is still included,
  11  * but will be dropped in the future."
  12  * Thus we should implement the new interface and at most keep the old
  13  * routines for backward compatibility.
  14  */
  15
  16 #include <unistd.h>
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <fcntl.h>
  21 #include <sys/ioctl.h>
  22 #include "windows.h"
  23 #include "ldt.h"
  24 #include "user.h"
  25 #include "driver.h"
  26 #include "mmsystem.h"
  27 #include "stddebug.h"
  28 #include "debug.h"
  29
  30 static int count_use[4] = {0, 0, 0, 0};
  31 static int dev_stat;
  32 static int joy_nr_open = 0;
  33 static BOOL16 joyCaptured = FALSE;
  34 static HWND16 CaptureWnd[2] = {0, 0};
  35 static int joy_dev[2] = {-1, -1};
  36 static JOYINFO16 joyCapData[2];
  37 static unsigned int joy_threshold[2] = {0, 0};
  38
  39 struct js_status
  40 {
  41     int buttons;
  42     int x;
  43     int y;
  44 };
  45
  46
  47 /**************************************************************************
  48  *                              joyOpenDriver           [internal]
  49  */
  50 BOOL16 joyOpenDriver(WORD wID)
  51 {
  52         char dev_name[] = "/dev/jsx";
  53
  54         if (joy_dev[wID] >= 0) return TRUE;
  55         dev_name[strlen(dev_name)-1]=(char) wID+0x30;
  56         if ((joy_dev[wID] = open(dev_name, O_RDONLY)) >= 0) {
  57                 joy_nr_open++;
  58                 return TRUE;
  59         }
  60         else return FALSE;
  61 }
  62
  63 /**************************************************************************
  64  *                              joyCloseDriver           [internal]
  65  */
  66 void joyCloseDriver(WORD wID)
  67 {
  68         if (joy_dev[wID] >= 0) {
  69                 close(joy_dev[wID]);
  70                 joy_dev[wID] = -1;
  71                 joy_nr_open--;
  72         }
  73 }
  74
  75 /**************************************************************************
  76  *                              joySendMessages           [internal]
  77  */
  78 void joySendMessages(void)
  79 {
  80         int joy;
  81         struct js_status js;
  82
  83         if (joy_nr_open)
  84         for (joy=0; joy < 4; joy++)
  85         if (joy_dev[joy] >= 0) {
  86                 if (count_use[joy] > 250) {
  87                         joyCloseDriver(joy);
  88                         count_use[joy] = 0;
  89                 }
  90                 count_use[joy]++;
  91         }
  92         else return;
  93         if (joyCaptured == FALSE) return;
  94         dprintf_mmsys(stddeb, "JoySendMessages()\n");
  95         for (joy=0; joy < 4; joy++) {
  96                 if (joyOpenDriver(joy) == FALSE) continue;
  97                 dev_stat = read(joy_dev[joy], &js, sizeof(js));
  98                 if (dev_stat == sizeof(js)) {
  99                         js.x = js.x*37;
 100                         js.y = js.y*37;
 101                         if ((joyCapData[joy].wXpos != js.x) || (joyCapData[joy].wYpos != js.y)) {
 102                                 SendMessage32A(CaptureWnd[joy], MM_JOY1MOVE + joy, js.buttons, MAKELONG(js.x, js.y));
 103                                 joyCapData[joy].wXpos = js.x;
 104                                 joyCapData[joy].wYpos = js.y;
 105                         }
 106                         if (joyCapData[joy].wButtons != js.buttons) {
 107                                 unsigned int ButtonChanged = (WORD)(joyCapData[joy].wButtons ^ js.buttons)<<8;
 108                                 if (joyCapData[joy].wButtons < js.buttons)
 109                                 SendMessage32A(CaptureWnd[joy], MM_JOY1BUTTONDOWN + joy, ButtonChanged, MAKELONG(js.x, js.y));
 110                                 else
 111                                 if (joyCapData[joy].wButtons > js.buttons)
 112                                 SendMessage32A(CaptureWnd[joy], MM_JOY1BUTTONUP
 113 + joy, ButtonChanged, MAKELONG(js.x, js.y));
 114                                 joyCapData[joy].wButtons = js.buttons;
 115                         }
 116                 }
 117         }
 118 }
 119
 120
 121 /**************************************************************************
 122  *                              JoyGetNumDevs           [MMSYSTEM.101]
 123  */
 124 UINT32 WINAPI joyGetNumDevs32(void)
 125 {
 126         return joyGetNumDevs16();
 127 }
 128
 129 /**************************************************************************
 130  *                              JoyGetNumDevs           [MMSYSTEM.101]
 131  */
 132 UINT16 WINAPI joyGetNumDevs16(void)
 133 {
 134     int joy;
 135     UINT16 joy_cnt = 0;
 136
 137     dprintf_mmsys(stddeb, "JoyGetNumDevs: ");
 138     for (joy=0; joy<4; joy++)
 139         if (joyOpenDriver(joy) == TRUE) {
 140                 joyCloseDriver(joy);
 141                 joy_cnt++;
 142     }
 143     dprintf_mmsys(stddeb, "returning %d\n", joy_cnt);
 144     if (!joy_cnt) fprintf(stderr, "No joystick found - perhaps get joystick-0.8.0.tar.gz and load it as module or use Linux >= 2.1.45 to be able to use joysticks.\n");
 145     return joy_cnt;
 146 }
 147
 148 /**************************************************************************
 149  *                              JoyGetDevCaps           [WINMM.27]
 150  */
 151 MMRESULT32 WINAPI joyGetDevCaps32A(UINT32 wID, LPJOYCAPS32A lpCaps,UINT32 wSize)
 152 {
 153         JOYCAPS16       jc16;
 154         MMRESULT16      ret = joyGetDevCaps16(wID,&jc16,sizeof(jc16));
 155
 156         lpCaps->wMid = jc16.wMid;
 157         lpCaps->wPid = jc16.wPid;
 158         lstrcpy32A(lpCaps->szPname,jc16.szPname);
 159         lpCaps->wXmin = jc16.wXmin;
 160         lpCaps->wXmax = jc16.wXmax;
 161         lpCaps->wYmin = jc16.wYmin;
 162         lpCaps->wYmax = jc16.wYmax;
 163         lpCaps->wZmin = jc16.wZmin;
 164         lpCaps->wZmax = jc16.wZmax;
 165         lpCaps->wNumButtons = jc16.wNumButtons;
 166         lpCaps->wPeriodMin = jc16.wPeriodMin;
 167         lpCaps->wPeriodMax = jc16.wPeriodMax;
 168
 169         lpCaps->wRmin = jc16.wRmin;
 170         lpCaps->wRmax = jc16.wRmax;
 171         lpCaps->wUmin = jc16.wUmin;
 172         lpCaps->wUmax = jc16.wUmax;
 173         lpCaps->wVmin = jc16.wVmin;
 174         lpCaps->wVmax = jc16.wVmax;
 175         lpCaps->wCaps = jc16.wCaps;
 176         lpCaps->wMaxAxes = jc16.wMaxAxes;
 177         lpCaps->wNumAxes = jc16.wNumAxes;
 178         lpCaps->wMaxButtons = jc16.wMaxButtons;
 179         lstrcpy32A(lpCaps->szRegKey,jc16.szRegKey);
 180         lstrcpy32A(lpCaps->szOEMVxD,jc16.szOEMVxD);
 181         return ret;
 182 }
 183
 184 /**************************************************************************
 185  *                              JoyGetDevCaps           [WINMM.28]
 186  */
 187 MMRESULT32 WINAPI joyGetDevCaps32W(UINT32 wID, LPJOYCAPS32W lpCaps,UINT32 wSize)
 188 {
 189         JOYCAPS16       jc16;
 190         MMRESULT16      ret = joyGetDevCaps16(wID,&jc16,sizeof(jc16));
 191
 192         lpCaps->wMid = jc16.wMid;
 193         lpCaps->wPid = jc16.wPid;
 194         lstrcpyAtoW(lpCaps->szPname,jc16.szPname);
 195         lpCaps->wXmin = jc16.wXmin;
 196         lpCaps->wXmax = jc16.wXmax;
 197         lpCaps->wYmin = jc16.wYmin;
 198         lpCaps->wYmax = jc16.wYmax;
 199         lpCaps->wZmin = jc16.wZmin;
 200         lpCaps->wZmax = jc16.wZmax;
 201         lpCaps->wNumButtons = jc16.wNumButtons;
 202         lpCaps->wPeriodMin = jc16.wPeriodMin;
 203         lpCaps->wPeriodMax = jc16.wPeriodMax;
 204
 205         lpCaps->wRmin = jc16.wRmin;
 206         lpCaps->wRmax = jc16.wRmax;
 207         lpCaps->wUmin = jc16.wUmin;
 208         lpCaps->wUmax = jc16.wUmax;
 209         lpCaps->wVmin = jc16.wVmin;
 210         lpCaps->wVmax = jc16.wVmax;
 211         lpCaps->wCaps = jc16.wCaps;
 212         lpCaps->wMaxAxes = jc16.wMaxAxes;
 213         lpCaps->wNumAxes = jc16.wNumAxes;
 214         lpCaps->wMaxButtons = jc16.wMaxButtons;
 215         lstrcpyAtoW(lpCaps->szRegKey,jc16.szRegKey);
 216         lstrcpyAtoW(lpCaps->szOEMVxD,jc16.szOEMVxD);
 217         return ret;
 218 }
 219 /**************************************************************************
 220  *                              JoyGetDevCaps           [MMSYSTEM.102]
 221  */
 222 MMRESULT16 WINAPI joyGetDevCaps16(UINT16 wID, LPJOYCAPS16 lpCaps, UINT16 wSize)
 223 {
 224     dprintf_mmsys(stderr, "JoyGetDevCaps(%04X, %p, %d);\n",
 225             wID, lpCaps, wSize);
 226     if (joyOpenDriver(wID) == TRUE) {
 227         lpCaps->wMid = MM_MICROSOFT;
 228         lpCaps->wPid = MM_PC_JOYSTICK;
 229         strcpy(lpCaps->szPname, "WineJoy"); /* joystick product name */
 230         lpCaps->wXmin = 0; /* FIXME */
 231         lpCaps->wXmax = 0xffff;
 232         lpCaps->wYmin = 0;
 233         lpCaps->wYmax = 0xffff;
 234         lpCaps->wZmin = 0;
 235         lpCaps->wZmax = 0xffff;
 236         lpCaps->wNumButtons = 2;
 237         lpCaps->wPeriodMin = 0;
 238         lpCaps->wPeriodMax = 50; /* FIXME end */
 239         if (wSize == sizeof(JOYCAPS16)) {
 240                 /* complete 95 structure */
 241                 lpCaps->wRmin = 0;
 242                 lpCaps->wRmax = 0xffff;
 243                 lpCaps->wUmin = 0;
 244                 lpCaps->wUmax = 0xffff;
 245                 lpCaps->wVmin = 0;
 246                 lpCaps->wVmax = 0xffff;
 247                 lpCaps->wCaps = 0;
 248                 lpCaps->wMaxAxes = 6;
 249                 lpCaps->wNumAxes = 2;
 250                 lpCaps->wMaxButtons = 3;
 251                 strcpy(lpCaps->szRegKey,"");
 252                 strcpy(lpCaps->szOEMVxD,"");
 253         }
 254         joyCloseDriver(wID);
 255         return JOYERR_NOERROR;
 256     }
 257     else
 258     return MMSYSERR_NODRIVER;
 259 }
 260
 261 /**************************************************************************
 262  *                              JoyGetPosEx             [WINMM.31]
 263  */
 264 MMRESULT32 WINAPI joyGetPosEx(UINT32 wID, LPJOYINFO32 lpInfo)
 265 {
 266         /* FIXME: implement it */
 267         return MMSYSERR_NODRIVER;
 268 }
 269
 270 /**************************************************************************
 271  *                              JoyGetPos               [WINMM.30]
 272  */
 273 MMRESULT32 WINAPI joyGetPos32(UINT32 wID, LPJOYINFO32 lpInfo)
 274 {
 275         JOYINFO16       ji;
 276         MMRESULT16      ret = joyGetPos16(wID,&ji);
 277
 278         lpInfo->wXpos = ji.wXpos;
 279         lpInfo->wYpos = ji.wYpos;
 280         lpInfo->wZpos = ji.wZpos;
 281         lpInfo->wButtons = ji.wButtons;
 282         return ret;
 283 }
 284
 285 /**************************************************************************
 286  *                              JoyGetPos               [MMSYSTEM.103]
 287  */
 288 MMRESULT16 WINAPI joyGetPos16(UINT16 wID, LPJOYINFO16 lpInfo)
 289 {
 290         struct js_status js;
 291
 292         dprintf_mmsys(stderr, "JoyGetPos(%04X, %p):", wID, lpInfo);
 293         if (joyOpenDriver(wID) == FALSE) return MMSYSERR_NODRIVER;
 294         dev_stat = read(joy_dev[wID], &js, sizeof(js));
 295         if (dev_stat != sizeof(js)) {
 296                 joyCloseDriver(wID);
 297                 return JOYERR_UNPLUGGED; /* FIXME: perhaps wrong, but what should I return else ? */
 298         }
 299         count_use[wID] = 0;
 300         js.x = js.x*37;
 301         js.y = js.y*37;
 302         lpInfo->wXpos = js.x;   /* FIXME: perhaps multiply it somehow ? */
 303         lpInfo->wYpos = js.y;
 304         lpInfo->wZpos = 0; /* FIXME: Don't know what to do with this value as joystick driver doesn't provide a Z value */
 305         lpInfo->wButtons = js.buttons;
 306         dprintf_mmsys(stderr, "x: %d, y: %d, buttons: %d\n", js.x, js.y, js.buttons);
 307         return JOYERR_NOERROR;
 308 }
 309
 310 /**************************************************************************
 311  *                              JoyGetThreshold         [WINMM.32]
 312  */
 313 MMRESULT32 WINAPI joyGetThreshold32(UINT32 wID, LPUINT32 lpThreshold)
 314 {
 315         UINT16          thresh;
 316         MMRESULT16      ret = joyGetThreshold16(wID,&thresh);
 317
 318         *lpThreshold = thresh;
 319         return ret;
 320 }
 321
 322 /**************************************************************************
 323  *                              JoyGetThreshold         [MMSYSTEM.104]
 324  */
 325 MMRESULT16 WINAPI joyGetThreshold16(UINT16 wID, LPUINT16 lpThreshold)
 326 {
 327     dprintf_mmsys(stderr, "JoyGetThreshold(%04X, %p);\n", wID, lpThreshold);
 328     if (wID > 3) return JOYERR_PARMS;
 329     *lpThreshold = joy_threshold[wID];
 330     return JOYERR_NOERROR;
 331 }
 332
 333 /**************************************************************************
 334  *                              JoyReleaseCapture       [WINMM.33]
 335  */
 336 MMRESULT32 WINAPI joyReleaseCapture32(UINT32 wID)
 337 {
 338         return joyReleaseCapture16(wID);
 339 }
 340
 341 /**************************************************************************
 342  *                              JoyReleaseCapture       [MMSYSTEM.105]
 343  */
 344 MMRESULT16 WINAPI joyReleaseCapture16(UINT16 wID)
 345 {
 346     dprintf_mmsys(stderr, "JoyReleaseCapture(%04X);\n", wID);
 347     joyCaptured = FALSE;
 348     joyCloseDriver(wID);
 349     joy_dev[wID] = -1;
 350     CaptureWnd[wID] = 0;
 351     return JOYERR_NOERROR;
 352 }
 353
 354 /**************************************************************************
 355  *                              JoySetCapture           [MMSYSTEM.106]
 356  */
 357 MMRESULT32 WINAPI joySetCapture32(HWND32 hWnd,UINT32 wID,UINT32 wPeriod,BOOL32 bChanged)
 358 {
 359         return joySetCapture16(hWnd,wID,wPeriod,bChanged);
 360 }
 361
 362 /**************************************************************************
 363  *                              JoySetCapture           [MMSYSTEM.106]
 364  */
 365 MMRESULT16 WINAPI joySetCapture16(HWND16 hWnd,UINT16 wID,UINT16 wPeriod,BOOL16 bChanged)
 366 {
 367
 368     dprintf_mmsys(stderr, "JoySetCapture(%04X, %04X, %d, %d);\n",
 369             hWnd, wID, wPeriod, bChanged);
 370
 371     if (!CaptureWnd[wID]) {
 372         if (joyOpenDriver(wID) == FALSE) return MMSYSERR_NODRIVER;
 373         joyCaptured = TRUE;
 374         CaptureWnd[wID] = hWnd;
 375         return JOYERR_NOERROR;
 376     }
 377     else
 378     return JOYERR_NOCANDO; /* FIXME: what should be returned ? */
 379 }
 380
 381 /**************************************************************************
 382  *                              JoySetThreshold         [WINMM.35]
 383  */
 384 MMRESULT32 WINAPI joySetThreshold32(UINT32 wID, UINT32 wThreshold)
 385 {
 386         return joySetThreshold16(wID,wThreshold);
 387 }
 388 /**************************************************************************
 389  *                              JoySetThreshold         [MMSYSTEM.107]
 390  */
 391 MMRESULT16 WINAPI joySetThreshold16(UINT16 wID, UINT16 wThreshold)
 392 {
 393     dprintf_mmsys(stderr, "JoySetThreshold(%04X, %d);\n", wID, wThreshold);
 394
 395     if (wID > 3) return JOYERR_PARMS;
 396     joy_threshold[wID] = wThreshold;
 397     return JOYERR_NOERROR;
 398 }
 399
 400 /**************************************************************************
 401  *                              JoySetCalibration       [MMSYSTEM.109]
 402  */
 403 MMRESULT16 WINAPI joySetCalibration16(UINT16 wID)
 404 {
 405     fprintf(stderr, "EMPTY STUB !!! joySetCalibration(%04X);\n", wID);
 406     return JOYERR_NOCANDO;
 407 }