VirtualBox

source: vbox/trunk/src/VBox/Devices/Input/DevPS2M.cpp@ 98102

Last change on this file since 98102 was 96407, checked in by vboxsync, 2 years ago

scm copyright and license note update
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 45.3 KB
Line 
1/* $Id: DevPS2M.cpp 96407 2022-08-22 17:43:14Z vboxsync $ */
2/** @file
3 * PS2M - PS/2 auxiliary device (mouse) emulation.
4 */
5
6/*
7 * Copyright (C) 2007-2022 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.virtualbox.org.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation, in version 3 of the
15 * License.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <https://www.gnu.org/licenses>.
24 *
25 * SPDX-License-Identifier: GPL-3.0-only
26 */
27
28/*
29 * References:
30 *
31 * The Undocumented PC (2nd Ed.), Frank van Gilluwe, Addison-Wesley, 1996.
32 * IBM TrackPoint System Version 4.0 Engineering Specification, 1999.
33 * ELAN Microelectronics eKM8025 USB & PS/2 Mouse Controller, 2006.
34 *
35 *
36 * Notes:
37 *
38 * - The auxiliary device commands are very similar to keyboard commands.
39 * Most keyboard commands which do not specifically deal with the keyboard
40 * (enable, disable, reset) have identical counterparts.
41 * - The code refers to 'auxiliary device' and 'mouse'; these terms are not
42 * quite interchangeable. 'Auxiliary device' is used when referring to the
43 * generic PS/2 auxiliary device interface and 'mouse' when referring to
44 * a mouse attached to the auxiliary port.
45 * - The basic modes of operation are reset, stream, and remote. Those are
46 * mutually exclusive. Stream and remote modes can additionally have wrap
47 * mode enabled.
48 * - The auxiliary device sends unsolicited data to the host only when it is
49 * both in stream mode and enabled. Otherwise it only responds to commands.
50 *
51 *
52 * There are three report packet formats supported by the emulated device. The
53 * standard three-byte PS/2 format (with middle button support), IntelliMouse
54 * four-byte format with added scroll wheel, and IntelliMouse Explorer four-byte
55 * format with reduced scroll wheel range but two additional buttons. Note that
56 * the first three bytes of the report are always the same.
57 *
58 * Upon reset, the mouse is always in the standard PS/2 mode. A special 'knock'
59 * sequence can be used to switch to ImPS/2 or ImEx mode. Three consecutive
60 * Set Sampling Rate (0F3h) commands with arguments 200, 100, 80 switch to ImPS/2
61 * mode. While in ImPS/2 or PS/2 mode, three consecutive Set Sampling Rate
62 * commands with arguments 200, 200, 80 switch to ImEx mode. The Read ID (0F2h)
63 * command will report the currently selected protocol.
64 *
65 * There is an extended ImEx mode with support for horizontal scrolling. It is
66 * entered from ImEx mode with a 200, 80, 40 sequence of Set Sampling Rate
67 * commands. It does not change the reported protocol (it remains 4, or ImEx)
68 * but changes the meaning of the 4th byte.
69 *
70 *
71 * Standard PS/2 pointing device three-byte report packet format:
72 *
73 * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
74 * |Bit/byte| bit 7 | bit 6 | bit 5 | bit 4 | bit 3 | bit 2 | bit 1 | bit 0 |
75 * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
76 * | Byte 1 | Y ovfl | X ovfl | Y sign | X sign | Sync | M btn | R btn | L btn |
77 * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
78 * | Byte 2 | X movement delta (two's complement) |
79 * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
80 * | Byte 3 | Y movement delta (two's complement) |
81 * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
82 *
83 * - The sync bit is always set. It allows software to synchronize data packets
84 * as the X/Y position data typically does not have bit 4 set.
85 * - The overflow bits are set if motion exceeds accumulator range. We use the
86 * maximum range (effectively 9 bits) and do not set the overflow bits.
87 * - Movement in the up/right direction is defined as having positive sign.
88 *
89 *
90 * IntelliMouse PS/2 (ImPS/2) fourth report packet byte:
91 *
92 * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
93 * |Bit/byte| bit 7 | bit 6 | bit 5 | bit 4 | bit 3 | bit 2 | bit 1 | bit 0 |
94 * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
95 * | Byte 4 | Z movement delta (two's complement) |
96 * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
97 *
98 * - The valid range for Z delta values is only -8/+7, i.e. 4 bits.
99 *
100 * IntelliMouse Explorer (ImEx) fourth report packet byte:
101 *
102 * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
103 * |Bit/byte| bit 7 | bit 6 | bit 5 | bit 4 | bit 3 | bit 2 | bit 1 | bit 0 |
104 * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
105 * | Byte 4 | 0 | 0 | Btn 5 | Btn 4 | Z mov't delta (two's complement) |
106 * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
107 *
108 * - The Z delta values are in practice only -1/+1; some mice (A4tech?) report
109 * horizontal scrolling as -2/+2.
110 *
111 * IntelliMouse Explorer (ImEx) fourth report packet byte when scrolling:
112 *
113 * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
114 * |Bit/byte| bit 7 | bit 6 | bit 5 | bit 4 | bit 3 | bit 2 | bit 1 | bit 0 |
115 * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
116 * | Byte 4 | V | H | Z or W movement delta (two's complement) |
117 * +--------+--------+--------+--------+--------+--------+--------+--------+--------+
118 *
119 * - Buttons 4 and 5 are reported as with the regular ImEx protocol, but not when
120 * scrolling. This is a departure from the usual logic because when the mouse
121 * sends scroll events, the state of buttons 4/5 is not reported and the last
122 * reported state should be assumed.
123 *
124 * - When the V bit (bit 7) is set, vertical scroll (Z axis) is being reported.
125 * When the H bit (bit 6) is set, horizontal scroll (W axis) is being reported.
126 * The H and V bits are never set at the same time (also see below). When
127 * the H and V bits are both clear, button 4/5 state is being reported.
128 *
129 * - The Z/W delta is extended to 6 bits. Z (vertical) values are not restricted
130 * to -1/+1, although W (horizontal) values are. Z values of at least -20/+20
131 * can be seen in practice.
132 *
133 * - Horizontal and vertical scroll is mutually exclusive. When the button is
134 * tilted, no vertical scrolling is reported, i.e. horizontal scrolling
135 * has priority over vertical.
136 *
137 * - Positive values indicate down/right direction, negative values up/left.
138 *
139 * - When the scroll button is tilted to engage horizontal scrolling, the mouse
140 * keeps sending events at a rate of 4 or 5 per second as long as the button
141 * is tilted.
142 *
143 * All report formats were verified with a real Microsoft IntelliMouse Explorer 4.0
144 * mouse attached through a PS/2 port.
145 *
146 * The button "accumulator" is necessary to avoid missing brief button presses.
147 * Without it, a very fast mouse button press + release might be lost if it
148 * happened between sending reports. The accumulator latches button presses to
149 * prevent that.
150 *
151 */
152
153
154/*********************************************************************************************************************************
155* Header Files *
156*********************************************************************************************************************************/
157#define LOG_GROUP LOG_GROUP_DEV_KBD
158#include <VBox/vmm/pdmdev.h>
159#include <VBox/err.h>
160#include <iprt/assert.h>
161#include <iprt/uuid.h>
162#include "VBoxDD.h"
163#define IN_PS2M
164#include "DevPS2.h"
165
166
167/*********************************************************************************************************************************
168* Defined Constants And Macros *
169*********************************************************************************************************************************/
170/** @name Auxiliary device commands sent by the system.
171 * @{ */
172#define ACMD_SET_SCALE_11 0xE6 /* Set 1:1 scaling. */
173#define ACMD_SET_SCALE_21 0xE7 /* Set 2:1 scaling. */
174#define ACMD_SET_RES 0xE8 /* Set resolution. */
175#define ACMD_REQ_STATUS 0xE9 /* Get device status. */
176#define ACMD_SET_STREAM 0xEA /* Set stream mode. */
177#define ACMD_READ_REMOTE 0xEB /* Read remote data. */
178#define ACMD_RESET_WRAP 0xEC /* Exit wrap mode. */
179#define ACMD_INVALID_1 0xED
180#define ACMD_SET_WRAP 0xEE /* Set wrap (echo) mode. */
181#define ACMD_INVALID_2 0xEF
182#define ACMD_SET_REMOTE 0xF0 /* Set remote mode. */
183#define ACMD_INVALID_3 0xF1
184#define ACMD_READ_ID 0xF2 /* Read device ID. */
185#define ACMD_SET_SAMP_RATE 0xF3 /* Set sampling rate. */
186#define ACMD_ENABLE 0xF4 /* Enable (streaming mode). */
187#define ACMD_DISABLE 0xF5 /* Disable (streaming mode). */
188#define ACMD_SET_DEFAULT 0xF6 /* Set defaults. */
189#define ACMD_INVALID_4 0xF7
190#define ACMD_INVALID_5 0xF8
191#define ACMD_INVALID_6 0xF9
192#define ACMD_INVALID_7 0xFA
193#define ACMD_INVALID_8 0xFB
194#define ACMD_INVALID_9 0xFC
195#define ACMD_INVALID_10 0xFD
196#define ACMD_RESEND 0xFE /* Resend response. */
197#define ACMD_RESET 0xFF /* Reset device. */
198/** @} */
199
200/** @name Auxiliary device responses sent to the system.
201 * @{ */
202#define ARSP_ID 0x00
203#define ARSP_BAT_OK 0xAA /* Self-test passed. */
204#define ARSP_ACK 0xFA /* Command acknowledged. */
205#define ARSP_ERROR 0xFC /* Bad command. */
206#define ARSP_RESEND 0xFE /* Requesting resend. */
207/** @} */
208
209
210/*********************************************************************************************************************************
211* Test code function declarations *
212*********************************************************************************************************************************/
213#if defined(RT_STRICT) && defined(IN_RING3)
214static void ps2mR3TestAccumulation(void);
215#endif
216
217
218#ifdef IN_RING3
219
220/* Report a change in status down (or is it up?) the driver chain. */
221static void ps2mR3SetDriverState(PPS2MR3 pThisCC, bool fEnabled)
222{
223 PPDMIMOUSECONNECTOR pDrv = pThisCC->Mouse.pDrv;
224 if (pDrv)
225 pDrv->pfnReportModes(pDrv, fEnabled, false, false, false);
226}
227
228/* Reset the pointing device. */
229static void ps2mR3Reset(PPS2M pThis, PPS2MR3 pThisCC)
230{
231 LogFlowFunc(("Reset"));
232
233 PS2Q_INSERT(&pThis->cmdQ, ARSP_BAT_OK);
234 PS2Q_INSERT(&pThis->cmdQ, 0);
235 pThis->enmMode = AUX_MODE_STD;
236 pThis->u8CurrCmd = 0;
237
238 /// @todo move to its proper home!
239 ps2mR3SetDriverState(pThisCC, true);
240}
241
242#endif /* IN_RING3 */
243
244static void ps2mSetRate(PPS2M pThis, uint8_t rate)
245{
246 Assert(rate);
247 pThis->uThrottleDelay = rate ? 1000 / rate : 0;
248 pThis->u8SampleRate = rate;
249 LogFlowFunc(("Sampling rate %u, throttle delay %u ms\n", pThis->u8SampleRate, pThis->uThrottleDelay));
250}
251
252static void ps2mSetDefaults(PPS2M pThis)
253{
254 LogFlowFunc(("Set mouse defaults\n"));
255 /* Standard protocol, reporting disabled, resolution 2, 1:1 scaling. */
256 pThis->enmProtocol = PS2M_PROTO_PS2STD;
257 pThis->u8State = 0;
258 pThis->u8Resolution = 2;
259
260 /* Sample rate 100 reports per second. */
261 ps2mSetRate(pThis, 100);
262
263 /* Event queue, eccumulators, and button status bits are cleared. */
264 PS2Q_CLEAR(&pThis->evtQ);
265 pThis->iAccumX = pThis->iAccumY = pThis->iAccumZ = pThis->iAccumW = pThis->fAccumB = 0;
266}
267
268/* Handle the sampling rate 'knock' sequence which selects protocol. */
269static void ps2mRateProtocolKnock(PPS2M pThis, uint8_t rate)
270{
271 PS2M_PROTO enmOldProtocol = pThis->enmProtocol;
272 LogFlowFunc(("rate=%u\n", rate));
273
274 switch (pThis->enmKnockState)
275 {
276 case PS2M_KNOCK_INITIAL:
277 if (rate == 200)
278 pThis->enmKnockState = PS2M_KNOCK_1ST;
279 break;
280 case PS2M_KNOCK_1ST:
281 if (rate == 100)
282 pThis->enmKnockState = PS2M_KNOCK_IMPS2_2ND;
283 else if (rate == 200)
284 pThis->enmKnockState = PS2M_KNOCK_IMEX_2ND;
285 else if (rate == 80)
286 pThis->enmKnockState = PS2M_KNOCK_IMEX_HORZ_2ND;
287 else
288 pThis->enmKnockState = PS2M_KNOCK_INITIAL;
289 break;
290 case PS2M_KNOCK_IMPS2_2ND:
291 if (rate == 80)
292 {
293 pThis->enmProtocol = PS2M_PROTO_IMPS2;
294 LogRelFlow(("PS2M: Switching mouse to ImPS/2 protocol.\n"));
295 }
296 pThis->enmKnockState = PS2M_KNOCK_INITIAL;
297 break;
298 case PS2M_KNOCK_IMEX_2ND:
299 if (rate == 80)
300 {
301 pThis->enmProtocol = PS2M_PROTO_IMEX;
302 LogRelFlow(("PS2M: Switching mouse to ImEx protocol.\n"));
303 }
304 pThis->enmKnockState = PS2M_KNOCK_INITIAL;
305 break;
306 case PS2M_KNOCK_IMEX_HORZ_2ND:
307 if (rate == 40)
308 {
309 pThis->enmProtocol = PS2M_PROTO_IMEX_HORZ;
310 LogRelFlow(("PS2M: Switching mouse ImEx with horizontal scrolling.\n"));
311 }
312 RT_FALL_THRU();
313 default:
314 pThis->enmKnockState = PS2M_KNOCK_INITIAL;
315 }
316
317 /* If the protocol changed, throw away any queued input because it now
318 * has the wrong format, which could severely confuse the guest.
319 */
320 if (enmOldProtocol != pThis->enmProtocol)
321 PS2Q_CLEAR(&pThis->evtQ);
322}
323
324/* Three-button event mask. */
325#define PS2M_STD_BTN_MASK (RT_BIT(0) | RT_BIT(1) | RT_BIT(2))
326/* ImEx button 4/5 event mask. */
327#define PS2M_IMEX_BTN_MASK (RT_BIT(3) | RT_BIT(4))
328
329/** Report accumulated movement and button presses, then clear the accumulators. */
330static void ps2mReportAccumulatedEvents(PPS2M pThis, PPS2QHDR pQHdr, size_t cQElements, uint8_t *pbQElements, bool fAccumBtns)
331{
332 uint32_t fBtnState = fAccumBtns ? pThis->fAccumB : pThis->fCurrB;
333 uint8_t val;
334 int dX, dY, dZ, dW;
335
336 LogFlowFunc(("cQElements=%zu, fAccumBtns=%RTbool\n", cQElements, fAccumBtns));
337
338 /* Clamp the accumulated delta values to the allowed range. */
339 dX = RT_MIN(RT_MAX(pThis->iAccumX, -255), 255);
340 dY = RT_MIN(RT_MAX(pThis->iAccumY, -255), 255);
341
342 /* Start with the sync bit and buttons 1-3. */
343 val = RT_BIT(3) | (fBtnState & PS2M_STD_BTN_MASK);
344 /* Set the X/Y sign bits. */
345 if (dX < 0)
346 val |= RT_BIT(4);
347 if (dY < 0)
348 val |= RT_BIT(5);
349
350 /* Send the standard 3-byte packet (always the same). */
351 LogFlowFunc(("Queuing standard 3-byte packet\n"));
352 PS2CmnInsertQueue(pQHdr, cQElements, pbQElements, val);
353 PS2CmnInsertQueue(pQHdr, cQElements, pbQElements, dX);
354 PS2CmnInsertQueue(pQHdr, cQElements, pbQElements, dY);
355
356 /* Add fourth byte if an extended protocol is in use. */
357 if (pThis->enmProtocol > PS2M_PROTO_PS2STD)
358 {
359 /* Start out with 4-bit dZ range. */
360 dZ = RT_MIN(RT_MAX(pThis->iAccumZ, -8), 7);
361
362 if (pThis->enmProtocol == PS2M_PROTO_IMPS2)
363 {
364 /* NB: Only uses 4-bit dZ range, despite using a full byte. */
365 LogFlowFunc(("Queuing ImPS/2 last byte\n"));
366 PS2CmnInsertQueue(pQHdr, cQElements, pbQElements, dZ);
367 pThis->iAccumZ -= dZ;
368 }
369 else if (pThis->enmProtocol == PS2M_PROTO_IMEX)
370 {
371 /* Z value uses 4 bits; buttons 4/5 in bits 4 and 5. */
372 val = (fBtnState & PS2M_IMEX_BTN_MASK) << 1;
373 val |= dZ & 0x0f;
374 pThis->iAccumZ -= dZ;
375 LogFlowFunc(("Queuing ImEx last byte\n"));
376 PS2CmnInsertQueue(pQHdr, cQElements, pbQElements, val);
377 }
378 else
379 {
380 Assert((pThis->enmProtocol == PS2M_PROTO_IMEX_HORZ));
381 /* With ImEx + horizontal reporting, prioritize buttons 4/5. */
382 if (pThis->iAccumZ || pThis->iAccumW)
383 {
384 /* ImEx + horizontal reporting Horizontal scroll has
385 * precedence over vertical. Buttons cannot be reported
386 * this way.
387 */
388 if (pThis->iAccumW)
389 {
390 dW = RT_MIN(RT_MAX(pThis->iAccumW, -32), 31);
391 val = (dW & 0x3F) | 0x40;
392 pThis->iAccumW -= dW;
393 }
394 else
395 {
396 Assert(pThis->iAccumZ);
397 /* We can use 6-bit dZ range. Wow! */
398 dZ = RT_MIN(RT_MAX(pThis->iAccumZ, -32), 31);
399 val = (dZ & 0x3F) | 0x80;
400 pThis->iAccumZ -= dZ;
401 }
402 }
403 else
404 {
405 /* Just Buttons 4/5 in bits 4 and 5. No scrolling. */
406 val = (fBtnState & PS2M_IMEX_BTN_MASK) << 1;
407 }
408 LogFlowFunc(("Queuing ImEx+horz last byte\n"));
409 PS2CmnInsertQueue(pQHdr, cQElements, pbQElements, val);
410 }
411 }
412
413 /* Clear the movement accumulators, but not necessarily button state. */
414 pThis->iAccumX = pThis->iAccumY = 0;
415 /* Clear accumulated button state only when it's being used. */
416 if (fAccumBtns)
417 {
418 pThis->fReportedB = pThis->fCurrB | pThis->fAccumB;
419 pThis->fAccumB = 0;
420 }
421}
422
423
424/* Determine whether a reporting rate is one of the valid ones. */
425bool ps2mIsRateSupported(uint8_t rate)
426{
427 static uint8_t aValidRates[] = { 10, 20, 40, 60, 80, 100, 200 };
428 size_t i;
429 bool fValid = false;
430
431 for (i = 0; i < RT_ELEMENTS(aValidRates); ++i)
432 if (aValidRates[i] == rate)
433 {
434 fValid = true;
435 break;
436 }
437
438 return fValid;
439}
440
441
442/**
443 * The keyboard controller disabled the auxiliary serial line.
444 *
445 * @param pThis The PS/2 auxiliary device shared instance data.
446 */
447void PS2MLineDisable(PPS2M pThis)
448{
449 LogFlowFunc(("Disabling mouse serial line\n"));
450
451 pThis->fLineDisabled = true;
452}
453
454/**
455 * The keyboard controller enabled the auxiliary serial line.
456 *
457 * @param pThis The PS/2 auxiliary device shared instance data.
458 */
459void PS2MLineEnable(PPS2M pThis)
460{
461 LogFlowFunc(("Enabling mouse serial line\n"));
462
463 pThis->fLineDisabled = false;
464
465 /* If there was anything in the input queue,
466 * consider it lost and throw it away.
467 */
468 PS2Q_CLEAR(&pThis->evtQ);
469}
470
471
472/**
473 * Receive and process a byte sent by the keyboard controller.
474 *
475 * @param pDevIns The device instance.
476 * @param pThis The PS/2 auxiliary device shared instance data.
477 * @param cmd The command (or data) byte.
478 */
479int PS2MByteToAux(PPDMDEVINS pDevIns, PPS2M pThis, uint8_t cmd)
480{
481 uint8_t u8Val;
482 bool fHandled = true;
483
484 LogFlowFunc(("cmd=0x%02X, active cmd=0x%02X\n", cmd, pThis->u8CurrCmd));
485
486 if (pThis->enmMode == AUX_MODE_RESET)
487 /* In reset mode, do not respond at all. */
488 return VINF_SUCCESS;
489
490 /* If there's anything left in the command response queue, trash it. */
491 PS2Q_CLEAR(&pThis->cmdQ);
492
493 if (pThis->enmMode == AUX_MODE_WRAP)
494 {
495 /* In wrap mode, bounce most data right back.*/
496 if (cmd == ACMD_RESET || cmd == ACMD_RESET_WRAP)
497 ; /* Handle as regular commands. */
498 else
499 {
500 PS2Q_INSERT(&pThis->cmdQ, cmd);
501 return VINF_SUCCESS;
502 }
503 }
504
505#ifndef IN_RING3
506 /* Reset, Enable, and Set Default commands must be run in R3. */
507 if (cmd == ACMD_RESET || cmd == ACMD_ENABLE || cmd == ACMD_SET_DEFAULT)
508 return VINF_IOM_R3_IOPORT_WRITE;
509#endif
510
511 switch (cmd)
512 {
513 case ACMD_SET_SCALE_11:
514 pThis->u8State &= ~AUX_STATE_SCALING;
515 PS2Q_INSERT(&pThis->cmdQ, ARSP_ACK);
516 pThis->u8CurrCmd = 0;
517 break;
518 case ACMD_SET_SCALE_21:
519 pThis->u8State |= AUX_STATE_SCALING;
520 PS2Q_INSERT(&pThis->cmdQ, ARSP_ACK);
521 pThis->u8CurrCmd = 0;
522 break;
523 case ACMD_REQ_STATUS:
524 /* Report current status, sample rate, and resolution. */
525 u8Val = (pThis->u8State & AUX_STATE_EXTERNAL) | (pThis->fCurrB & PS2M_STD_BTN_MASK);
526 PS2Q_INSERT(&pThis->cmdQ, ARSP_ACK);
527 PS2Q_INSERT(&pThis->cmdQ, u8Val);
528 PS2Q_INSERT(&pThis->cmdQ, pThis->u8Resolution);
529 PS2Q_INSERT(&pThis->cmdQ, pThis->u8SampleRate);
530 pThis->u8CurrCmd = 0;
531 break;
532 case ACMD_SET_STREAM:
533 pThis->u8State &= ~AUX_STATE_REMOTE;
534 PS2Q_INSERT(&pThis->cmdQ, ARSP_ACK);
535 pThis->u8CurrCmd = 0;
536 break;
537 case ACMD_READ_REMOTE:
538 PS2Q_INSERT(&pThis->cmdQ, ARSP_ACK);
539 ps2mReportAccumulatedEvents(pThis, &pThis->cmdQ.Hdr, RT_ELEMENTS(pThis->cmdQ.abQueue), pThis->cmdQ.abQueue, false);
540 pThis->u8CurrCmd = 0;
541 break;
542 case ACMD_RESET_WRAP:
543 pThis->enmMode = AUX_MODE_STD;
544 /* NB: Stream mode reporting remains disabled! */
545 PS2Q_INSERT(&pThis->cmdQ, ARSP_ACK);
546 pThis->u8CurrCmd = 0;
547 break;
548 case ACMD_SET_WRAP:
549 pThis->enmMode = AUX_MODE_WRAP;
550 pThis->u8State &= ~AUX_STATE_ENABLED;
551 PS2Q_INSERT(&pThis->cmdQ, ARSP_ACK);
552 pThis->u8CurrCmd = 0;
553 break;
554 case ACMD_SET_REMOTE:
555 pThis->u8State |= AUX_STATE_REMOTE;
556 PS2Q_INSERT(&pThis->cmdQ, ARSP_ACK);
557 pThis->u8CurrCmd = 0;
558 break;
559 case ACMD_READ_ID:
560 PS2Q_INSERT(&pThis->cmdQ, ARSP_ACK);
561 /* ImEx + horizontal is protocol 4, just like plain ImEx. */
562 u8Val = pThis->enmProtocol == PS2M_PROTO_IMEX_HORZ ? PS2M_PROTO_IMEX : pThis->enmProtocol;
563 PS2Q_INSERT(&pThis->cmdQ, u8Val);
564 pThis->u8CurrCmd = 0;
565 break;
566 case ACMD_ENABLE:
567 pThis->u8State |= AUX_STATE_ENABLED;
568#ifdef IN_RING3
569 ps2mR3SetDriverState(&PDMDEVINS_2_DATA_CC(pDevIns, PKBDSTATER3)->Aux, true);
570#else
571 AssertLogRelMsgFailed(("Invalid ACMD_ENABLE outside R3!\n"));
572#endif
573 PS2Q_CLEAR(&pThis->evtQ);
574 PS2Q_INSERT(&pThis->cmdQ, ARSP_ACK);
575 pThis->u8CurrCmd = 0;
576 break;
577 case ACMD_DISABLE:
578 pThis->u8State &= ~AUX_STATE_ENABLED;
579 PS2Q_INSERT(&pThis->cmdQ, ARSP_ACK);
580 pThis->u8CurrCmd = 0;
581 break;
582 case ACMD_SET_DEFAULT:
583 ps2mSetDefaults(pThis);
584 PS2Q_INSERT(&pThis->cmdQ, ARSP_ACK);
585 pThis->u8CurrCmd = 0;
586 break;
587 case ACMD_RESEND:
588 pThis->u8CurrCmd = 0;
589 break;
590 case ACMD_RESET:
591 ps2mSetDefaults(pThis);
592 /// @todo reset more?
593 pThis->u8CurrCmd = cmd;
594 pThis->enmMode = AUX_MODE_RESET;
595 PS2Q_INSERT(&pThis->cmdQ, ARSP_ACK);
596 if (pThis->fDelayReset)
597 /* Slightly delay reset completion; it might take hundreds of ms. */
598 PDMDevHlpTimerSetMillies(pDevIns, pThis->hDelayTimer, 1);
599 else
600#ifdef IN_RING3
601 ps2mR3Reset(pThis, &PDMDEVINS_2_DATA_CC(pDevIns, PKBDSTATER3)->Aux);
602#else
603 AssertLogRelMsgFailed(("Invalid ACMD_RESET outside R3!\n"));
604#endif
605 break;
606 /* The following commands need a parameter. */
607 case ACMD_SET_RES:
608 case ACMD_SET_SAMP_RATE:
609 PS2Q_INSERT(&pThis->cmdQ, ARSP_ACK);
610 pThis->u8CurrCmd = cmd;
611 break;
612 default:
613 /* Sending a command instead of a parameter starts the new command. */
614 switch (pThis->u8CurrCmd)
615 {
616 case ACMD_SET_RES:
617 if (cmd < 4) /* Valid resolutions are 0-3. */
618 {
619 pThis->u8Resolution = cmd;
620 pThis->u8State &= ~AUX_STATE_RES_ERR;
621 PS2Q_INSERT(&pThis->cmdQ, ARSP_ACK);
622 pThis->u8CurrCmd = 0;
623 }
624 else
625 {
626 /* Bad resolution. Reply with Resend or Error. */
627 if (pThis->u8State & AUX_STATE_RES_ERR)
628 {
629 pThis->u8State &= ~AUX_STATE_RES_ERR;
630 PS2Q_INSERT(&pThis->cmdQ, ARSP_ERROR);
631 pThis->u8CurrCmd = 0;
632 }
633 else
634 {
635 pThis->u8State |= AUX_STATE_RES_ERR;
636 PS2Q_INSERT(&pThis->cmdQ, ARSP_RESEND);
637 /* NB: Current command remains unchanged. */
638 }
639 }
640 break;
641 case ACMD_SET_SAMP_RATE:
642 if (ps2mIsRateSupported(cmd))
643 {
644 pThis->u8State &= ~AUX_STATE_RATE_ERR;
645 ps2mSetRate(pThis, cmd);
646 ps2mRateProtocolKnock(pThis, cmd);
647 PS2Q_INSERT(&pThis->cmdQ, ARSP_ACK);
648 pThis->u8CurrCmd = 0;
649 }
650 else
651 {
652 /* Bad rate. Reply with Resend or Error. */
653 if (pThis->u8State & AUX_STATE_RATE_ERR)
654 {
655 pThis->u8State &= ~AUX_STATE_RATE_ERR;
656 PS2Q_INSERT(&pThis->cmdQ, ARSP_ERROR);
657 pThis->u8CurrCmd = 0;
658 }
659 else
660 {
661 pThis->u8State |= AUX_STATE_RATE_ERR;
662 PS2Q_INSERT(&pThis->cmdQ, ARSP_RESEND);
663 /* NB: Current command remains unchanged. */
664 }
665 }
666 break;
667 default:
668 fHandled = false;
669 }
670 /* Fall through only to handle unrecognized commands. */
671 if (fHandled)
672 break;
673 RT_FALL_THRU();
674
675 case ACMD_INVALID_1:
676 case ACMD_INVALID_2:
677 case ACMD_INVALID_3:
678 case ACMD_INVALID_4:
679 case ACMD_INVALID_5:
680 case ACMD_INVALID_6:
681 case ACMD_INVALID_7:
682 case ACMD_INVALID_8:
683 case ACMD_INVALID_9:
684 case ACMD_INVALID_10:
685 Log(("Unsupported command 0x%02X!\n", cmd));
686 PS2Q_INSERT(&pThis->cmdQ, ARSP_RESEND);
687 pThis->u8CurrCmd = 0;
688 break;
689 }
690 LogFlowFunc(("Active cmd now 0x%02X; updating interrupts\n", pThis->u8CurrCmd));
691 return VINF_SUCCESS;
692}
693
694/**
695 * Send a byte (packet data or command response) to the keyboard controller.
696 *
697 * @returns VINF_SUCCESS or VINF_TRY_AGAIN.
698 * @param pThis The PS/2 auxiliary device shared instance data.
699 * @param pb Where to return the byte we've read.
700 * @remarks Caller must have entered the device critical section.
701 */
702int PS2MByteFromAux(PPS2M pThis, uint8_t *pb)
703{
704 int rc;
705
706 AssertPtr(pb);
707
708 /* Anything in the command queue has priority over data
709 * in the event queue. Additionally, packet data are
710 * blocked if a command is currently in progress, even if
711 * the command queue is empty.
712 */
713 /// @todo Probably should flush/not fill queue if stream mode reporting disabled?!
714 rc = PS2Q_REMOVE(&pThis->cmdQ, pb);
715 if (rc != VINF_SUCCESS && !pThis->u8CurrCmd && (pThis->u8State & AUX_STATE_ENABLED))
716 rc = PS2Q_REMOVE(&pThis->evtQ, pb);
717
718 LogFlowFunc(("mouse sends 0x%02x (%svalid data)\n", *pb, rc == VINF_SUCCESS ? "" : "not "));
719
720 return rc;
721}
722
723#ifdef IN_RING3
724
725/** Is there any state change to send as events to the guest? */
726static uint32_t ps2mR3HaveEvents(PPS2M pThis)
727{
728/** @todo r=bird: Why is this returning uint32_t when you're calculating a
729 * boolean value here? Also, it's a predicate function... */
730 return pThis->iAccumX || pThis->iAccumY || pThis->iAccumZ || pThis->iAccumW
731 || ((pThis->fCurrB | pThis->fAccumB) != pThis->fReportedB);
732}
733
734/**
735 * @callback_method_impl{FNTMTIMERDEV,
736 * Event rate throttling timer to emulate the auxiliary device sampling rate.}
737 */
738static DECLCALLBACK(void) ps2mR3ThrottleTimer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
739{
740 PPS2M pThis = (PS2M *)pvUser;
741 uint32_t uHaveEvents;
742 Assert(hTimer == pThis->hThrottleTimer);
743 Assert(PDMDevHlpCritSectIsOwner(pDevIns, pDevIns->pCritSectRoR3));
744
745 /* If more movement is accumulated, report it and restart the timer. */
746 uHaveEvents = ps2mR3HaveEvents(pThis);
747 LogFlowFunc(("Have%s events\n", uHaveEvents ? "" : " no"));
748
749 if (uHaveEvents)
750 {
751 /* Report accumulated data, poke the KBC, and start the timer. */
752 ps2mReportAccumulatedEvents(pThis, &pThis->evtQ.Hdr, RT_ELEMENTS(pThis->evtQ.abQueue), pThis->evtQ.abQueue, true);
753 KBCUpdateInterrupts(pDevIns);
754 PDMDevHlpTimerSetMillies(pDevIns, hTimer, pThis->uThrottleDelay);
755 }
756 else
757 pThis->fThrottleActive = false;
758}
759
760/**
761 * @callback_method_impl{FNTMTIMERDEV}
762 *
763 * The auxiliary device reset is specified to take up to about 500 milliseconds.
764 * We need to delay sending the result to the host for at least a tiny little
765 * while.
766 */
767static DECLCALLBACK(void) ps2mR3DelayTimer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
768{
769 PPS2M pThis = &PDMDEVINS_2_DATA(pDevIns, PKBDSTATE)->Aux;
770 PPS2MR3 pThisCC = &PDMDEVINS_2_DATA_CC(pDevIns, PKBDSTATER3)->Aux;
771 RT_NOREF(pvUser, hTimer);
772
773 LogFlowFunc(("Delay timer: cmd %02X\n", pThis->u8CurrCmd));
774
775 Assert(pThis->u8CurrCmd == ACMD_RESET);
776 ps2mR3Reset(pThis, pThisCC);
777
778 /// @todo Might want a PS2MCompleteCommand() to push last response, clear command, and kick the KBC...
779 /* Give the KBC a kick. */
780 KBCUpdateInterrupts(pDevIns);
781}
782
783
784/**
785 * Debug device info handler. Prints basic auxiliary device state.
786 *
787 * @param pDevIns Device instance which registered the info.
788 * @param pHlp Callback functions for doing output.
789 * @param pszArgs Argument string. Optional and specific to the handler.
790 */
791static DECLCALLBACK(void) ps2mR3InfoState(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
792{
793 static const char * const s_apcszModes[] = { "normal", "reset", "wrap" };
794 static const char * const s_apcszProtocols[] = { "PS/2", NULL, NULL, "ImPS/2", "ImEx", "ImEx+horizontal" };
795 PKBDSTATE pParent = PDMDEVINS_2_DATA(pDevIns, PKBDSTATE);
796 PPS2M pThis = &pParent->Aux;
797 NOREF(pszArgs);
798
799 Assert(pThis->enmMode < RT_ELEMENTS(s_apcszModes));
800 pHlp->pfnPrintf(pHlp, "PS/2 mouse state: %s, %s mode, reporting %s, serial line %s\n",
801 s_apcszModes[pThis->enmMode],
802 pThis->u8State & AUX_STATE_REMOTE ? "remote" : "stream",
803 pThis->u8State & AUX_STATE_ENABLED ? "enabled" : "disabled",
804 pThis->fLineDisabled ? "disabled" : "enabled");
805 Assert(pThis->enmProtocol < RT_ELEMENTS(s_apcszProtocols));
806 pHlp->pfnPrintf(pHlp, "Protocol: %s, scaling %u:1\n",
807 s_apcszProtocols[pThis->enmProtocol],
808 pThis->u8State & AUX_STATE_SCALING ? 2 : 1);
809 pHlp->pfnPrintf(pHlp, "Active command %02X\n", pThis->u8CurrCmd);
810 pHlp->pfnPrintf(pHlp, "Sampling rate %u reports/sec, resolution %u counts/mm\n",
811 pThis->u8SampleRate, 1 << pThis->u8Resolution);
812 pHlp->pfnPrintf(pHlp, "Command queue: %d items (%d max)\n",
813 PS2Q_COUNT(&pThis->cmdQ), PS2Q_SIZE(&pThis->cmdQ));
814 pHlp->pfnPrintf(pHlp, "Event queue : %d items (%d max)\n",
815 PS2Q_COUNT(&pThis->evtQ), PS2Q_SIZE(&pThis->evtQ));
816}
817
818
819/* -=-=-=-=-=- Mouse: IMousePort -=-=-=-=-=- */
820
821/**
822 * Mouse event handler.
823 *
824 * @returns VBox status code.
825 * @param pDevIns The device instance.
826 * @param pThis The PS/2 auxiliary device shared instance data.
827 * @param dx X direction movement delta.
828 * @param dy Y direction movement delta.
829 * @param dz Z (vertical scroll) movement delta.
830 * @param dw W (horizontal scroll) movement delta.
831 * @param fButtons Depressed button mask.
832 */
833static int ps2mR3PutEventWorker(PPDMDEVINS pDevIns, PPS2M pThis, int32_t dx, int32_t dy, int32_t dz, int32_t dw, uint32_t fButtons)
834{
835 LogFlowFunc(("dx=%d, dy=%d, dz=%d, dw=%d, fButtons=%X\n", dx, dy, dz, dw, fButtons));
836
837 /* Update internal accumulators and button state. Ignore any buttons beyond 5. */
838 pThis->iAccumX += dx;
839 pThis->iAccumY += dy;
840 pThis->iAccumZ += dz;
841 pThis->iAccumW += dw;
842 pThis->fCurrB = fButtons & (PS2M_STD_BTN_MASK | PS2M_IMEX_BTN_MASK);
843 pThis->fAccumB |= pThis->fCurrB;
844
845 /* Ditch accumulated data that can't be reported by the current protocol.
846 * This avoids sending phantom empty reports when un-reportable events
847 * are received.
848 */
849 if (pThis->enmProtocol < PS2M_PROTO_IMEX_HORZ)
850 pThis->iAccumW = 0; /* No horizontal scroll. */
851
852 if (pThis->enmProtocol < PS2M_PROTO_IMEX)
853 {
854 pThis->fAccumB &= PS2M_STD_BTN_MASK; /* Only buttons 1-3. */
855 pThis->fCurrB &= PS2M_STD_BTN_MASK;
856 }
857
858 if (pThis->enmProtocol < PS2M_PROTO_IMPS2)
859 pThis->iAccumZ = 0; /* No vertical scroll. */
860
861 /* Report the event (if any) and start the throttle timer unless it's already running. */
862 if (!pThis->fThrottleActive && ps2mR3HaveEvents(pThis))
863 {
864 ps2mReportAccumulatedEvents(pThis, &pThis->evtQ.Hdr, RT_ELEMENTS(pThis->evtQ.abQueue), pThis->evtQ.abQueue, true);
865 KBCUpdateInterrupts(pDevIns);
866 pThis->fThrottleActive = true;
867 PDMDevHlpTimerSetMillies(pDevIns, pThis->hThrottleTimer, pThis->uThrottleDelay);
868 }
869
870 return VINF_SUCCESS;
871}
872
873
874/* -=-=-=-=-=- Mouse: IMousePort -=-=-=-=-=- */
875
876/**
877 * @interface_method_impl{PDMIMOUSEPORT,pfnPutEvent}
878 */
879static DECLCALLBACK(int) ps2mR3MousePort_PutEvent(PPDMIMOUSEPORT pInterface, int32_t dx, int32_t dy,
880 int32_t dz, int32_t dw, uint32_t fButtons)
881{
882 PPS2MR3 pThisCC = RT_FROM_MEMBER(pInterface, PS2MR3, Mouse.IPort);
883 PPDMDEVINS pDevIns = pThisCC->pDevIns;
884 PPS2M pThis = &PDMDEVINS_2_DATA(pDevIns, PKBDSTATE)->Aux;
885 int const rcLock = PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_SEM_BUSY);
886 PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, pDevIns->pCritSectRoR3, rcLock);
887
888 LogRelFlowFunc(("dX=%d dY=%d dZ=%d dW=%d buttons=%02X\n", dx, dy, dz, dw, fButtons));
889 /* NB: The PS/2 Y axis direction is inverted relative to ours. */
890 ps2mR3PutEventWorker(pDevIns, pThis, dx, -dy, dz, dw, fButtons);
891
892 PDMDevHlpCritSectLeave(pDevIns, pDevIns->pCritSectRoR3);
893 return VINF_SUCCESS;
894}
895
896/**
897 * @interface_method_impl{PDMIMOUSEPORT,pfnPutEventAbs}
898 */
899static DECLCALLBACK(int) ps2mR3MousePort_PutEventAbs(PPDMIMOUSEPORT pInterface, uint32_t x, uint32_t y,
900 int32_t dz, int32_t dw, uint32_t fButtons)
901{
902 AssertFailedReturn(VERR_NOT_SUPPORTED);
903 NOREF(pInterface); NOREF(x); NOREF(y); NOREF(dz); NOREF(dw); NOREF(fButtons);
904}
905
906/**
907 * @interface_method_impl{PDMIMOUSEPORT,pfnPutEventTouchScreen}
908 */
909static DECLCALLBACK(int) ps2mR3MousePort_PutEventMTAbs(PPDMIMOUSEPORT pInterface, uint8_t cContacts,
910 const uint64_t *pau64Contacts, uint32_t u32ScanTime)
911{
912 AssertFailedReturn(VERR_NOT_SUPPORTED);
913 NOREF(pInterface); NOREF(cContacts); NOREF(pau64Contacts); NOREF(u32ScanTime);
914}
915
916/**
917 * @interface_method_impl{PDMIMOUSEPORT,pfnPutEventTouchPad}
918 */
919static DECLCALLBACK(int) ps2mR3MousePort_PutEventMTRel(PPDMIMOUSEPORT pInterface, uint8_t cContacts,
920 const uint64_t *pau64Contacts, uint32_t u32ScanTime)
921{
922 AssertFailedReturn(VERR_NOT_SUPPORTED);
923 NOREF(pInterface); NOREF(cContacts); NOREF(pau64Contacts); NOREF(u32ScanTime);
924}
925
926
927/* -=-=-=-=-=- Mouse: IBase -=-=-=-=-=- */
928
929/**
930 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
931 */
932static DECLCALLBACK(void *) ps2mR3QueryInterface(PPDMIBASE pInterface, const char *pszIID)
933{
934 PPS2MR3 pThisCC = RT_FROM_MEMBER(pInterface, PS2MR3, Mouse.IBase);
935 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThisCC->Mouse.IBase);
936 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMOUSEPORT, &pThisCC->Mouse.IPort);
937 return NULL;
938}
939
940
941/* -=-=-=-=-=- Device management -=-=-=-=-=- */
942
943/**
944 * Attach command.
945 *
946 * This is called to let the device attach to a driver for a
947 * specified LUN.
948 *
949 * This is like plugging in the mouse after turning on the
950 * system.
951 *
952 * @returns VBox status code.
953 * @param pDevIns The device instance.
954 * @param pThisCC The PS/2 auxiliary device instance data for ring-3.
955 * @param iLUN The logical unit which is being detached.
956 * @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
957 */
958int PS2MR3Attach(PPDMDEVINS pDevIns, PPS2MR3 pThisCC, unsigned iLUN, uint32_t fFlags)
959{
960 int rc;
961
962 /* The LUN must be 1, i.e. mouse. */
963 Assert(iLUN == 1);
964 AssertMsgReturn(fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG,
965 ("PS/2 mouse does not support hotplugging\n"),
966 VERR_INVALID_PARAMETER);
967
968 LogFlowFunc(("iLUN=%d\n", iLUN));
969
970 rc = PDMDevHlpDriverAttach(pDevIns, iLUN, &pThisCC->Mouse.IBase, &pThisCC->Mouse.pDrvBase, "Mouse Port");
971 if (RT_SUCCESS(rc))
972 {
973 pThisCC->Mouse.pDrv = PDMIBASE_QUERY_INTERFACE(pThisCC->Mouse.pDrvBase, PDMIMOUSECONNECTOR);
974 if (!pThisCC->Mouse.pDrv)
975 {
976 AssertLogRelMsgFailed(("LUN #1 doesn't have a mouse interface! rc=%Rrc\n", rc));
977 rc = VERR_PDM_MISSING_INTERFACE;
978 }
979 }
980 else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
981 {
982 Log(("%s/%d: warning: no driver attached to LUN #1!\n", pDevIns->pReg->szName, pDevIns->iInstance));
983 rc = VINF_SUCCESS;
984 }
985 else
986 AssertLogRelMsgFailed(("Failed to attach LUN #1! rc=%Rrc\n", rc));
987
988 return rc;
989}
990
991void PS2MR3SaveState(PPDMDEVINS pDevIns, PPS2M pThis, PSSMHANDLE pSSM)
992{
993 PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
994 LogFlowFunc(("Saving PS2M state\n"));
995
996 /* Save the core auxiliary device state. */
997 pHlp->pfnSSMPutU8(pSSM, pThis->u8State);
998 pHlp->pfnSSMPutU8(pSSM, pThis->u8SampleRate);
999 pHlp->pfnSSMPutU8(pSSM, pThis->u8Resolution);
1000 pHlp->pfnSSMPutU8(pSSM, pThis->u8CurrCmd);
1001 pHlp->pfnSSMPutU8(pSSM, pThis->enmMode);
1002 pHlp->pfnSSMPutU8(pSSM, pThis->enmProtocol);
1003 pHlp->pfnSSMPutU8(pSSM, pThis->enmKnockState);
1004
1005 /* Save the command and event queues. */
1006 PS2Q_SAVE(pHlp, pSSM, &pThis->cmdQ);
1007 PS2Q_SAVE(pHlp, pSSM, &pThis->evtQ);
1008
1009 /* Save the command delay timer. Note that the rate throttling
1010 * timer is *not* saved.
1011 */
1012 PDMDevHlpTimerSave(pDevIns, pThis->hDelayTimer, pSSM);
1013}
1014
1015int PS2MR3LoadState(PPDMDEVINS pDevIns, PPS2M pThis, PPS2MR3 pThisCC, PSSMHANDLE pSSM, uint32_t uVersion)
1016{
1017 PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
1018 uint8_t u8;
1019 int rc;
1020
1021 NOREF(uVersion);
1022 LogFlowFunc(("Loading PS2M state version %u\n", uVersion));
1023
1024 /* Load the basic auxiliary device state. */
1025 pHlp->pfnSSMGetU8(pSSM, &pThis->u8State);
1026 pHlp->pfnSSMGetU8(pSSM, &pThis->u8SampleRate);
1027 pHlp->pfnSSMGetU8(pSSM, &pThis->u8Resolution);
1028 pHlp->pfnSSMGetU8(pSSM, &pThis->u8CurrCmd);
1029 pHlp->pfnSSMGetU8(pSSM, &u8);
1030 pThis->enmMode = (PS2M_MODE)u8;
1031 pHlp->pfnSSMGetU8(pSSM, &u8);
1032 pThis->enmProtocol = (PS2M_PROTO)u8;
1033 pHlp->pfnSSMGetU8(pSSM, &u8);
1034 pThis->enmKnockState = (PS2M_KNOCK_STATE)u8;
1035
1036 /* Load the command and event queues. */
1037 rc = PS2Q_LOAD(pHlp, pSSM, &pThis->cmdQ);
1038 AssertRCReturn(rc, rc);
1039 rc = PS2Q_LOAD(pHlp, pSSM, &pThis->evtQ);
1040 AssertRCReturn(rc, rc);
1041
1042 /* Load the command delay timer, just in case. */
1043 rc = PDMDevHlpTimerLoad(pDevIns, pThis->hDelayTimer, pSSM);
1044 AssertRCReturn(rc, rc);
1045
1046 /* Recalculate the throttling delay. */
1047 ps2mSetRate(pThis, pThis->u8SampleRate);
1048
1049 ps2mR3SetDriverState(pThisCC, !!(pThis->u8State & AUX_STATE_ENABLED));
1050
1051 return VINF_SUCCESS;
1052}
1053
1054void PS2MR3FixupState(PPS2M pThis, PPS2MR3 pThisCC, uint8_t u8State, uint8_t u8Rate, uint8_t u8Proto)
1055{
1056 LogFlowFunc(("Fixing up old PS2M state version\n"));
1057
1058 /* Load the basic auxiliary device state. */
1059 pThis->u8State = u8State;
1060 pThis->u8SampleRate = u8Rate ? u8Rate : 40; /* In case it wasn't saved right. */
1061 pThis->enmProtocol = (PS2M_PROTO)u8Proto;
1062
1063 /* Recalculate the throttling delay. */
1064 ps2mSetRate(pThis, pThis->u8SampleRate);
1065
1066 ps2mR3SetDriverState(pThisCC, !!(pThis->u8State & AUX_STATE_ENABLED));
1067}
1068
1069void PS2MR3Reset(PPS2M pThis)
1070{
1071 LogFlowFunc(("Resetting PS2M\n"));
1072
1073 pThis->u8CurrCmd = 0;
1074
1075 /* Clear the queues. */
1076 PS2Q_CLEAR(&pThis->cmdQ);
1077 ps2mSetDefaults(pThis); /* Also clears event queue. */
1078}
1079
1080int PS2MR3Construct(PPDMDEVINS pDevIns, PPS2M pThis, PPS2MR3 pThisCC)
1081{
1082 LogFlowFunc(("\n"));
1083
1084 pThis->cmdQ.Hdr.pszDescR3 = "Aux Cmd";
1085 pThis->evtQ.Hdr.pszDescR3 = "Aux Evt";
1086
1087#ifdef RT_STRICT
1088 ps2mR3TestAccumulation();
1089#endif
1090
1091 /*
1092 * Initialize the state.
1093 */
1094 pThisCC->pDevIns = pDevIns;
1095 pThisCC->Mouse.IBase.pfnQueryInterface = ps2mR3QueryInterface;
1096 pThisCC->Mouse.IPort.pfnPutEvent = ps2mR3MousePort_PutEvent;
1097 pThisCC->Mouse.IPort.pfnPutEventAbs = ps2mR3MousePort_PutEventAbs;
1098 pThisCC->Mouse.IPort.pfnPutEventTouchScreen = ps2mR3MousePort_PutEventMTAbs;
1099 pThisCC->Mouse.IPort.pfnPutEventTouchPad = ps2mR3MousePort_PutEventMTRel;
1100
1101 /*
1102 * Create the input rate throttling timer. Does not use virtual time!
1103 */
1104 int rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_REAL, ps2mR3ThrottleTimer, pThis,
1105 TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_NO_RING0,
1106 "PS2M Throttle", &pThis->hThrottleTimer);
1107 AssertRCReturn(rc, rc);
1108
1109 /*
1110 * Create the command delay timer.
1111 */
1112 rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, ps2mR3DelayTimer, pThis,
1113 TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_RING0, "PS2M Delay", &pThis->hDelayTimer);
1114 AssertRCReturn(rc, rc);
1115
1116 /*
1117 * Register debugger info callbacks.
1118 */
1119 PDMDevHlpDBGFInfoRegister(pDevIns, "ps2m", "Display PS/2 mouse state.", ps2mR3InfoState);
1120
1121 /// @todo Where should we do this?
1122 ps2mR3SetDriverState(pThisCC, true);
1123 pThis->u8State = 0;
1124 pThis->enmMode = AUX_MODE_STD;
1125
1126 return rc;
1127}
1128
1129#endif
1130
1131#if defined(RT_STRICT) && defined(IN_RING3)
1132/* -=-=-=-=-=- Test code -=-=-=-=-=- */
1133
1134/** Test the event accumulation mechanism which we use to delay events going
1135 * to the guest to one per 10ms (the default PS/2 mouse event rate). This
1136 * test depends on ps2mR3PutEventWorker() not touching the timer if
1137 * This.fThrottleActive is true. */
1138/** @todo if we add any more tests it might be worth using a table of test
1139 * operations and checks. */
1140static void ps2mR3TestAccumulation(void)
1141{
1142 PS2M This;
1143 unsigned i;
1144 int rc;
1145 uint8_t b;
1146
1147 RT_ZERO(This);
1148 This.u8State = AUX_STATE_ENABLED;
1149 This.fThrottleActive = true;
1150 This.cmdQ.Hdr.pszDescR3 = "Test Aux Cmd";
1151 This.evtQ.Hdr.pszDescR3 = "Test Aux Evt";
1152 /* Certain Windows touch pad drivers report a double tap as a press, then
1153 * a release-press-release all within a single 10ms interval. Simulate
1154 * this to check that it is handled right. */
1155 ps2mR3PutEventWorker(NULL, &This, 0, 0, 0, 0, 1);
1156 if (ps2mR3HaveEvents(&This))
1157 ps2mReportAccumulatedEvents(&This, &This.evtQ.Hdr, RT_ELEMENTS(This.evtQ.abQueue), This.evtQ.abQueue, true);
1158 ps2mR3PutEventWorker(NULL, &This, 0, 0, 0, 0, 0);
1159 if (ps2mR3HaveEvents(&This))
1160 ps2mReportAccumulatedEvents(&This, &This.evtQ.Hdr, RT_ELEMENTS(This.evtQ.abQueue), This.evtQ.abQueue, true);
1161 ps2mR3PutEventWorker(NULL, &This, 0, 0, 0, 0, 1);
1162 ps2mR3PutEventWorker(NULL, &This, 0, 0, 0, 0, 0);
1163 if (ps2mR3HaveEvents(&This))
1164 ps2mReportAccumulatedEvents(&This, &This.evtQ.Hdr, RT_ELEMENTS(This.evtQ.abQueue), This.evtQ.abQueue, true);
1165 if (ps2mR3HaveEvents(&This))
1166 ps2mReportAccumulatedEvents(&This, &This.evtQ.Hdr, RT_ELEMENTS(This.evtQ.abQueue), This.evtQ.abQueue, true);
1167 for (i = 0; i < 12; ++i)
1168 {
1169 const uint8_t abExpected[] = { 9, 0, 0, 8, 0, 0, 9, 0, 0, 8, 0, 0};
1170
1171 rc = PS2MByteFromAux(&This, &b);
1172 AssertRCSuccess(rc);
1173 Assert(b == abExpected[i]);
1174 }
1175 rc = PS2MByteFromAux(&This, &b);
1176 Assert(rc != VINF_SUCCESS);
1177 /* Button hold down during mouse drags was broken at some point during
1178 * testing fixes for the previous issue. Test that that works. */
1179 ps2mR3PutEventWorker(NULL, &This, 0, 0, 0, 0, 1);
1180 if (ps2mR3HaveEvents(&This))
1181 ps2mReportAccumulatedEvents(&This, &This.evtQ.Hdr, RT_ELEMENTS(This.evtQ.abQueue), This.evtQ.abQueue, true);
1182 if (ps2mR3HaveEvents(&This))
1183 ps2mReportAccumulatedEvents(&This, &This.evtQ.Hdr, RT_ELEMENTS(This.evtQ.abQueue), This.evtQ.abQueue, true);
1184 for (i = 0; i < 3; ++i)
1185 {
1186 const uint8_t abExpected[] = { 9, 0, 0 };
1187
1188 rc = PS2MByteFromAux(&This, &b);
1189 AssertRCSuccess(rc);
1190 Assert(b == abExpected[i]);
1191 }
1192 rc = PS2MByteFromAux(&This, &b);
1193 Assert(rc != VINF_SUCCESS);
1194}
1195#endif /* RT_STRICT && IN_RING3 */
1196
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