PS2M.cpp@ 69222

Last change on this file since 69222 was 69046, checked in by vboxsync, 7 years ago
Global: replace fall-through comments with RT_FALL_THRU(). bugref:8192: gcc warnings
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 46.2 KB

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

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: