VirtualBox

source: vbox/trunk/src/VBox/Devices/Input/PS2M.cpp@ 54030

Last change on this file since 54030 was 53322, checked in by vboxsync, 10 years ago

PS2M: Fixed assertion.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 40.0 KB
Line 
1/** @file
2 * PS2M - PS/2 auxiliary device (mouse) emulation.
3 */
4
5/*
6 * Copyright (C) 2007-2013 Oracle Corporation
7 *
8 * This file is part of VirtualBox Open Source Edition (OSE), as
9 * available from http://www.virtualbox.org. This file is free software;
10 * you can redistribute it and/or modify it under the terms of the GNU
11 * General Public License (GPL) as published by the Free Software
12 * Foundation, in version 2 as it comes in the "COPYING" file of the
13 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15 */
16
17/*
18 * References:
19 *
20 * The Undocumented PC (2nd Ed.), Frank van Gilluwe, Addison-Wesley, 1996.
21 * IBM TrackPoint System Version 4.0 Engineering Specification, 1999.
22 * ELAN Microelectronics eKM8025 USB & PS/2 Mouse Controller, 2006.
23 *
24 *
25 * Notes:
26 *
27 * - The auxiliary device commands are very similar to keyboard commands.
28 * Most keyboard commands which do not specifically deal with the keyboard
29 * (enable, disable, reset) have identical counterparts.
30 * - The code refers to 'auxiliary device' and 'mouse'; these terms are not
31 * quite interchangeable. 'Auxiliary device' is used when referring to the
32 * generic PS/2 auxiliary device interface and 'mouse' when referring to
33 * a mouse attached to the auxiliary port.
34 * - The basic modes of operation are reset, stream, and remote. Those are
35 * mutually exclusive. Stream and remote modes can additionally have wrap
36 * mode enabled.
37 * - The auxiliary device sends unsolicited data to the host only when it is
38 * both in stream mode and enabled. Otherwise it only responds to commands.
39 *
40 *
41 * There are three report packet formats supported by the emulated device. The
42 * standard three-byte PS/2 format (with middle button support), IntelliMouse
43 * four-byte format with added scroll wheel, and IntelliMouse Explorer four-byte
44 * format with reduced scroll wheel range but two additional buttons. Note that
45 * the first three bytes of the report are always the same.
46 *
47 * Upon reset, the mouse is always in the standard PS/2 mode. A special 'knock'
48 * sequence can be used to switch to ImPS/2 or ImEx mode. Three consecutive
49 * Set Sampling Rate (0F3h) commands with arguments 200, 100, 80 switch to ImPS/2
50 * mode. While in ImPS/2 or PS/2 mode, three consecutive Set Sampling Rate
51 * commands with arguments 200, 200, 80 switch to ImEx mode. The Read ID (0F2h)
52 * command will report the currently selected protocol.
53 *
54 *
55 * Standard PS/2 pointing device three-byte report packet format:
56 *
57 * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
58 * |Bit/byte| bit 7 | bit 6 | bit 5 | bit 4 | bit 3 | bit 2 | bit 1 | bit 0 |
59 * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
60 * | Byte 1 | Y ovfl | X ovfl | Y sign | X sign | Sync | M btn | R btn | L btn |
61 * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
62 * | Byte 2 | X movement delta (two's complement) |
63 * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
64 * | Byte 3 | Y movement delta (two's complement) |
65 * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
66 *
67 * - The sync bit is always set. It allows software to synchronize data packets
68 * as the X/Y position data typically does not have bit 4 set.
69 * - The overflow bits are set if motion exceeds accumulator range. We use the
70 * maximum range (effectively 9 bits) and do not set the overflow bits.
71 * - Movement in the up/right direction is defined as having positive sign.
72 *
73 *
74 * IntelliMouse PS/2 (ImPS/2) fourth report packet byte:
75 *
76 * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
77 * |Bit/byte| bit 7 | bit 6 | bit 5 | bit 4 | bit 3 | bit 2 | bit 1 | bit 0 |
78 * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
79 * | Byte 4 | Z movement delta (two's complement) |
80 * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
81 *
82 * - The valid range for Z delta values is only -8/+7, i.e. 4 bits.
83 *
84 * IntelliMouse Explorer (ImEx) fourth report packet byte:
85 *
86 * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
87 * |Bit/byte| bit 7 | bit 6 | bit 5 | bit 4 | bit 3 | bit 2 | bit 1 | bit 0 |
88 * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
89 * | Byte 4 | 0 | 0 | Btn 5 | Btn 4 | Z mov't delta (two's complement) |
90 * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
91 *
92 */
93
94
95/*******************************************************************************
96* Header Files *
97*******************************************************************************/
98#define LOG_GROUP LOG_GROUP_DEV_KBD
99#include <VBox/vmm/pdmdev.h>
100#include <VBox/err.h>
101#include <iprt/assert.h>
102#include <iprt/uuid.h>
103#include "VBoxDD.h"
104#define IN_PS2M
105#include "PS2Dev.h"
106
107/*******************************************************************************
108* Defined Constants And Macros *
109*******************************************************************************/
110/** @name Auxiliary device commands sent by the system.
111 * @{ */
112#define ACMD_SET_SCALE_11 0xE6 /* Set 1:1 scaling. */
113#define ACMD_SET_SCALE_21 0xE7 /* Set 2:1 scaling. */
114#define ACMD_SET_RES 0xE8 /* Set resolution. */
115#define ACMD_REQ_STATUS 0xE9 /* Get device status. */
116#define ACMD_SET_STREAM 0xEA /* Set stream mode. */
117#define ACMD_READ_REMOTE 0xEB /* Read remote data. */
118#define ACMD_RESET_WRAP 0xEC /* Exit wrap mode. */
119#define ACMD_INVALID_1 0xED
120#define ACMD_SET_WRAP 0xEE /* Set wrap (echo) mode. */
121#define ACMD_INVALID_2 0xEF
122#define ACMD_SET_REMOTE 0xF0 /* Set remote mode. */
123#define ACMD_INVALID_3 0xF1
124#define ACMD_READ_ID 0xF2 /* Read device ID. */
125#define ACMD_SET_SAMP_RATE 0xF3 /* Set sampling rate. */
126#define ACMD_ENABLE 0xF4 /* Enable (streaming mode). */
127#define ACMD_DFLT_DISABLE 0xF5 /* Disable and set defaults. */
128#define ACMD_SET_DEFAULT 0xF6 /* Set defaults. */
129#define ACMD_INVALID_4 0xF7
130#define ACMD_INVALID_5 0xF8
131#define ACMD_INVALID_6 0xF9
132#define ACMD_INVALID_7 0xFA
133#define ACMD_INVALID_8 0xFB
134#define ACMD_INVALID_9 0xFC
135#define ACMD_INVALID_10 0xFD
136#define ACMD_RESEND 0xFE /* Resend response. */
137#define ACMD_RESET 0xFF /* Reset device. */
138/** @} */
139
140/** @name Auxiliary device responses sent to the system.
141 * @{ */
142#define ARSP_ID 0x00
143#define ARSP_BAT_OK 0xAA /* Self-test passed. */
144#define ARSP_ACK 0xFA /* Command acknowledged. */
145#define ARSP_ERROR 0xFC /* Bad command. */
146#define ARSP_RESEND 0xFE /* Requesting resend. */
147/** @} */
148
149/** Define a simple PS/2 input device queue. */
150#define DEF_PS2Q_TYPE(name, size) \
151 typedef struct { \
152 uint32_t rpos; \
153 uint32_t wpos; \
154 uint32_t cUsed; \
155 uint32_t cSize; \
156 uint8_t abQueue[size]; \
157 } name
158
159/* Internal mouse queue sizes. The input queue is relatively large,
160 * but the command queue only needs to handle a few bytes.
161 */
162#define AUX_EVT_QUEUE_SIZE 256
163#define AUX_CMD_QUEUE_SIZE 8
164
165/*******************************************************************************
166* Structures and Typedefs *
167*******************************************************************************/
168
169DEF_PS2Q_TYPE(AuxEvtQ, AUX_EVT_QUEUE_SIZE);
170DEF_PS2Q_TYPE(AuxCmdQ, AUX_CMD_QUEUE_SIZE);
171#ifndef VBOX_DEVICE_STRUCT_TESTCASE //@todo: hack
172DEF_PS2Q_TYPE(GeneriQ, 1);
173#endif
174
175/* Auxiliary device special modes of operation. */
176typedef enum {
177 AUX_MODE_STD, /* Standard operation. */
178 AUX_MODE_RESET, /* Currently in reset. */
179 AUX_MODE_WRAP /* Wrap mode (echoing input). */
180} PS2M_MODE;
181
182/* Auxiliary device operational state. */
183typedef enum {
184 AUX_STATE_SCALING = RT_BIT(4), /* 2:1 scaling in effect. */
185 AUX_STATE_ENABLED = RT_BIT(5), /* Reporting enabled in stream mode. */
186 AUX_STATE_REMOTE = RT_BIT(6) /* Remote mode (reports on request). */
187} PS2M_STATE;
188
189/* Protocols supported by the PS/2 mouse. */
190typedef enum {
191 PS2M_PROTO_PS2STD = 0, /* Standard PS/2 mouse protocol. */
192 PS2M_PROTO_IMPS2 = 3, /* IntelliMouse PS/2 protocol. */
193 PS2M_PROTO_IMEX = 4 /* IntelliMouse Explorer protocol. */
194} PS2M_PROTO;
195
196/* Protocol selection 'knock' states. */
197typedef enum {
198 PS2M_KNOCK_INITIAL,
199 PS2M_KNOCK_1ST,
200 PS2M_KNOCK_IMPS2_2ND,
201 PS2M_KNOCK_IMEX_2ND
202} PS2M_KNOCK_STATE;
203
204/**
205 * The PS/2 auxiliary device instance data.
206 */
207typedef struct PS2M
208{
209 /** Pointer to parent device (keyboard controller). */
210 R3PTRTYPE(void *) pParent;
211 /** Operational state. */
212 uint8_t u8State;
213 /** Configured sampling rate. */
214 uint8_t u8SampleRate;
215 /** Configured resolution. */
216 uint8_t u8Resolution;
217 /** Currently processed command (if any). */
218 uint8_t u8CurrCmd;
219 /** Set if the throttle delay is active. */
220 bool fThrottleActive;
221 /** Set if the throttle delay is active. */
222 bool fDelayReset;
223 /** Operational mode. */
224 PS2M_MODE enmMode;
225 /** Currently used protocol. */
226 PS2M_PROTO enmProtocol;
227 /** Currently used protocol. */
228 PS2M_KNOCK_STATE enmKnockState;
229 /** Buffer holding mouse events to be sent to the host. */
230 AuxEvtQ evtQ;
231 /** Command response queue (priority). */
232 AuxCmdQ cmdQ;
233 /** Accumulated horizontal movement. */
234 int32_t iAccumX;
235 /** Accumulated vertical movement. */
236 int32_t iAccumY;
237 /** Accumulated Z axis movement. */
238 int32_t iAccumZ;
239 /** Accumulated button presses. */
240 uint32_t fAccumB;
241 /** Throttling delay in milliseconds. */
242 unsigned uThrottleDelay;
243#if HC_ARCH_BITS == 32
244 uint32_t Alignment0;
245#endif
246
247 /** The device critical section protecting everything - R3 Ptr */
248 R3PTRTYPE(PPDMCRITSECT) pCritSectR3;
249 /** Command delay timer - R3 Ptr. */
250 PTMTIMERR3 pDelayTimerR3;
251 /** Interrupt throttling timer - R3 Ptr. */
252 PTMTIMERR3 pThrottleTimerR3;
253 RTR3PTR Alignment1;
254
255 /** Command delay timer - RC Ptr. */
256 PTMTIMERRC pDelayTimerRC;
257 /** Interrupt throttling timer - RC Ptr. */
258 PTMTIMERRC pThrottleTimerRC;
259
260 /** Command delay timer - R0 Ptr. */
261 PTMTIMERR0 pDelayTimerR0;
262 /** Interrupt throttling timer - R0 Ptr. */
263 PTMTIMERR0 pThrottleTimerR0;
264
265 /**
266 * Mouse port - LUN#1.
267 *
268 * @implements PDMIBASE
269 * @implements PDMIMOUSEPORT
270 */
271 struct
272 {
273 /** The base interface for the mouse port. */
274 PDMIBASE IBase;
275 /** The keyboard port base interface. */
276 PDMIMOUSEPORT IPort;
277
278 /** The base interface of the attached mouse driver. */
279 R3PTRTYPE(PPDMIBASE) pDrvBase;
280 /** The keyboard interface of the attached mouse driver. */
281 R3PTRTYPE(PPDMIMOUSECONNECTOR) pDrv;
282 } Mouse;
283} PS2M, *PPS2M;
284
285AssertCompile(PS2M_STRUCT_FILLER >= sizeof(PS2M));
286
287#ifndef VBOX_DEVICE_STRUCT_TESTCASE
288
289/* Key type flags. */
290#define KF_E0 0x01 /* E0 prefix. */
291#define KF_NB 0x02 /* No break code. */
292#define KF_GK 0x04 /* Gray navigation key. */
293#define KF_PS 0x08 /* Print Screen key. */
294#define KF_PB 0x10 /* Pause/Break key. */
295#define KF_NL 0x20 /* Num Lock key. */
296#define KF_NS 0x40 /* NumPad '/' key. */
297
298/*******************************************************************************
299* Global Variables *
300*******************************************************************************/
301
302
303/*******************************************************************************
304* Internal Functions *
305*******************************************************************************/
306
307
308/**
309 * Clear a queue.
310 *
311 * @param pQ Pointer to the queue.
312 */
313static void ps2kClearQueue(GeneriQ *pQ)
314{
315 LogFlowFunc(("Clearing queue %p\n", pQ));
316 pQ->wpos = pQ->rpos;
317 pQ->cUsed = 0;
318}
319
320
321/**
322 * Add a byte to a queue.
323 *
324 * @param pQ Pointer to the queue.
325 * @param val The byte to store.
326 */
327static void ps2kInsertQueue(GeneriQ *pQ, uint8_t val)
328{
329 /* Check if queue is full. */
330 if (pQ->cUsed >= pQ->cSize)
331 {
332 LogFlowFunc(("queue %p full (%d entries)\n", pQ, pQ->cUsed));
333 return;
334 }
335 /* Insert data and update circular buffer write position. */
336 pQ->abQueue[pQ->wpos] = val;
337 if (++pQ->wpos == pQ->cSize)
338 pQ->wpos = 0; /* Roll over. */
339 ++pQ->cUsed;
340 LogFlowFunc(("inserted 0x%02X into queue %p\n", val, pQ));
341}
342
343#ifdef IN_RING3
344
345/**
346 * Save a queue state.
347 *
348 * @param pSSM SSM handle to write the state to.
349 * @param pQ Pointer to the queue.
350 */
351static void ps2kSaveQueue(PSSMHANDLE pSSM, GeneriQ *pQ)
352{
353 uint32_t cItems = pQ->cUsed;
354 int i;
355
356 /* Only save the number of items. Note that the read/write
357 * positions aren't saved as they will be rebuilt on load.
358 */
359 SSMR3PutU32(pSSM, cItems);
360
361 LogFlow(("Storing %d items from queue %p\n", cItems, pQ));
362
363 /* Save queue data - only the bytes actually used (typically zero). */
364 for (i = pQ->rpos; cItems-- > 0; i = (i + 1) % pQ->cSize)
365 SSMR3PutU8(pSSM, pQ->abQueue[i]);
366}
367
368/**
369 * Load a queue state.
370 *
371 * @param pSSM SSM handle to read the state from.
372 * @param pQ Pointer to the queue.
373 *
374 * @return int VBox status/error code.
375 */
376static int ps2kLoadQueue(PSSMHANDLE pSSM, GeneriQ *pQ)
377{
378 int rc;
379
380 /* On load, always put the read pointer at zero. */
381 SSMR3GetU32(pSSM, &pQ->cUsed);
382
383 LogFlow(("Loading %d items to queue %p\n", pQ->cUsed, pQ));
384
385 if (pQ->cUsed > pQ->cSize)
386 {
387 AssertMsgFailed(("Saved size=%u, actual=%u\n", pQ->cUsed, pQ->cSize));
388 return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
389 }
390
391 /* Recalculate queue positions and load data in one go. */
392 pQ->rpos = 0;
393 pQ->wpos = pQ->cUsed;
394 rc = SSMR3GetMem(pSSM, pQ->abQueue, pQ->cUsed);
395
396 return rc;
397}
398
399/* Report a change in status down (or is it up?) the driver chain. */
400static void ps2mSetDriverState(PPS2M pThis, bool fEnabled)
401{
402 PPDMIMOUSECONNECTOR pDrv = pThis->Mouse.pDrv;
403 if (pDrv)
404 pDrv->pfnReportModes(pDrv, fEnabled, false, false);
405}
406
407/* Reset the pointing device. */
408static void ps2mReset(PPS2M pThis)
409{
410 ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_BAT_OK);
411 ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, 0);
412 pThis->enmMode = AUX_MODE_STD;
413 pThis->u8CurrCmd = 0;
414
415 //@todo: move to its proper home!
416 ps2mSetDriverState(pThis, true);
417}
418
419#endif /* IN_RING3 */
420
421/**
422 * Retrieve a byte from a queue.
423 *
424 * @param pQ Pointer to the queue.
425 * @param pVal Pointer to storage for the byte.
426 *
427 * @return int VINF_TRY_AGAIN if queue is empty,
428 * VINF_SUCCESS if a byte was read.
429 */
430static int ps2kRemoveQueue(GeneriQ *pQ, uint8_t *pVal)
431{
432 int rc = VINF_TRY_AGAIN;
433
434 Assert(pVal);
435 if (pQ->cUsed)
436 {
437 *pVal = pQ->abQueue[pQ->rpos];
438 if (++pQ->rpos == pQ->cSize)
439 pQ->rpos = 0; /* Roll over. */
440 --pQ->cUsed;
441 rc = VINF_SUCCESS;
442 LogFlowFunc(("removed 0x%02X from queue %p\n", *pVal, pQ));
443 } else
444 LogFlowFunc(("queue %p empty\n", pQ));
445 return rc;
446}
447
448static void ps2mSetRate(PPS2M pThis, uint8_t rate)
449{
450 pThis->uThrottleDelay = 1000 / rate;
451 pThis->u8SampleRate = rate;
452 LogFlowFunc(("Sampling rate %u, throttle delay %u ms\n", pThis->u8SampleRate, pThis->uThrottleDelay));
453}
454
455static void ps2mSetDefaults(PPS2M pThis)
456{
457 LogFlowFunc(("Set mouse defaults\n"));
458 /* Standard protocol, reporting disabled, resolution 2, 1:1 scaling. */
459 pThis->enmProtocol = PS2M_PROTO_PS2STD;
460 pThis->u8State = 0;
461 pThis->u8Resolution = 2;
462
463 /* Sample rate 100 reports per second. */
464 ps2mSetRate(pThis, 100);
465
466 /* Event queue, eccumulators, and button status bits are cleared. */
467 ps2kClearQueue((GeneriQ *)&pThis->evtQ);
468 pThis->iAccumX = pThis->iAccumY = pThis->iAccumZ = pThis->fAccumB = 0;
469}
470
471/* Handle the sampling rate 'knock' sequence which selects protocol. */
472static void ps2mRateProtocolKnock(PPS2M pThis, uint8_t rate)
473{
474 switch (pThis->enmKnockState)
475 {
476 case PS2M_KNOCK_INITIAL:
477 if (rate == 200)
478 pThis->enmKnockState = PS2M_KNOCK_1ST;
479 break;
480 case PS2M_KNOCK_1ST:
481 if (rate == 100)
482 pThis->enmKnockState = PS2M_KNOCK_IMPS2_2ND;
483 else if (rate == 200)
484 pThis->enmKnockState = PS2M_KNOCK_IMEX_2ND;
485 else
486 pThis->enmKnockState = PS2M_KNOCK_INITIAL;
487 break;
488 case PS2M_KNOCK_IMPS2_2ND:
489 if (rate == 80)
490 {
491 pThis->enmProtocol = PS2M_PROTO_IMPS2;
492 LogRelFlow(("PS2M: Switching mouse to ImPS/2 protocol.\n"));
493 }
494 pThis->enmKnockState = PS2M_KNOCK_INITIAL;
495 break;
496 case PS2M_KNOCK_IMEX_2ND:
497 if (rate == 80)
498 {
499 pThis->enmProtocol = PS2M_PROTO_IMEX;
500 LogRelFlow(("PS2M: Switching mouse to ImEx protocol.\n"));
501 }
502 /* Fall through! */
503 default:
504 pThis->enmKnockState = PS2M_KNOCK_INITIAL;
505 }
506}
507
508/**
509 * Receive and process a byte sent by the keyboard controller.
510 *
511 * @param pThis The PS/2 auxiliary device instance data.
512 * @param cmd The command (or data) byte.
513 */
514int PS2MByteToAux(PPS2M pThis, uint8_t cmd)
515{
516 uint8_t u8Val;
517 bool fHandled = true;
518
519 LogFlowFunc(("cmd=0x%02X, active cmd=0x%02X\n", cmd, pThis->u8CurrCmd));
520//LogRel(("aux: cmd=0x%02X, active cmd=0x%02X\n", cmd, pThis->u8CurrCmd));
521
522 if (pThis->enmMode == AUX_MODE_RESET)
523 /* In reset mode, do not respond at all. */
524 return VINF_SUCCESS;
525
526 /* If there's anything left in the command response queue, trash it. */
527 ps2kClearQueue((GeneriQ *)&pThis->cmdQ);
528
529 if (pThis->enmMode == AUX_MODE_WRAP)
530 {
531 /* In wrap mode, bounce most data right back.*/
532 if (cmd == ACMD_RESET || cmd == ACMD_RESET_WRAP)
533 ; /* Handle as regular commands. */
534 else
535 {
536 ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, cmd);
537 return VINF_SUCCESS;
538 }
539 }
540
541#ifndef IN_RING3
542 /* Reset, Enable, and Set Default commands must be run in R3. */
543 if (cmd == ACMD_RESET || cmd == ACMD_ENABLE || cmd == ACMD_SET_DEFAULT)
544 return VINF_IOM_R3_IOPORT_WRITE;
545#endif
546
547 switch (cmd)
548 {
549 case ACMD_SET_SCALE_11:
550 pThis->u8State &= ~AUX_STATE_SCALING;
551 ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
552 pThis->u8CurrCmd = 0;
553 break;
554 case ACMD_SET_SCALE_21:
555 pThis->u8State |= AUX_STATE_SCALING;
556 ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
557 pThis->u8CurrCmd = 0;
558 break;
559 case ACMD_REQ_STATUS:
560 /* Report current status, sample rate, and resolution. */
561 //@todo: buttons
562 u8Val = pThis->u8State;
563 ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
564 ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, u8Val);
565 ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, pThis->u8Resolution);
566 ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, pThis->u8SampleRate);
567 pThis->u8CurrCmd = 0;
568 break;
569 case ACMD_SET_STREAM:
570 pThis->u8State &= ~AUX_STATE_REMOTE;
571 ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
572 pThis->u8CurrCmd = 0;
573 break;
574 case ACMD_RESET_WRAP:
575 pThis->enmMode = AUX_MODE_STD;
576 /* NB: Stream mode reporting remains disabled! */
577 ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
578 pThis->u8CurrCmd = 0;
579 break;
580 case ACMD_SET_WRAP:
581 pThis->enmMode = AUX_MODE_WRAP;
582 pThis->u8State &= ~AUX_STATE_ENABLED;
583 ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
584 pThis->u8CurrCmd = 0;
585 break;
586 case ACMD_SET_REMOTE:
587 pThis->u8State |= AUX_STATE_REMOTE;
588 ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
589 pThis->u8CurrCmd = 0;
590 break;
591 case ACMD_READ_ID:
592 ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
593 ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, pThis->enmProtocol);
594 pThis->u8CurrCmd = 0;
595 break;
596 case ACMD_ENABLE:
597 pThis->u8State |= AUX_STATE_ENABLED;
598#ifdef IN_RING3
599 ps2mSetDriverState(pThis, true);
600#else
601 AssertLogRelMsgFailed(("Invalid ACMD_ENABLE outside R3!\n"));
602#endif
603 ps2kClearQueue((GeneriQ *)&pThis->evtQ);
604 ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
605 pThis->u8CurrCmd = 0;
606 break;
607 case ACMD_DFLT_DISABLE:
608 ps2mSetDefaults(pThis);
609 ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
610 pThis->u8CurrCmd = 0;
611 break;
612 case ACMD_SET_DEFAULT:
613 ps2mSetDefaults(pThis);
614 ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
615 pThis->u8CurrCmd = 0;
616 break;
617 case ACMD_RESEND:
618 pThis->u8CurrCmd = 0;
619 break;
620 case ACMD_RESET:
621 ps2mSetDefaults(pThis);
622 ///@todo reset more?
623 pThis->u8CurrCmd = cmd;
624 pThis->enmMode = AUX_MODE_RESET;
625 ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
626 if (pThis->fDelayReset)
627 /* Slightly delay reset completion; it might take hundreds of ms. */
628 TMTimerSetMillies(pThis->CTX_SUFF(pDelayTimer), 1);
629 else
630#ifdef IN_RING3
631 ps2mReset(pThis);
632#else
633 AssertLogRelMsgFailed(("Invalid ACMD_RESET outside R3!\n"));
634#endif
635 break;
636 /* The following commands need a parameter. */
637 case ACMD_SET_RES:
638 case ACMD_SET_SAMP_RATE:
639 ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
640 pThis->u8CurrCmd = cmd;
641 break;
642 default:
643 /* Sending a command instead of a parameter starts the new command. */
644 switch (pThis->u8CurrCmd)
645 {
646 case ACMD_SET_RES:
647 //@todo reject unsupported resolutions
648 pThis->u8Resolution = cmd;
649 ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
650 pThis->u8CurrCmd = 0;
651 break;
652 case ACMD_SET_SAMP_RATE:
653 //@todo reject unsupported rates
654 ps2mSetRate(pThis, cmd);
655 ps2mRateProtocolKnock(pThis, cmd);
656 ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_ACK);
657 pThis->u8CurrCmd = 0;
658 break;
659 default:
660 fHandled = false;
661 }
662 /* Fall through only to handle unrecognized commands. */
663 if (fHandled)
664 break;
665
666 case ACMD_INVALID_1:
667 case ACMD_INVALID_2:
668 case ACMD_INVALID_3:
669 case ACMD_INVALID_4:
670 case ACMD_INVALID_5:
671 case ACMD_INVALID_6:
672 case ACMD_INVALID_7:
673 case ACMD_INVALID_8:
674 case ACMD_INVALID_9:
675 case ACMD_INVALID_10:
676 Log(("Unsupported command 0x%02X!\n", cmd));
677 ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, ARSP_RESEND);
678 pThis->u8CurrCmd = 0;
679 break;
680 }
681 LogFlowFunc(("Active cmd now 0x%02X; updating interrupts\n", pThis->u8CurrCmd));
682// KBCUpdateInterrupts(pThis->pParent);
683 return VINF_SUCCESS;
684}
685
686/**
687 * Send a byte (keystroke or command response) to the keyboard controller.
688 *
689 * @returns VINF_SUCCESS or VINF_TRY_AGAIN.
690 * @param pThis The PS/2 auxiliary device instance data.
691 * @param pb Where to return the byte we've read.
692 * @remarks Caller must have entered the device critical section.
693 */
694int PS2MByteFromAux(PPS2M pThis, uint8_t *pb)
695{
696 int rc;
697
698 AssertPtr(pb);
699
700 /* Anything in the command queue has priority over data
701 * in the event queue. Additionally, keystrokes are //@todo: true?
702 * blocked if a command is currently in progress, even if
703 * the command queue is empty.
704 */
705 //@todo: Probably should flush/not fill queue if stream mode reporting disabled?!
706 rc = ps2kRemoveQueue((GeneriQ *)&pThis->cmdQ, pb);
707 if (rc != VINF_SUCCESS && !pThis->u8CurrCmd && (pThis->u8State & AUX_STATE_ENABLED))
708 rc = ps2kRemoveQueue((GeneriQ *)&pThis->evtQ, pb);
709
710 LogFlowFunc(("mouse sends 0x%02x (%svalid data)\n", *pb, rc == VINF_SUCCESS ? "" : "not "));
711//if (rc == VINF_SUCCESS) LogRel(("aux: sends 0x%02X\n", *pb));
712
713 return rc;
714}
715
716#ifdef IN_RING3
717
718/* Three-button event mask. */
719#define PS2M_STD_BTN_MASK (RT_BIT(0) | RT_BIT(1) | RT_BIT(2))
720
721/* Report accumulated movement and button presses, then clear the accumulators. */
722static void ps2mReportAccumulatedEvents(PPS2M pThis)
723{
724 uint8_t val;
725 int8_t dX, dY, dZ;
726
727 /* Clamp the accumulated delta values to the allowed range. */
728 dX = RT_MIN(RT_MAX(pThis->iAccumX, -256), 255);
729 dY = RT_MIN(RT_MAX(pThis->iAccumY, -256), 255);
730 dZ = RT_MIN(RT_MAX(pThis->iAccumZ, -8), 7);
731
732 /* Start with the sync bit and buttons 1-3. */
733 val = RT_BIT(3) | (pThis->fAccumB & PS2M_STD_BTN_MASK);
734 /* Set the X/Y sign bits. */
735 if (dX < 0)
736 val |= RT_BIT(4);
737 if (dY < 0)
738 val |= RT_BIT(5);
739
740 /* Send the standard 3-byte packet (always the same). */
741 ps2kInsertQueue((GeneriQ *)&pThis->evtQ, val);
742 ps2kInsertQueue((GeneriQ *)&pThis->evtQ, dX);
743 ps2kInsertQueue((GeneriQ *)&pThis->evtQ, dY);
744
745 /* Add fourth byte if extended protocol is in use. */
746 if (pThis->enmProtocol > PS2M_PROTO_PS2STD)
747 {
748 if (pThis->enmProtocol == PS2M_PROTO_IMPS2)
749 ps2kInsertQueue((GeneriQ *)&pThis->evtQ, dZ);
750 else
751 {
752 Assert(pThis->enmProtocol == PS2M_PROTO_IMEX);
753 /* Z value uses 4 bits; buttons 4/5 in bits 4 and 5. */
754 val = dZ & 0x0f;
755 val |= (pThis->fAccumB << 1) & (RT_BIT(4) | RT_BIT(5));
756 ps2kInsertQueue((GeneriQ *)&pThis->evtQ, dZ);
757 }
758 }
759
760 /* Clear the accumulators. */
761 pThis->iAccumX = pThis->iAccumY = pThis->iAccumZ = pThis->fAccumB = 0;
762
763 /* Poke the KBC to update its state. */
764 KBCUpdateInterrupts(pThis->pParent);
765}
766
767/* Event rate throttling timer to emulate the auxiliary device sampling rate.
768 */
769static DECLCALLBACK(void) ps2mThrottleTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
770{
771 PPS2M pThis = (PS2M *)pvUser; NOREF(pDevIns);
772 uint32_t uHaveEvents;
773
774 /* Grab the lock to avoid races with PutEvent(). */
775 int rc = PDMCritSectEnter(pThis->pCritSectR3, VERR_SEM_BUSY);
776 AssertReleaseRC(rc);
777
778#if 0
779 /* If the input queue is not empty, restart the timer. */
780#else
781 /* If more movement is accumulated, report it and restart the timer. */
782 uHaveEvents = pThis->iAccumX | pThis->iAccumY | pThis->iAccumZ | pThis->fAccumB;
783 LogFlowFunc(("Have%s events\n", uHaveEvents ? "" : " no"));
784
785 if (uHaveEvents)
786#endif
787 {
788 ps2mReportAccumulatedEvents(pThis);
789 TMTimerSetMillies(pThis->CTX_SUFF(pThrottleTimer), pThis->uThrottleDelay);
790 }
791 else
792 pThis->fThrottleActive = false;
793
794 PDMCritSectLeave(pThis->pCritSectR3);
795}
796
797/* The auxiliary device is specified to take up to about 500 milliseconds. We need
798 * to delay sending the result to the host for at least a tiny little while.
799 */
800static DECLCALLBACK(void) ps2mDelayTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
801{
802 PPS2M pThis = (PS2M *)pvUser; NOREF(pDevIns);
803
804 LogFlowFunc(("Delay timer: cmd %02X\n", pThis->u8CurrCmd));
805
806 Assert(pThis->u8CurrCmd == ACMD_RESET);
807 ps2mReset(pThis);
808
809 ///@todo Might want a PS2MCompleteCommand() to push last response, clear command, and kick the KBC...
810 /* Give the KBC a kick. */
811 KBCUpdateInterrupts(pThis->pParent);
812}
813
814
815/**
816 * Debug device info handler. Prints basic auxiliary device state.
817 *
818 * @param pDevIns Device instance which registered the info.
819 * @param pHlp Callback functions for doing output.
820 * @param pszArgs Argument string. Optional and specific to the handler.
821 */
822static DECLCALLBACK(void) ps2mInfoState(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
823{
824 static const char *pcszModes[] = { "normal", "reset", "wrap" };
825 static const char *pcszProtocols[] = { "PS/2", NULL, NULL, "ImPS/2", "ImEx" };
826 PPS2M pThis = KBDGetPS2MFromDevIns(pDevIns);
827 NOREF(pszArgs);
828
829 Assert(pThis->enmMode <= RT_ELEMENTS(pcszModes));
830 Assert(pThis->enmProtocol <= RT_ELEMENTS(pcszProtocols));
831 pHlp->pfnPrintf(pHlp, "PS/2 mouse state: %s, %s mode, reporting %s\n",
832 pcszModes[pThis->enmMode],
833 pThis->u8State & AUX_STATE_REMOTE ? "remote" : "stream",
834 pThis->u8State & AUX_STATE_ENABLED ? "enabled" : "disabled");
835 pHlp->pfnPrintf(pHlp, "Protocol: %s, scaling %u:1\n",
836 pcszProtocols[pThis->enmProtocol], pThis->u8State & AUX_STATE_SCALING ? 2 : 1);
837 pHlp->pfnPrintf(pHlp, "Active command %02X\n", pThis->u8CurrCmd);
838 pHlp->pfnPrintf(pHlp, "Sampling rate %u reports/sec, resolution %u counts/mm\n",
839 pThis->u8SampleRate, 1 << pThis->u8Resolution);
840 pHlp->pfnPrintf(pHlp, "Command queue: %d items (%d max)\n",
841 pThis->cmdQ.cUsed, pThis->cmdQ.cSize);
842 pHlp->pfnPrintf(pHlp, "Event queue : %d items (%d max)\n",
843 pThis->evtQ.cUsed, pThis->evtQ.cSize);
844}
845
846/* -=-=-=-=-=- Mouse: IBase -=-=-=-=-=- */
847
848/**
849 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
850 */
851static DECLCALLBACK(void *) ps2mQueryInterface(PPDMIBASE pInterface, const char *pszIID)
852{
853 PPS2M pThis = RT_FROM_MEMBER(pInterface, PS2M, Mouse.IBase);
854 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->Mouse.IBase);
855 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMOUSEPORT, &pThis->Mouse.IPort);
856 return NULL;
857}
858
859
860/* -=-=-=-=-=- Mouse: IMousePort -=-=-=-=-=- */
861
862/**
863 * Mouse event handler.
864 *
865 * @returns VBox status code.
866 * @param pThis The PS/2 auxiliary device instance data.
867 * @param dx X direction movement delta.
868 * @param dy Y direction movement delta.
869 * @param dz Z (vertical scroll) movement delta.
870 * @param dw W (horizontal scroll) movement delta.
871 * @param fButtons Depressed button mask.
872 */
873static int ps2mPutEventWorker(PPS2M pThis, int32_t dx, int32_t dy,
874 int32_t dz, int32_t dw, uint32_t fButtons)
875{
876 int rc = VINF_SUCCESS;
877
878 /* Update internal accumulators and button state. */
879 pThis->iAccumX += dx;
880 pThis->iAccumY += dy;
881 pThis->iAccumZ += dz;
882 pThis->fAccumB |= fButtons & PS2M_STD_BTN_MASK; //@todo: accumulate based on current protocol?
883
884#if 1
885 /* Report the event and start the throttle timer unless it's already running. */
886 if (!pThis->fThrottleActive)
887 {
888 ps2mReportAccumulatedEvents(pThis);
889 pThis->fThrottleActive = true;
890 TMTimerSetMillies(pThis->CTX_SUFF(pThrottleTimer), pThis->uThrottleDelay);
891 }
892#else
893 /* Clamp the delta values to the allowed range. */
894 dx = RT_MIN(RT_MAX(dx, -256), 255);
895 dy = RT_MIN(RT_MAX(dy, -256), 255);
896
897 /* Start with the sync bit. */
898 val = RT_BIT(3);
899 /* Add buttons 1-3. */
900 val |= fButtons & PS2M_STD_BTN_MASK;
901 /* Set the X/Y sign bits. */
902 if (dx < 0)
903 val |= RT_BIT(4);
904 if (dy < 0)
905 val |= RT_BIT(5);
906
907 ps2kInsertQueue((GeneriQ *)&pThis->evtQ, val);
908 ps2kInsertQueue((GeneriQ *)&pThis->evtQ, (uint8_t)dx);
909 ps2kInsertQueue((GeneriQ *)&pThis->evtQ, (uint8_t)dy);
910 if (pThis->enmProtocol > PS2M_PROTO_PS2STD)
911 {
912 ps2kInsertQueue((GeneriQ *)&pThis->evtQ, (uint8_t)dz);
913 }
914#endif
915
916 return rc;
917}
918
919/* -=-=-=-=-=- Mouse: IMousePort -=-=-=-=-=- */
920
921/**
922 * @interface_method_impl{PDMIMOUSEPORT, pfnPutEvent}
923 */
924static DECLCALLBACK(int) ps2mPutEvent(PPDMIMOUSEPORT pInterface, int32_t dx, int32_t dy,
925 int32_t dz, int32_t dw, uint32_t fButtons)
926{
927 PPS2M pThis = RT_FROM_MEMBER(pInterface, PS2M, Mouse.IPort);
928 int rc = PDMCritSectEnter(pThis->pCritSectR3, VERR_SEM_BUSY);
929 AssertReleaseRC(rc);
930
931 LogFlowFunc(("dX=%d dY=%d dZ=%d dW=%d buttons=%02X\n", dx, dy, dz, dw, fButtons));
932 /* NB: The PS/2 Y axis direction is inverted relative to ours. */
933 ps2mPutEventWorker(pThis, dx, -dy, dz, dw, fButtons);
934
935 PDMCritSectLeave(pThis->pCritSectR3);
936 return VINF_SUCCESS;
937}
938
939/**
940 * @interface_method_impl{PDMIMOUSEPORT, pfnPutEventAbs}
941 */
942static DECLCALLBACK(int) ps2mPutEventAbs(PPDMIMOUSEPORT pInterface, uint32_t x, uint32_t y,
943 int32_t dz, int32_t dw, uint32_t fButtons)
944{
945 AssertFailedReturn(VERR_NOT_SUPPORTED);
946 NOREF(pInterface); NOREF(x); NOREF(y); NOREF(dz); NOREF(dw); NOREF(fButtons);
947}
948
949/**
950 * @interface_method_impl{PDMIMOUSEPORT, pfnPutEventMultiTouch}
951 */
952static DECLCALLBACK(int) ps2mPutEventMT(PPDMIMOUSEPORT pInterface, uint8_t cContacts,
953 const uint64_t *pau64Contacts, uint32_t u32ScanTime)
954{
955 AssertFailedReturn(VERR_NOT_SUPPORTED);
956 NOREF(pInterface); NOREF(cContacts); NOREF(pau64Contacts); NOREF(u32ScanTime);
957}
958
959
960
961/**
962 * Attach command.
963 *
964 * This is called to let the device attach to a driver for a
965 * specified LUN.
966 *
967 * This is like plugging in the mouse after turning on the
968 * system.
969 *
970 * @returns VBox status code.
971 * @param pThis The PS/2 auxiliary device instance data.
972 * @param pDevIns The device instance.
973 * @param iLUN The logical unit which is being detached.
974 * @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
975 */
976int PS2MAttach(PPS2M pThis, PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
977{
978 int rc;
979
980 /* The LUN must be 1, i.e. mouse. */
981 Assert(iLUN == 1);
982 AssertMsgReturn(fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG,
983 ("PS/2 mouse does not support hotplugging\n"),
984 VERR_INVALID_PARAMETER);
985
986 LogFlowFunc(("iLUN=%d\n", iLUN));
987
988 rc = PDMDevHlpDriverAttach(pDevIns, iLUN, &pThis->Mouse.IBase, &pThis->Mouse.pDrvBase, "Mouse Port");
989 if (RT_SUCCESS(rc))
990 {
991 pThis->Mouse.pDrv = PDMIBASE_QUERY_INTERFACE(pThis->Mouse.pDrvBase, PDMIMOUSECONNECTOR);
992 if (!pThis->Mouse.pDrv)
993 {
994 AssertLogRelMsgFailed(("LUN #1 doesn't have a mouse interface! rc=%Rrc\n", rc));
995 rc = VERR_PDM_MISSING_INTERFACE;
996 }
997 }
998 else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
999 {
1000 Log(("%s/%d: warning: no driver attached to LUN #1!\n", pDevIns->pReg->szName, pDevIns->iInstance));
1001 rc = VINF_SUCCESS;
1002 }
1003 else
1004 AssertLogRelMsgFailed(("Failed to attach LUN #1! rc=%Rrc\n", rc));
1005
1006 return rc;
1007}
1008
1009void PS2MSaveState(PPS2M pThis, PSSMHANDLE pSSM)
1010{
1011 uint32_t cPressed = 0;
1012
1013 LogFlowFunc(("Saving PS2M state\n"));
1014
1015 /* Save the core auxiliary device state. */
1016 SSMR3PutU8(pSSM, pThis->u8State);
1017 SSMR3PutU8(pSSM, pThis->u8SampleRate);
1018 SSMR3PutU8(pSSM, pThis->u8Resolution);
1019 SSMR3PutU8(pSSM, pThis->u8CurrCmd);
1020 SSMR3PutU8(pSSM, pThis->enmMode);
1021 SSMR3PutU8(pSSM, pThis->enmProtocol);
1022 SSMR3PutU8(pSSM, pThis->enmKnockState);
1023
1024 /* Save the command and event queues. */
1025 ps2kSaveQueue(pSSM, (GeneriQ *)&pThis->cmdQ);
1026 ps2kSaveQueue(pSSM, (GeneriQ *)&pThis->evtQ);
1027
1028 /* Save the command delay timer. Note that the rate throttling
1029 * timer is *not* saved.
1030 */
1031 TMR3TimerSave(pThis->CTX_SUFF(pDelayTimer), pSSM);
1032}
1033
1034int PS2MLoadState(PPS2M pThis, PSSMHANDLE pSSM, uint32_t uVersion)
1035{
1036 uint8_t u8;
1037 int rc;
1038
1039 NOREF(uVersion);
1040 LogFlowFunc(("Loading PS2M state version %u\n", uVersion));
1041
1042 /* Load the basic auxiliary device state. */
1043 SSMR3GetU8(pSSM, &pThis->u8State);
1044 SSMR3GetU8(pSSM, &pThis->u8SampleRate);
1045 SSMR3GetU8(pSSM, &pThis->u8Resolution);
1046 SSMR3GetU8(pSSM, &pThis->u8CurrCmd);
1047 SSMR3GetU8(pSSM, &u8);
1048 pThis->enmMode = (PS2M_MODE)u8;
1049 SSMR3GetU8(pSSM, &u8);
1050 pThis->enmProtocol = (PS2M_PROTO)u8;
1051 SSMR3GetU8(pSSM, &u8);
1052 pThis->enmKnockState = (PS2M_KNOCK_STATE)u8;
1053
1054 /* Load the command and event queues. */
1055 rc = ps2kLoadQueue(pSSM, (GeneriQ *)&pThis->cmdQ);
1056 AssertRCReturn(rc, rc);
1057 rc = ps2kLoadQueue(pSSM, (GeneriQ *)&pThis->evtQ);
1058 AssertRCReturn(rc, rc);
1059
1060 /* Load the command delay timer, just in case. */
1061 rc = TMR3TimerLoad(pThis->CTX_SUFF(pDelayTimer), pSSM);
1062 AssertRCReturn(rc, rc);
1063
1064 /* Recalculate the throttling delay. */
1065 ps2mSetRate(pThis, pThis->u8SampleRate);
1066
1067 //@todo: Is this the right place/logic?
1068 ps2mSetDriverState(pThis, !!(pThis->u8State & AUX_STATE_ENABLED));
1069
1070 return rc;
1071}
1072
1073void PS2MReset(PPS2M pThis)
1074{
1075 LogFlowFunc(("Resetting PS2M\n"));
1076
1077 pThis->u8CurrCmd = 0;
1078
1079 /* Clear the queues. */
1080 ps2kClearQueue((GeneriQ *)&pThis->cmdQ);
1081 ps2mSetDefaults(pThis); /* Also clears event queue. */
1082
1083 /* Activate the PS/2 mouse by default. */
1084// if (pThis->Mouse.pDrv)
1085// pThis->Mouse.pDrv->pfnSetActive(pThis->Mouse.pDrv, true);
1086}
1087
1088void PS2MRelocate(PPS2M pThis, RTGCINTPTR offDelta, PPDMDEVINS pDevIns)
1089{
1090 LogFlowFunc(("Relocating PS2M\n"));
1091 pThis->pDelayTimerRC = TMTimerRCPtr(pThis->pDelayTimerR3);
1092 pThis->pThrottleTimerRC = TMTimerRCPtr(pThis->pThrottleTimerR3);
1093 NOREF(offDelta);
1094}
1095
1096int PS2MConstruct(PPS2M pThis, PPDMDEVINS pDevIns, void *pParent, int iInstance)
1097{
1098 int rc;
1099
1100 LogFlowFunc(("iInstance=%d\n", iInstance));
1101
1102 pThis->pParent = pParent;
1103
1104 /* Initialize the queues. */
1105 pThis->evtQ.cSize = AUX_EVT_QUEUE_SIZE;
1106 pThis->cmdQ.cSize = AUX_CMD_QUEUE_SIZE;
1107
1108 pThis->Mouse.IBase.pfnQueryInterface = ps2mQueryInterface;
1109 pThis->Mouse.IPort.pfnPutEvent = ps2mPutEvent;
1110 pThis->Mouse.IPort.pfnPutEventAbs = ps2mPutEventAbs;
1111 pThis->Mouse.IPort.pfnPutEventMultiTouch = ps2mPutEventMT;
1112
1113 /*
1114 * Initialize the critical section pointer(s).
1115 */
1116 pThis->pCritSectR3 = pDevIns->pCritSectRoR3;
1117
1118 /*
1119 * Create the input rate throttling timer. Does not use virtual time!
1120 */
1121 PTMTIMER pTimer;
1122 rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_REAL, ps2mThrottleTimer, pThis,
1123 TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "PS2M Throttle Timer", &pTimer);
1124 if (RT_FAILURE(rc))
1125 return rc;
1126
1127 pThis->pThrottleTimerR3 = pTimer;
1128 pThis->pThrottleTimerR0 = TMTimerR0Ptr(pTimer);
1129 pThis->pThrottleTimerRC = TMTimerRCPtr(pTimer);
1130
1131 /*
1132 * Create the command delay timer.
1133 */
1134 rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, ps2mDelayTimer, pThis,
1135 TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "PS2M Delay Timer", &pTimer);
1136 if (RT_FAILURE(rc))
1137 return rc;
1138
1139 pThis->pDelayTimerR3 = pTimer;
1140 pThis->pDelayTimerR0 = TMTimerR0Ptr(pTimer);
1141 pThis->pDelayTimerRC = TMTimerRCPtr(pTimer);
1142
1143 /*
1144 * Register debugger info callbacks.
1145 */
1146 PDMDevHlpDBGFInfoRegister(pDevIns, "ps2m", "Display PS/2 mouse state.", ps2mInfoState);
1147
1148 //@todo: Where should we do this?
1149 ps2mSetDriverState(pThis, true);
1150 pThis->u8State = 0;
1151 pThis->enmMode = AUX_MODE_STD;
1152
1153 return rc;
1154}
1155
1156#endif
1157
1158#endif /* !VBOX_DEVICE_STRUCT_TESTCASE */
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette