PS2M.cpp@ 66058

Last change on this file since 66058 was 65648, checked in by vboxsync, 8 years ago
gcc 7: Devices: fall thru
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 44.1 KB

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

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

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

Download in other formats: