rom/devs/input/processevents.c

   1 /*
   2     Copyright © 1995-2010, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: english
   7 */
   8
   9 #include <proto/exec.h>
  10 #include <proto/timer.h>
  11 #include <proto/graphics.h>
  12
  13 #include <exec/lists.h>
  14 #include <exec/interrupts.h>
  15 #include <exec/alerts.h>
  16 #include <exec/memory.h>
  17 #include <devices/inputevent.h>
  18 #include <devices/input.h>
  19 #include <devices/timer.h>
  20 #include <devices/keyboard.h>
  21 #include <devices/gameport.h>
  22 #include <intuition/intuition.h>
  23 #include <aros/asmcall.h>
  24
  25 #include "input_intern.h"
  26
  27 #define SEND_INPUT_REQUEST(io, ie, cmd) \
  28     io->io_Command = cmd;                       \
  29     io->io_Data = (APTR)ie;                     \
  30     io->io_Length = sizeof (struct InputEvent); \
  31     SendIO((struct IORequest *)io)
  32
  33
  34 #define SEND_KBD_REQUEST(kbdio, kbdie)  SEND_INPUT_REQUEST(kbdio, kbdie, KBD_READEVENT)
  35 #define SEND_GPD_REQUEST(gpdio, gpdie) SEND_INPUT_REQUEST(gpdio, gpdie, GPD_READEVENT)
  36
  37 #define SEND_TIMER_REQUEST(timerio)                     \
  38         timerio->tr_node.io_Command = TR_ADDREQUEST;    \
  39         timerio->tr_time.tv_secs = 0;                   \
  40         timerio->tr_time.tv_micro = 100000;             \
  41         SendIO((struct IORequest *)timerio)
  42
  43 #define SEND_KEYTIMER_REQUEST(timerio,time)             \
  44         timerio->tr_node.io_Command = TR_ADDREQUEST;    \
  45         timerio->tr_time = time;                        \
  46         SendIO((struct IORequest *)timerio)
  47
  48 #define ABORT_KEYTIMER_REQUEST \
  49         if (!CheckIO(&keytimerio->tr_node)) AbortIO(&keytimerio->tr_node); \
  50         WaitIO(&keytimerio->tr_node); \
  51         SetSignal(0, keytimersig);
  52
  53 #define KEY_QUALIFIERS (IEQUALIFIER_LSHIFT     | IEQUALIFIER_RSHIFT   | \
  54                         IEQUALIFIER_CAPSLOCK   | IEQUALIFIER_CONTROL  | \
  55                         IEQUALIFIER_RALT       | IEQUALIFIER_LALT     | \
  56                         IEQUALIFIER_RCOMMAND   | IEQUALIFIER_RCOMMAND | \
  57                         IEQUALIFIER_NUMERICPAD /* | IEQUALIFIER_REPEAT */)
  58
  59 #define MOUSE_QUALIFIERS (IEQUALIFIER_LEFTBUTTON | IEQUALIFIER_RBUTTON | \
  60                           IEQUALIFIER_MIDBUTTON)
  61
  62
  63 #define DEBUG 0
  64 #include <aros/debug.h>
  65
  66 AROS_UFH3S(void, ResetHandler,
  67     AROS_UFHA(struct inputbase *, InputDevice, A1),
  68     AROS_UFHA(APTR, code, A5),
  69     AROS_UFHA(struct ExecBase *, sysBase, A6))
  70 {
  71     AROS_USERFUNC_INIT
  72
  73     if (InputDevice->ResetSig)
  74     {
  75         Signal(InputDevice->InputTask, InputDevice->ResetSig);
  76     }
  77
  78     AROS_USERFUNC_EXIT
  79 }
  80
  81 /**********************
  82 **  ForwardEvents()  **
  83 **********************/
  84 /* Forwards a chain of events to the inputhandlers */
  85 VOID ForwardQueuedEvents(struct inputbase *InputDevice)
  86 {
  87    struct InputEvent *ie_chain;
  88    struct Interrupt *ihiterator;
  89
  90    ie_chain = GetEventsFromQueue(InputDevice);
  91    if (ie_chain)
  92    {
  93         ForeachNode(&(InputDevice->HandlerList), ihiterator)
  94         {
  95             D(bug("ipe: calling inputhandler %s at %p\n",
  96                         ihiterator->is_Node.ln_Name, ihiterator->is_Code));
  97
  98             ie_chain = AROS_UFC2(struct InputEvent *, ihiterator->is_Code,
  99                     AROS_UFCA(struct InputEvent *,  ie_chain,               A0),
 100                     AROS_UFCA(APTR,                 ihiterator->is_Data,    A1));
 101
 102             D(bug("ipe: returned from inputhandler\n"));
 103
 104         } /* for each input handler */
 105
 106     }
 107
 108     return;
 109 }
 110
 111
 112 /***********************************
 113 ** Input device task entry point  **
 114 ***********************************/
 115 void ProcessEvents (struct inputbase *InputDevice)
 116 {
 117     ULONG                    commandsig, kbdsig, wakeupsigs;
 118     ULONG                    gpdsig, timersig, keytimersig;
 119     struct MsgPort          *timermp, *keytimermp;
 120     struct timerequest      *timerio, *keytimerio;
 121
 122     struct MsgPort          *kbdmp, *gpdmp;
 123     struct IOStdReq         *kbdio, *gpdio;
 124     struct InputEvent       *kbdie, *gpdie, keyrepeatie;
 125     struct Interrupt        resethandler;
 126     struct Library          *TimerBase;
 127
 128     struct GamePortTrigger  mouseTrigger =
 129     {
 130         GPTF_DOWNKEYS | GPTF_UPKEYS,
 131         9999,                   /* We dont really care about time triggers */
 132         0,                      /* Report any mouse change */
 133         0
 134     };
 135
 136     BYTE                    controllerType = GPCT_MOUSE;
 137     BYTE                    keyrepeat_state = 0;
 138
 139     /************** Open timer.device *******************/
 140
 141     timermp    = CreateMsgPort();
 142     keytimermp = CreateMsgPort();
 143
 144     if (!timermp || !keytimermp)
 145         Alert(AT_DeadEnd | AG_NoMemory | AN_Unknown);
 146
 147     timerio    = (struct timerequest *)CreateIORequest(timermp   , sizeof(struct timerequest));
 148     keytimerio = (struct timerequest *)CreateIORequest(keytimermp, sizeof(struct timerequest));
 149     if (!timerio || !keytimerio)
 150         Alert(AT_DeadEnd | AG_NoMemory | AN_Unknown);
 151
 152     if ( 0 != OpenDevice(TIMERNAME, UNIT_VBLANK, (struct IORequest *)timerio, 0))
 153         Alert(AT_DeadEnd | AG_OpenDev | AN_Unknown);
 154
 155     TimerBase = (struct Library *)timerio->tr_node.io_Device;
 156
 157     *keytimerio = *timerio;
 158     keytimerio->tr_node.io_Message.mn_ReplyPort = keytimermp;
 159
 160     /************** Open keyboard.device *******************/
 161     kbdmp = CreateMsgPort();
 162     if (!kbdmp)
 163         Alert(AT_DeadEnd | AG_NoMemory | AN_Unknown);
 164
 165     kbdio = (struct IOStdReq *)CreateIORequest(kbdmp, sizeof(struct IOStdReq));
 166     if (!kbdio)
 167         Alert(AT_DeadEnd | AG_NoMemory | AN_Unknown);
 168
 169     if ( 0 != OpenDevice("keyboard.device", 0, (struct IORequest *)kbdio, 0))
 170         Alert(AT_DeadEnd | AG_OpenDev | AN_Unknown);
 171
 172     /* Install RESET Handler */
 173
 174     InputDevice->ResetSig = 1L << AllocSignal(-1);
 175
 176     resethandler.is_Node.ln_Name = "input.device reset handler";
 177     resethandler.is_Node.ln_Type = NT_INTERRUPT;
 178     resethandler.is_Node.ln_Pri = -128;
 179
 180     resethandler.is_Code = (VOID (*)())ResetHandler;
 181     resethandler.is_Data = InputDevice;
 182
 183     kbdio->io_Command = KBD_ADDRESETHANDLER;
 184     kbdio->io_Data = &resethandler;
 185     DoIO((struct IORequest *)kbdio);
 186
 187     kbdie = AllocMem(sizeof (struct InputEvent), MEMF_PUBLIC | MEMF_CLEAR);
 188     if (!kbdie)
 189         Alert(AT_DeadEnd | AG_NoMemory | AN_Unknown);
 190
 191
 192     /************** Open gameport.device *******************/
 193     gpdmp = CreateMsgPort();
 194     if (!gpdmp)
 195         Alert(AT_DeadEnd | AG_NoMemory | AN_Unknown);
 196
 197     gpdio = (struct IOStdReq *)CreateIORequest(gpdmp, sizeof(struct IOStdReq));
 198     if (!gpdio)
 199         Alert(AT_DeadEnd | AG_NoMemory | AN_Unknown);
 200
 201     if ( 0 != OpenDevice("gameport.device", 0, (struct IORequest *)gpdio, 0))
 202         Alert(AT_DeadEnd | AG_OpenDev | AN_Unknown);
 203
 204     /* Set the controller type */
 205     gpdio->io_Command = GPD_SETCTYPE;
 206     gpdio->io_Data = (APTR)&controllerType;
 207     gpdio->io_Length = sizeof(BYTE);
 208     DoIO((struct IORequest *)gpdio);
 209
 210     /* Set the gameport trigger */
 211     gpdio->io_Command = GPD_SETTRIGGER;
 212     gpdio->io_Data = &mouseTrigger;
 213     gpdio->io_Length = sizeof(struct GamePortTrigger);
 214     DoIO((struct IORequest *)gpdio);
 215
 216     gpdie = AllocMem(sizeof (struct InputEvent), MEMF_PUBLIC | MEMF_CLEAR);
 217     if (!gpdie)
 218         Alert(AT_DeadEnd | AG_NoMemory | AN_Unknown);
 219
 220
 221     /* Send an initial request to the keyboard device */
 222     SEND_KBD_REQUEST(kbdio, kbdie);
 223
 224     /* .. and to the gameport.device */
 225     SEND_GPD_REQUEST(gpdio, gpdie);
 226
 227     /* .. and to the timer device */
 228     SEND_TIMER_REQUEST(timerio);
 229
 230     commandsig = 1 << InputDevice->CommandPort.mp_SigBit;
 231
 232     kbdsig      = 1 << kbdmp->mp_SigBit;
 233     gpdsig      = 1 << gpdmp->mp_SigBit;
 234     timersig    = 1 << timermp->mp_SigBit;
 235     keytimersig = 1 << keytimermp->mp_SigBit;
 236
 237     for (;;)
 238     {
 239         wakeupsigs = Wait (commandsig            |
 240                            kbdsig                |
 241                            gpdsig                |
 242                            timersig              |
 243                            keytimersig           |
 244                            InputDevice->ResetSig |
 245                            SIGBREAKF_CTRL_F);
 246
 247         D(bug("Wakeup sig: %x, cmdsig: %x, kbdsig: %x\n, timersig: %x"
 248                 , wakeupsigs, commandsig, kbdsig, timersig));
 249
 250         if (wakeupsigs & SIGBREAKF_CTRL_F)
 251         {
 252             struct InputEvent null_ie;
 253
 254             null_ie.ie_NextEvent         = NULL;
 255             null_ie.ie_Class             = IECLASS_NULL;
 256             null_ie.ie_SubClass          = 0;
 257             null_ie.ie_Code              = 0;
 258             null_ie.ie_Qualifier         = 0;
 259             null_ie.ie_position.ie_addr  = 0;
 260
 261             /* Add a timestamp to the event */
 262             GetSysTime( &(null_ie.ie_TimeStamp ));
 263             AddEQTail(&null_ie, InputDevice);
 264             ForwardQueuedEvents(InputDevice);
 265         }
 266
 267         if (wakeupsigs & timersig)
 268         {
 269             struct InputEvent timer_ie;
 270
 271             GetMsg(timermp);
 272
 273             timer_ie.ie_NextEvent        = NULL;
 274             timer_ie.ie_Class            = IECLASS_TIMER;
 275             timer_ie.ie_SubClass         = 0;
 276             timer_ie.ie_Code             = 0;
 277             timer_ie.ie_Qualifier        = InputDevice->ActQualifier;
 278             timer_ie.ie_position.ie_addr = 0;
 279
 280             /* Add a timestamp to the event */
 281             GetSysTime( &(timer_ie.ie_TimeStamp ));
 282
 283             AddEQTail(&timer_ie, InputDevice);
 284             ForwardQueuedEvents(InputDevice);
 285
 286             SEND_TIMER_REQUEST(timerio);
 287         }
 288
 289         if (wakeupsigs & commandsig)
 290         {
 291             struct IOStdReq *ioreq;
 292
 293             /* Get all commands from the port */
 294             while ((ioreq = (struct IOStdReq *)GetMsg(&InputDevice->CommandPort)))
 295             {
 296
 297                 switch (ioreq->io_Command)
 298                 {
 299                 case IND_ADDHANDLER:
 300                     Enqueue((struct List *)&(InputDevice->HandlerList),
 301                         (struct Node *)ioreq->io_Data);
 302                     break;
 303
 304                 case IND_REMHANDLER:
 305                     Remove((struct Node *)ioreq->io_Data);
 306                     break;
 307
 308                 case IND_SETMTRIG:
 309                     break;
 310
 311                 case IND_SETMTYPE:
 312                     break;
 313
 314                 case IND_ADDEVENT: {
 315                     /*
 316                      * IND_ADDEVENT command allows client to send multiple RAWKEY or RAWMOUSE
 317                      * events to the input.device. All other classes will be ignored.
 318                      */
 319                     struct InputEvent *ie = (struct InputEvent *)ioreq->io_Data;
 320                     ULONG ie_cnt = ioreq->io_Length / sizeof(struct InputEvent);
 321
 322                     D(bug("[input.device] ie_cnt=%d, ie=%d\n", ie_cnt, ie));
 323
 324                     /* Update the current qualifier */
 325                     InputDevice->ActQualifier = ie->ie_Qualifier;
 326
 327                     /* For each event... */
 328                     for (; ie_cnt; ie_cnt--, ie++)
 329                     {
 330                         D(bug("[input.device]  ie_Class=%02x ie_Code=%04x ie_Qualifier=%04x\n",
 331                             ie->ie_Class, ie->ie_Code, ie->ie_Qualifier));
 332
 333                         /* Of class RAWMOUSE or RAWKEY... */
 334                         if (ie->ie_Class == IECLASS_RAWMOUSE || ie->ie_Class == IECLASS_RAWKEY)
 335                         {
 336                             ie->ie_NextEvent = NULL;
 337
 338                             if (ie->ie_Class == IECLASS_RAWKEY)
 339                             {
 340                                 if (!IsQualifierKey(ie->ie_Code))
 341                                 {
 342                                     if (keyrepeat_state > 0)
 343                                     {
 344                                         ABORT_KEYTIMER_REQUEST;
 345                                         keyrepeat_state = 0;
 346                                     }
 347
 348                                     if (!(ie->ie_Code & IECODE_UP_PREFIX))
 349                                     {
 350                                         if (IsRepeatableKey(ie->ie_Code))
 351                                         {
 352                                             keyrepeatie = *ie;
 353
 354                                             SEND_KEYTIMER_REQUEST(keytimerio, InputDevice->KeyRepeatThreshold);
 355                                             keyrepeat_state = 1;
 356
 357                                         }
 358                                     }
 359                                 } /* if (!IsQualifierKey(ie->ie_Code)) */
 360                             }
 361
 362                             /* If the event's qualifier differs from the current one, fire the events */
 363                             if (InputDevice->ActQualifier == ie->ie_Qualifier) {
 364                                 UWORD q = ie->ie_Qualifier;
 365                                 ForwardQueuedEvents(InputDevice);
 366
 367                                 /* And set new qualifier */
 368                                 InputDevice->ActQualifier = q;
 369                             }
 370
 371                             /* Set the timestamp */
 372                             GetSysTime( &(ie->ie_TimeStamp ));
 373
 374                             /* and enqueue */
 375                             AddEQTail(ie, InputDevice);
 376                         }
 377                     }
 378                     /* In case some events are still in the queue, fire them all up */
 379                     ForwardQueuedEvents(InputDevice);
 380                 } break;
 381
 382                 case IND_WRITEEVENT: {
 383                     struct InputEvent *ie;
 384
 385                     ie = (struct InputEvent *)ioreq->io_Data;
 386
 387                     ie->ie_NextEvent = NULL;
 388                     /* Add a timestamp to the event */
 389                     GetSysTime( &(ie->ie_TimeStamp ));
 390
 391                     D(bug("id: %d\n", ie->ie_Class));
 392
 393                     /* Add event to queue */
 394                     AddEQTail((struct InputEvent *)ioreq->io_Data,
 395                               InputDevice);
 396
 397                     /* Forward event (and possible others in the queue) */
 398                     ForwardQueuedEvents(InputDevice);
 399                 } break;
 400
 401                 case IND_SETTHRESH:
 402                     InputDevice->KeyRepeatThreshold = ((struct timerequest *)ioreq)->tr_time;
 403                     break;
 404
 405                 case IND_SETPERIOD:
 406                     InputDevice->KeyRepeatInterval  = ((struct timerequest *)ioreq)->tr_time;
 407                     break;
 408
 409                 } /* switch (IO command) */
 410
 411                 ReplyMsg((struct Message *)ioreq);
 412
 413             } /* while (messages in the command port) */
 414
 415         } /* if (IO command received) */
 416
 417         if (wakeupsigs & keytimersig)
 418         {
 419             struct InputEvent ie;
 420
 421             GetMsg(keytimermp);
 422
 423             keyrepeat_state = 2;
 424
 425             ie = keyrepeatie; /* InputHandlers can change inputevents, so send a clone!! */
 426             ie.ie_NextEvent = NULL; /* !! */
 427             ie.ie_Qualifier |= IEQUALIFIER_REPEAT;
 428             GetSysTime(&ie.ie_TimeStamp);
 429
 430             AddEQTail(&ie, InputDevice);
 431
 432             /* Forward event (and possible others in the queue) */
 433             ForwardQueuedEvents(InputDevice);
 434
 435             SEND_KEYTIMER_REQUEST(keytimerio, InputDevice->KeyRepeatInterval);
 436
 437         } /* if (wakeupsigs & keytimersig) */
 438
 439         if (wakeupsigs & kbdsig)
 440         {
 441             GetMsg(kbdmp); /* Only one message */
 442             if (kbdio->io_Error != 0)
 443                 continue;
 444
 445             InputDevice->ActQualifier &= ~KEY_QUALIFIERS;
 446             InputDevice->ActQualifier |= (kbdie->ie_Qualifier & KEY_QUALIFIERS);
 447
 448             kbdie->ie_Qualifier &= ~MOUSE_QUALIFIERS;
 449             kbdie->ie_Qualifier |= (InputDevice->ActQualifier & MOUSE_QUALIFIERS);
 450
 451             /* Add event to queue */
 452             AddEQTail(kbdie, InputDevice);
 453
 454             if (!IsQualifierKey(kbdie->ie_Code))
 455             {
 456                 if (keyrepeat_state > 0)
 457                 {
 458                     ABORT_KEYTIMER_REQUEST;
 459                     keyrepeat_state = 0;
 460                 }
 461
 462                 if (!(kbdie->ie_Code & IECODE_UP_PREFIX))
 463                 {
 464                     if (IsRepeatableKey(kbdie->ie_Code))
 465                     {
 466                         keyrepeatie = *kbdie;
 467
 468                         SEND_KEYTIMER_REQUEST(keytimerio, InputDevice->KeyRepeatThreshold);
 469                         keyrepeat_state = 1;
 470
 471                     }
 472                 }
 473             } /* if (!IsQualifierKey(kbdie->ie_Code)) */
 474
 475             /* New event from keyboard device */
 476             D(bug("id: Keyboard event\n"));
 477             D(bug("id: Events forwarded\n"));
 478
 479             /* Forward event (and possible others in the queue) */
 480             ForwardQueuedEvents(InputDevice);
 481             D(bug("id: Events forwarded\n"));
 482
 483             /* Wit for some more events */
 484             SEND_KBD_REQUEST(kbdio, kbdie);
 485
 486         } /* if (wakeupsigs & kbdsig) */
 487
 488         if (wakeupsigs & gpdsig)
 489         {
 490             GetMsg(gpdmp); /* Only one message */
 491             if (gpdio->io_Error != 0)
 492                 continue;
 493
 494             InputDevice->ActQualifier &= ~MOUSE_QUALIFIERS;
 495             InputDevice->ActQualifier |= (gpdie->ie_Qualifier & MOUSE_QUALIFIERS);
 496
 497             gpdie->ie_Qualifier &= ~KEY_QUALIFIERS;
 498             gpdie->ie_Qualifier |= (InputDevice->ActQualifier & KEY_QUALIFIERS);
 499
 500             /* Gameport just returns the frame count since the last
 501                report in ie_TimeStamp.tv_secs; we therefore must add
 502                a real timestamp ourselves */
 503             GetSysTime(&gpdie->ie_TimeStamp);
 504
 505             /* Wheel events come in as IECLASS_NEWMOUSE, so fix ie_Class and ie_Qualifier) */
 506             if (gpdie->ie_Class == IECLASS_NEWMOUSE)
 507             {
 508                 #warning "The NewMouse standard seems to send both a IECLASS_NEWMOUSE and a IECLASS_RAWKEY event"
 509                 gpdie->ie_Class     = IECLASS_RAWKEY;
 510                 gpdie->ie_Qualifier = InputDevice->ActQualifier & KEY_QUALIFIERS;
 511             }
 512
 513             /* Add event to queue */
 514             AddEQTail(gpdie, InputDevice);
 515
 516             /* New event from gameport device */
 517             D(bug("id: Gameport event\n"));
 518             D(bug("id: Forwarding events\n"));
 519
 520             /* Forward event (and possible others in the queue) */
 521             ForwardQueuedEvents(InputDevice);
 522             D(bug("id: Events forwarded\n"));
 523
 524             /* Wit for some more events */
 525             SEND_GPD_REQUEST(gpdio, gpdie);
 526
 527         } /* if (wakeupsigs & gpdsig) */
 528
 529         if (wakeupsigs & InputDevice->ResetSig)
 530         {
 531             struct IOStdReq resetio = *kbdio;
 532
 533             InputDevice->ResetSig = 0;
 534
 535             /* Blank screen(s) in order to indicate upcoming machine reset */
 536             LoadView(NULL);
 537
 538             resetio.io_Command = KBD_RESETHANDLERDONE;
 539             resetio.io_Data = &resethandler;
 540
 541             /* Relying on this cmd being done quick, here */
 542
 543             DoIO((struct IORequest *)&resetio);
 544
 545         }
 546
 547     } /* Forever */
 548
 549 } /* ProcessEvents */
 550