rom/devs/gameport/gameport.c

   1 /*
   2     Copyright © 1995-2010, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Gameport device
   6     Lang: English
   7 */
   8
   9 /* NOTE: Currently, only mice are supported */
  10
  11 /****************************************************************************************/
  12
  13 #include <exec/interrupts.h>
  14 #include <exec/initializers.h>
  15 #include <hardware/intbits.h>
  16 #include <devices/inputevent.h>
  17 #include <devices/gameport.h>
  18 #include <devices/newstyle.h>
  19 #include <devices/rawkeycodes.h>
  20 #include <proto/exec.h>
  21 #include <proto/dos.h>
  22 #include <proto/oop.h>
  23 #include <exec/memory.h>
  24 #include <exec/errors.h>
  25 #include <exec/lists.h>
  26 #include <oop/oop.h>
  27 #include <utility/utility.h>
  28 #include <hidd/mouse.h>
  29 #include <aros/libcall.h>
  30 #include <aros/asmcall.h>
  31 #include <aros/symbolsets.h>
  32 #include "gameport_intern.h"
  33
  34 #ifdef  __GNUC__
  35 #include "gameport_gcc.h"
  36 #endif
  37
  38 #define DEBUG 0
  39 #include <aros/debug.h>
  40
  41 #include LC_LIBDEFS_FILE
  42
  43 /****************************************************************************************/
  44
  45 #define NEWSTYLE_DEVICE 1
  46 #define ALIGN_IS_EVIL   1
  47
  48 #define ioStd(x)        ((struct IOStdReq *)x)
  49 #define gpUn            ((struct GPUnit *)(ioreq->io_Unit))
  50
  51 #define min(a,b)        ((a) < (b)) ? (a) : (b)
  52 #define ABS(a)          ((a) >= 0) ? (a) : (-(a))
  53 #define ALIGN(x)        ((((x) + (__AROS_STRUCTURE_ALIGNMENT - 1)) / \
  54                         __AROS_STRUCTURE_ALIGNMENT) * __AROS_STRUCTURE_ALIGNMENT)
  55
  56 #if ALIGN_IS_EVIL
  57
  58 #define NUM_INPUTEVENTS(bytesize) ((bytesize) / sizeof(struct InputEvent))
  59 #define NEXT_INPUTEVENT(event)    (((struct InputEvent *)(event)) + 1)
  60
  61 #else
  62
  63 /* Number of InputEvents we can store in io_Data */
  64 /* be careful, the io_Length might be the size of the InputEvent structure,
  65    but it can be that the ALIGN() returns a larger size and then nEvents would
  66    be 0.
  67  */
  68
  69 #define NUM_INPUTEVENTS(bytesize) (((bytesize) == sizeof(struct InputEvent)) ? \
  70                                    1 : (bytesize) / ALIGN(sizeof(struct InputEvent)))
  71 #define NEXT_INPUTEVENT(event)    ((struct InputEvent *)((UBYTE*)(event) + \
  72                                    ALIGN(sizeof(struct InputEvent))))
  73
  74 #endif /* ALIGN_IS_EVIL */
  75
  76 #define IECODE_DUMMY_WHEEL 0xFE
  77
  78 /****************************************************************************************/
  79
  80 #if NEWSTYLE_DEVICE
  81
  82 static const UWORD SupportedCommands[] =
  83 {
  84     CMD_CLEAR,
  85     GPD_ASKCTYPE,
  86     GPD_SETCTYPE,
  87     GPD_ASKTRIGGER,
  88     GPD_SETTRIGGER,
  89     GPD_READEVENT,
  90     NSCMD_DEVICEQUERY,
  91     0
  92 };
  93
  94 #endif
  95
  96 /****************************************************************************************/
  97
  98 static BOOL fillrequest(struct IORequest *ioreq, BOOL *trigged, struct GameportBase *GPBase);
  99 static VOID mouseCallback(struct GameportBase *GPBase,
 100                           struct pHidd_Mouse_ExtEvent *ev);
 101 static AROS_INTP(gpSendQueuedEvents);
 102
 103
 104 /****************************************************************************************/
 105
 106 /* 'data' is a pointer to GPBase->gp_nTicks. */
 107
 108 AROS_INTH1(gpVBlank, LIBBASETYPEPTR, GPBase)
 109 {
 110     AROS_INTFUNC_INIT
 111
 112     if (GPBase->gp_nTicks < ~0)
 113     {
 114         GPBase->gp_nTicks++;
 115     }
 116
 117     return 0;
 118
 119     AROS_INTFUNC_EXIT
 120 }
 121
 122 static int GM_UNIQUENAME(init)(LIBBASETYPEPTR GPBase)
 123 {
 124     int i;
 125
 126     /* reset static data */
 127     HiddMouseAB = 0;
 128
 129     for(i = 0; i < GP_NUNITS; i++)
 130     {
 131         GPBase->gp_cTypes[i] = GPCT_NOCONTROLLER;
 132     }
 133
 134     InitSemaphore(&GPBase->gp_QueueLock);
 135     InitSemaphore(&GPBase->gp_Lock);
 136     NEWLIST(&GPBase->gp_PendingQueue);
 137
 138     GPBase->gp_Interrupt.is_Node.ln_Type = NT_INTERRUPT;
 139     GPBase->gp_Interrupt.is_Node.ln_Pri  = 0;
 140     GPBase->gp_Interrupt.is_Data         = (APTR)GPBase;
 141     GPBase->gp_Interrupt.is_Code         = (VOID_FUNC)gpSendQueuedEvents;
 142
 143     GPBase->gp_VBlank.is_Code         = (VOID_FUNC)gpVBlank;
 144     GPBase->gp_VBlank.is_Data         = GPBase;
 145     GPBase->gp_VBlank.is_Node.ln_Name = "Gameport VBlank server";
 146     GPBase->gp_VBlank.is_Node.ln_Pri  = 0;
 147     GPBase->gp_VBlank.is_Node.ln_Type = NT_INTERRUPT;
 148
 149     /* Add a VBLANK server to take care of event timing. */
 150     AddIntServer(INTB_VERTB, &GPBase->gp_VBlank);
 151
 152     return TRUE;
 153 }
 154
 155 /****************************************************************************************/
 156
 157 static int GM_UNIQUENAME(open)
 158 (
 159     LIBBASETYPEPTR GPBase,
 160     struct IORequest *ioreq,
 161     ULONG unitnum,
 162     ULONG flags
 163 )
 164 {
 165     struct Library *OOPBase;
 166
 167     /* Erroneous unit? */
 168     if (unitnum > GP_MAXUNIT)
 169     {
 170         ioreq->io_Error = IOERR_OPENFAIL;
 171
 172         return FALSE;
 173     }
 174
 175     if (ioreq->io_Message.mn_Length < sizeof(struct IOStdReq))
 176     {
 177         D(bug("gameport.device/open: IORequest structure passed to OpenDevice "
 178               "is too small!\n"));
 179         ioreq->io_Error = IOERR_OPENFAIL;
 180
 181         return FALSE;
 182     }
 183
 184     if (GPBase->gp_eventBuffer == NULL)
 185     {
 186         GPBase->gp_eventBuffer = AllocMem(sizeof(UWORD) * GP_BUFFERSIZE,
 187                                           MEMF_ANY);
 188     }
 189
 190     /* No memory for key buffer? */
 191     if (GPBase->gp_eventBuffer == NULL)
 192     {
 193         ioreq->io_Error = IOERR_OPENFAIL;
 194
 195         return FALSE;
 196     }
 197
 198     if ((ioreq->io_Unit = AllocMem(sizeof(GPUnit), MEMF_CLEAR)) == NULL)
 199     {
 200         ioreq->io_Error = IOERR_OPENFAIL;
 201
 202         return FALSE;
 203     }
 204
 205     gpUn->gpu_unitNum = unitnum;
 206
 207     OOPBase = OpenLibrary("oop.library", 0);
 208     if (!OOPBase) {
 209         ioreq->io_Error = IOERR_OPENFAIL;
 210         return FALSE;
 211     }
 212
 213     if (!HiddMouseAB)
 214     {
 215         HiddMouseAB = OOP_ObtainAttrBase(IID_Hidd_Mouse);
 216
 217         if (!HiddMouseAB)
 218         {
 219             ioreq->io_Error = IOERR_OPENFAIL;
 220             CloseLibrary(OOPBase);
 221             D(bug("gameport.device: Could not get attrbase\n"));
 222
 223             return FALSE;
 224         }
 225     }
 226
 227     D(bug("gameport.device: Attrbase: %x\n", HiddMouseAB));
 228
 229 /******* nlorentz: End of stuff added by me ********/
 230
 231     if(!GPBase->gp_MouseHiddBase)
 232     {
 233         GPBase->gp_MouseHiddBase = OpenLibrary("mouse.hidd", 0);
 234
 235         /* Install our own keyboard handler if opened for the first time */
 236         if(GPBase->gp_MouseHiddBase) {
 237             struct TagItem tags[] = {
 238                 { aHidd_Mouse_IrqHandler    , (IPTR)mouseCallback},
 239                 { aHidd_Mouse_IrqHandlerData, (IPTR)GPBase       },
 240                 { TAG_DONE                                       }
 241             };
 242
 243             GPBase->gp_Hidd = OOP_NewObject(NULL, CLID_Hidd_Mouse, tags);
 244             D(bug("keyboard.device: keyboard HIDD object 0x%p\n", GPBase->gp_Hidd));
 245             if(!GPBase->gp_Hidd)
 246             {
 247                 CloseLibrary(GPBase->gp_MouseHiddBase);
 248                 GPBase->gp_MouseHiddBase = NULL; /* Do cleanup below. */
 249             }
 250         }
 251
 252     }
 253     CloseLibrary(OOPBase);
 254
 255     if(!GPBase->gp_MouseHiddBase)
 256     {
 257         ioreq->io_Error = IOERR_OPENFAIL;
 258         return FALSE;
 259         /* TODO: Clean up. */
 260     }
 261
 262     return TRUE;
 263 }
 264
 265 /****************************************************************************************/
 266
 267 static int GM_UNIQUENAME(close)
 268 (
 269     LIBBASETYPEPTR GPBase,
 270     struct IORequest *ioreq
 271 )
 272 {
 273     FreeMem(ioreq->io_Unit, sizeof(GPUnit));
 274
 275     return TRUE;
 276 }
 277
 278 /****************************************************************************************/
 279
 280 ADD2INITLIB(GM_UNIQUENAME(init),0)
 281 ADD2OPENDEV(GM_UNIQUENAME(open),0)
 282 ADD2CLOSEDEV(GM_UNIQUENAME(close),0)
 283
 284 /****************************************************************************************/
 285
 286 AROS_LH1(void, beginio,
 287  AROS_LHA(struct IORequest *, ioreq, A1),
 288            struct GameportBase *, GPBase, 5, Gameport)
 289 {
 290     AROS_LIBFUNC_INIT
 291
 292     BOOL request_queued = FALSE;
 293
 294     D(bug("gpd: beginio(ioreq=%p, cmd=%d)\n", ioreq, ioreq->io_Command));
 295
 296     /* WaitIO will look into this */
 297     ioreq->io_Message.mn_Node.ln_Type = NT_MESSAGE;
 298     ioreq->io_Error = 0;
 299
 300     switch (ioreq->io_Command)
 301     {
 302 #if NEWSTYLE_DEVICE
 303     case NSCMD_DEVICEQUERY:
 304         if(ioStd(ioreq)->io_Length < ((LONG)OFFSET(NSDeviceQueryResult, SupportedCommands)) + sizeof(UWORD *))
 305         {
 306             ioreq->io_Error = IOERR_BADLENGTH;
 307         }
 308         else
 309         {
 310             struct NSDeviceQueryResult *d;
 311
 312             d = (struct NSDeviceQueryResult *)ioStd(ioreq)->io_Data;
 313
 314             d->DevQueryFormat    = 0;
 315             d->SizeAvailable     = sizeof(struct NSDeviceQueryResult);
 316             d->DeviceType        = NSDEVTYPE_GAMEPORT;
 317             d->DeviceSubType     = 0;
 318             d->SupportedCommands = (UWORD *)SupportedCommands;
 319
 320             ioStd(ioreq)->io_Actual   = sizeof(struct NSDeviceQueryResult);
 321         }
 322         break;
 323 #endif
 324
 325     case CMD_CLEAR:
 326         gpUn->gpu_readPos = GPBase->gp_writePos;
 327         break;
 328
 329     case GPD_ASKCTYPE:
 330         if (ioStd(ioreq)->io_Length < sizeof(UBYTE))
 331         {
 332             ioreq->io_Error = IOERR_BADLENGTH;
 333             break;
 334         }
 335
 336         ObtainSemaphoreShared(&GPBase->gp_Lock);
 337         *((UBYTE *)(ioStd(ioreq)->io_Data)) = (GPBase->gp_cTypes)[gpUn->gpu_unitNum];
 338         ReleaseSemaphore(&GPBase->gp_Lock);
 339         break;
 340
 341     case GPD_SETCTYPE:
 342         if (ioStd(ioreq)->io_Length != sizeof(UBYTE))
 343         {
 344             ioreq->io_Error = IOERR_BADLENGTH;
 345             break;
 346         }
 347
 348         ObtainSemaphore(&GPBase->gp_Lock);
 349         (GPBase->gp_cTypes)[gpUn->gpu_unitNum] = *((UBYTE *)(ioStd(ioreq)->io_Data));
 350         ReleaseSemaphore(&GPBase->gp_Lock);
 351         break;
 352
 353     case GPD_ASKTRIGGER:
 354         if (ioStd(ioreq)->io_Length != sizeof(struct GamePortTrigger))
 355         {
 356             ioreq->io_Error = IOERR_BADLENGTH;
 357             break;
 358         }
 359
 360         *((struct GamePortTrigger *)(ioStd(ioreq)->io_Data)) = gpUn->gpu_trigger;
 361         break;
 362
 363     case GPD_SETTRIGGER:
 364         if (ioStd(ioreq)->io_Length != sizeof(struct GamePortTrigger))
 365         {
 366             ioreq->io_Error = IOERR_BADLENGTH;
 367             break;
 368         }
 369
 370         gpUn->gpu_trigger = *((struct GamePortTrigger *)(ioStd(ioreq)->io_Data));
 371         break;
 372
 373     case GPD_READEVENT:
 374     #if 0
 375         if(((IPTR)(&(ioStd(ioreq)->io_Data)) & (__AROS_STRUCTURE_ALIGNMENT - 1)) != 0)
 376         {
 377             D(bug("gpd: Bad address\n"));
 378             ioreq->io_Error = IOERR_BADADDRESS;
 379             break;
 380         }
 381     #endif
 382
 383         D(bug("gpd: Readpos: %d, Writepos: %d\n", gpUn->gpu_readPos,
 384               GPBase->gp_writePos));
 385
 386         /* We queue the request if there are no events in the queue or if
 387            the unit didn't trig on the events thate were in the queue. */
 388
 389         Disable(); /* !! */
 390
 391         if (gpUn->gpu_readPos == GPBase->gp_writePos)
 392         {
 393             request_queued = TRUE;
 394         }
 395         else
 396         {
 397             BOOL trigged;
 398
 399             fillrequest(ioreq, &trigged, GPBase);
 400
 401             if (!trigged)
 402             {
 403                 request_queued = TRUE;
 404             }
 405         }
 406
 407         if (request_queued)
 408         {
 409             ioreq->io_Flags &= ~IOF_QUICK;
 410
 411             D(bug("gpd: No mouse events, putting request in queue\n"));
 412
 413             gpUn->gpu_flags |= GBUF_PENDING;
 414             AddTail((struct List *)&GPBase->gp_PendingQueue,
 415                     (struct Node *)ioreq);
 416         }
 417
 418         Enable();
 419
 420         break;
 421
 422     default:
 423         ioreq->io_Error = IOERR_NOCMD;
 424         break;
 425
 426     } /* switch (ioreq->io_Command) */
 427
 428     /* If the quick bit is not set, send the message to the port */
 429     if (!(ioreq->io_Flags & IOF_QUICK) && !request_queued)
 430     {
 431         ReplyMsg(&ioreq->io_Message);
 432     }
 433
 434     AROS_LIBFUNC_EXIT
 435 }
 436
 437 /******************************************************************************/
 438
 439
 440 AROS_LH1(LONG, abortio,
 441  AROS_LHA(struct IORequest *,    ioreq,  A1),
 442           struct GameportBase *, GPBase, 6,  Gameport)
 443 {
 444     AROS_LIBFUNC_INIT
 445
 446     LONG ret = -1;
 447
 448     Disable();
 449
 450     if (gpUn->gpu_flags & GBUF_PENDING)
 451     {
 452         if (ioreq->io_Message.mn_Node.ln_Type == NT_MESSAGE)
 453         {
 454             Remove((struct Node *)ioreq);
 455             ReplyMsg(&ioreq->io_Message);
 456
 457             ioreq->io_Error = IOERR_ABORTED;
 458
 459             if (IsListEmpty(&GPBase->gp_PendingQueue))
 460             {
 461                 gpUn->gpu_flags &= ~GBUF_PENDING;
 462             }
 463
 464             ret = 0;
 465         }
 466     }
 467
 468     Enable();
 469
 470     return ret;
 471
 472     AROS_LIBFUNC_EXIT
 473 }
 474
 475 /****************************************************************************************/
 476
 477 static VOID mouseCallback(struct GameportBase *GPBase,
 478                           struct pHidd_Mouse_ExtEvent *ev)
 479 {
 480     UWORD amigacode = 0;
 481
 482     D(bug("mouseCallBack(GPBase=%p, button=%d, x=%d, y=%d, type=%d, flags=0x%04X)\n",
 483           GPBase, ev->button, ev->x, ev->y, ev->type, ev->flags));
 484
 485     /* Convert the event */
 486     switch (ev->button)
 487     {
 488         case vHidd_Mouse_Button1:
 489             amigacode = IECODE_LBUTTON;
 490             break;
 491
 492         case vHidd_Mouse_Button2:
 493             amigacode = IECODE_RBUTTON;
 494             break;
 495
 496         case vHidd_Mouse_Button3:
 497             amigacode = IECODE_MBUTTON;
 498             break;
 499     }
 500
 501     switch (ev->type)
 502     {
 503         case vHidd_Mouse_Release:
 504             amigacode |= IECODE_UP_PREFIX;
 505             break;
 506
 507         case vHidd_Mouse_Motion:
 508             amigacode = IECODE_NOBUTTON;
 509             break;
 510
 511         case vHidd_Mouse_WheelMotion:
 512             amigacode = IECODE_DUMMY_WHEEL;
 513             break;
 514     }
 515
 516     Disable();
 517
 518     GPBase->gp_eventBuffer[GPBase->gp_writePos++] = amigacode;
 519     GPBase->gp_eventBuffer[GPBase->gp_writePos++] = ev->x;
 520     GPBase->gp_eventBuffer[GPBase->gp_writePos++] = ev->y;
 521     GPBase->gp_eventBuffer[GPBase->gp_writePos++] = ev->flags;
 522
 523     D(bug("Wrote to buffer\n"));
 524
 525     if (GPBase->gp_writePos == GP_NUMELEMENTS)
 526     {
 527         GPBase->gp_writePos = 0;
 528     }
 529
 530
 531     if (!IsListEmpty(&GPBase->gp_PendingQueue))
 532     {
 533 #if 0
 534         D(bug("doing software irq, node type=%d\n", GPBase->gp_Interrupt.is_Node.ln_Type));
 535         Cause(&GPBase->gp_Interrupt);
 536 #else
 537     AROS_INTC1(gpSendQueuedEvents, GPBase);
 538 #endif
 539     }
 540
 541     Enable();
 542 }
 543
 544 /****************************************************************************************/
 545
 546 /* nlorentz: Software interrupt to be called when keys are received
 547 Copied and pasted from the function above */
 548
 549 #undef SysBase
 550
 551 static AROS_INTH1(gpSendQueuedEvents, struct GameportBase *, GPBase)
 552 {
 553     AROS_INTFUNC_INIT
 554
 555     /* Broadcast keys */
 556     struct IORequest    *ioreq, *nextnode;
 557     struct List         *pendingList;
 558
 559     pendingList = (struct List *)&GPBase->gp_PendingQueue;
 560
 561     D(bug("Inside software irq\n"));
 562
 563     ForeachNodeSafe(pendingList, ioreq, nextnode)
 564     {
 565         BOOL moreevents, trigged;
 566
 567         D(bug("Replying msg\n"));
 568         moreevents = fillrequest(ioreq, &trigged, GPBase);
 569
 570         if (trigged)
 571         {
 572             Remove((struct Node *)ioreq);
 573             ReplyMsg((struct Message *)&ioreq->io_Message);
 574         }
 575
 576         if (!moreevents)
 577         {
 578             break;
 579         }
 580     }
 581
 582     if (IsListEmpty(pendingList))
 583     {
 584         gpUn->gpu_flags &= ~GBUF_PENDING;
 585     }
 586
 587     return 0;
 588
 589     AROS_INTFUNC_EXIT
 590 }
 591
 592 /****************************************************************************************/
 593
 594 /* When this function is called, there *must* be at least one event ready for
 595    processing. It returns TRUE as long as there are more events to preocess */
 596
 597 static BOOL fillrequest(struct IORequest *ioreq, BOOL *trigged,
 598                         struct GameportBase *GPBase)
 599 {
 600     BOOL   moreevents = TRUE;
 601     BOOL   down, up, wheel;
 602     int    i;                        /* Loop variable */
 603     int    nEvents;                  /* Number of struct InputEvent that there
 604                                         is room for in memory pointed to by
 605                                         io_Data */
 606     struct InputEvent *event;        /* Temporary variable */
 607
 608     *trigged = FALSE;
 609
 610     nEvents = NUM_INPUTEVENTS(ioStd(ioreq)->io_Length);
 611
 612     if (nEvents == 0)
 613     {
 614         ioreq->io_Error = IOERR_BADLENGTH;
 615         D(bug("gpd: Bad length\n"));
 616
 617         return TRUE;
 618     }
 619
 620     event = (struct InputEvent *)(ioStd(ioreq)->io_Data);
 621
 622     ioreq->io_Error = 0;
 623
 624     for (i = 0; i < nEvents; ) /* no i++ here, this is done if event is to report */
 625     {
 626         UWORD code;
 627         WORD  x;
 628         WORD  y;
 629         WORD  flags;
 630
 631         code = GPBase->gp_eventBuffer[gpUn->gpu_readPos++];
 632         x = GPBase->gp_eventBuffer[gpUn->gpu_readPos++];
 633         y = GPBase->gp_eventBuffer[gpUn->gpu_readPos++];
 634         flags = GPBase->gp_eventBuffer[gpUn->gpu_readPos++];
 635
 636         down = up = wheel = FALSE;      /* Reset states */
 637
 638         /* Take care of the qualifiers */
 639         switch (code)
 640         {
 641             case IECODE_LBUTTON:
 642                 gpUn->gpu_Qualifiers |= IEQUALIFIER_LEFTBUTTON;
 643                 down = TRUE;
 644                 break;
 645
 646             case IECODE_LBUTTON | IECODE_UP_PREFIX:
 647                 gpUn->gpu_Qualifiers &= ~IEQUALIFIER_LEFTBUTTON;
 648                 up = TRUE;
 649                 break;
 650
 651             case IECODE_MBUTTON:
 652                 gpUn->gpu_Qualifiers |= IEQUALIFIER_MIDBUTTON;
 653                 down = TRUE;
 654                 break;
 655
 656             case IECODE_MBUTTON | IECODE_UP_PREFIX:
 657                 gpUn->gpu_Qualifiers &= ~IEQUALIFIER_MIDBUTTON;
 658                 up = TRUE;
 659                 break;
 660
 661             case IECODE_RBUTTON:
 662                 gpUn->gpu_Qualifiers |= IEQUALIFIER_RBUTTON;
 663                 down = TRUE;
 664                 break;
 665
 666             case IECODE_RBUTTON | IECODE_UP_PREFIX:
 667                 gpUn->gpu_Qualifiers &= ~IEQUALIFIER_RBUTTON;
 668                 up = TRUE;
 669                 break;
 670
 671             case IECODE_DUMMY_WHEEL:
 672                 wheel = TRUE;
 673                 if (y < 0)
 674                 {
 675                     code = RAWKEY_NM_WHEEL_UP;
 676                 }
 677                 else if (y > 0)
 678                 {
 679                     code = RAWKEY_NM_WHEEL_DOWN;
 680                 }
 681                 else if (x < 0)
 682                 {
 683                     code = RAWKEY_NM_WHEEL_LEFT;
 684                 }
 685                 else if (x > 0)
 686                 {
 687                     code = RAWKEY_NM_WHEEL_RIGHT;
 688                 }
 689                 else
 690                 {
 691                     wheel = FALSE;
 692                 }
 693                 x = y = 0;
 694                 break;
 695         }
 696
 697         if (gpUn->gpu_readPos == GP_NUMELEMENTS)
 698         {
 699             gpUn->gpu_readPos = 0;
 700         }
 701
 702         D(bug("gpd: Adding event of code %d\n", code));
 703
 704 #if 0
 705
 706 #warning This needs to be fixed. And needs different handling, depending on whether coords are relative (x86-native) or not (x86-linux)!!!!
 707
 708
 709         /* Should we report this event? */
 710         if((down && (gpUn->gpu_trigger.gpt_Keys & GPTF_DOWNKEYS)) ||
 711            (up   && (gpUn->gpu_trigger.gpt_Keys & GPTF_UPKEYS))   ||
 712            (ABS(gpUn->gpu_lastX - x) > gpUn->gpu_trigger.gpt_XDelta) ||
 713            (ABS(gpUn->gpu_lastY - y) > gpUn->gpu_trigger.gpt_YDelta) ||
 714            (GPBase->gp_nTicks > gpUn->gpu_trigger.gpt_Timeout) ||
 715            (wheel))
 716 #else
 717         (void)(wheel); /* This is unused */
 718         (void)(down);  /* This is unused */
 719 #endif
 720
 721         {
 722             i++;
 723
 724             if (*trigged == TRUE)
 725             {
 726                 event = event->ie_NextEvent;
 727             }
 728             else
 729             {
 730                 *trigged = TRUE;
 731             }
 732
 733             event->ie_Class     = (wheel ? IECLASS_NEWMOUSE : IECLASS_RAWMOUSE);
 734             event->ie_SubClass  = 0;          /* Only port 0 for now */
 735             event->ie_Code      = code;
 736             event->ie_Qualifier = gpUn->gpu_Qualifiers;
 737             if (flags & vHidd_Mouse_Relative) event->ie_Qualifier |= IEQUALIFIER_RELATIVEMOUSE;
 738
 739             event->ie_X = x;
 740             event->ie_Y = y;
 741
 742             gpUn->gpu_lastX = x;
 743             gpUn->gpu_lastY = y;
 744
 745             event->ie_TimeStamp.tv_secs = GPBase->gp_nTicks;
 746             event->ie_TimeStamp.tv_micro = 0;
 747
 748             /* Reset frame delta counter */
 749             GPBase->gp_nTicks = 0;
 750
 751
 752             event->ie_NextEvent = NEXT_INPUTEVENT(event);
 753         }
 754
 755         /* No more keys in buffer? */
 756         if (gpUn->gpu_readPos == GPBase->gp_writePos)
 757         {
 758             moreevents = FALSE;
 759             break;
 760         }
 761     }
 762
 763     event->ie_NextEvent = NULL;
 764
 765     return moreevents;
 766 }
 767
 768 /****************************************************************************************/
 769
 770 static const char end = 0;
 771
 772 /****************************************************************************************/