PS2M.cpp@ 52128

Last change on this file since 52128 was 52128, checked in by vboxsync, 10 years ago
PS2M: Do not delay resets (too much trouble).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 40.0 KB

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

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

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

Download in other formats: