DevPS2.cpp@ 49886

Last change on this file since 49886 was 49886, checked in by vboxsync, 11 years ago
Devices/Input/DevPS2.cpp: fix regression in previous change, accidentally disabled A20 handling, leading to triple faults for many VMs
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 57.3 KB

Line
1	/* $Id: DevPS2.cpp 49886 2013-12-12 15:10:02Z vboxsync $ */
2	/** @file
3	* DevPS2 - PS/2 keyboard & mouse controller device.
4	*/
5
6	/*
7	* Copyright (C) 2006-2013 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	* This code is based on:
19	*
20	* QEMU PC keyboard emulation (revision 1.12)
21	*
22	* Copyright (c) 2003 Fabrice Bellard
23	*
24	* Permission is hereby granted, free of charge, to any person obtaining a copy
25	* of this software and associated documentation files (the "Software"), to deal
26	* in the Software without restriction, including without limitation the rights
27	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
28	* copies of the Software, and to permit persons to whom the Software is
29	* furnished to do so, subject to the following conditions:
30	*
31	* The above copyright notice and this permission notice shall be included in
32	* all copies or substantial portions of the Software.
33	*
34	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
35	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
36	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
37	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
38	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
39	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
40	* THE SOFTWARE.
41	*
42	*/
43
44	/*******************************************************************************
45	* Header Files *
46	*******************************************************************************/
47	#define LOG_GROUP LOG_GROUP_DEV_KBD
48	#include <VBox/vmm/pdmdev.h>
49	#include <iprt/assert.h>
50	#include <iprt/uuid.h>
51
52	#include "VBoxDD.h"
53	#include "PS2Dev.h"
54
55	/* Do not remove this (unless eliminating the corresponding ifdefs), it willi
56	* cause instant triple faults when booting Windows VMs. */
57	#define TARGET_I386
58
59	#define PCKBD_SAVED_STATE_VERSION 7
60
61
62	#ifndef VBOX_DEVICE_STRUCT_TESTCASE
63	/*******************************************************************************
64	* Internal Functions *
65	*******************************************************************************/
66	RT_C_DECLS_BEGIN
67	PDMBOTHCBDECL(int) kbdIOPortDataRead(PPDMDEVINS pDevIns, void pvUser, RTIOPORT Port, uint32_t pu32, unsigned cb);
68	PDMBOTHCBDECL(int) kbdIOPortDataWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb);
69	PDMBOTHCBDECL(int) kbdIOPortStatusRead(PPDMDEVINS pDevIns, void pvUser, RTIOPORT Port, uint32_t pu32, unsigned cb);
70	PDMBOTHCBDECL(int) kbdIOPortCommandWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb);
71	RT_C_DECLS_END
72	#endif /* !VBOX_DEVICE_STRUCT_TESTCASE */
73
74	/* debug PC keyboard */
75	#define DEBUG_KBD
76
77	/* debug PC keyboard : only mouse */
78	#define DEBUG_MOUSE
79
80	/* Keyboard Controller Commands */
81	#define KBD_CCMD_READ_MODE 0x20 /* Read mode bits */
82	#define KBD_CCMD_WRITE_MODE 0x60 /* Write mode bits */
83	#define KBD_CCMD_GET_VERSION 0xA1 /* Get controller version */
84	#define KBD_CCMD_MOUSE_DISABLE 0xA7 /* Disable mouse interface */
85	#define KBD_CCMD_MOUSE_ENABLE 0xA8 /* Enable mouse interface */
86	#define KBD_CCMD_TEST_MOUSE 0xA9 /* Mouse interface test */
87	#define KBD_CCMD_SELF_TEST 0xAA /* Controller self test */
88	#define KBD_CCMD_KBD_TEST 0xAB /* Keyboard interface test */
89	#define KBD_CCMD_KBD_DISABLE 0xAD /* Keyboard interface disable */
90	#define KBD_CCMD_KBD_ENABLE 0xAE /* Keyboard interface enable */
91	#define KBD_CCMD_READ_INPORT 0xC0 /* read input port */
92	#define KBD_CCMD_READ_OUTPORT 0xD0 /* read output port */
93	#define KBD_CCMD_WRITE_OUTPORT 0xD1 /* write output port */
94	#define KBD_CCMD_WRITE_OBUF 0xD2
95	#define KBD_CCMD_WRITE_AUX_OBUF 0xD3 /* Write to output buffer as if
96	initiated by the auxiliary device */
97	#define KBD_CCMD_WRITE_MOUSE 0xD4 /* Write the following byte to the mouse */
98	#define KBD_CCMD_DISABLE_A20 0xDD /* HP vectra only ? */
99	#define KBD_CCMD_ENABLE_A20 0xDF /* HP vectra only ? */
100	#define KBD_CCMD_READ_TSTINP 0xE0 /* Read test inputs T0, T1 */
101	#define KBD_CCMD_RESET_ALT 0xF0
102	#define KBD_CCMD_RESET 0xFE
103
104	/* Status Register Bits */
105	#define KBD_STAT_OBF 0x01 /* Keyboard output buffer full */
106	#define KBD_STAT_IBF 0x02 /* Keyboard input buffer full */
107	#define KBD_STAT_SELFTEST 0x04 /* Self test successful */
108	#define KBD_STAT_CMD 0x08 /* Last write was a command write (0=data) */
109	#define KBD_STAT_UNLOCKED 0x10 /* Zero if keyboard locked */
110	#define KBD_STAT_MOUSE_OBF 0x20 /* Mouse output buffer full */
111	#define KBD_STAT_GTO 0x40 /* General receive/xmit timeout */
112	#define KBD_STAT_PERR 0x80 /* Parity error */
113
114	/* Controller Mode Register Bits */
115	#define KBD_MODE_KBD_INT 0x01 /* Keyboard data generate IRQ1 */
116	#define KBD_MODE_MOUSE_INT 0x02 /* Mouse data generate IRQ12 */
117	#define KBD_MODE_SYS 0x04 /* The system flag (?) */
118	#define KBD_MODE_NO_KEYLOCK 0x08 /* The keylock doesn't affect the keyboard if set */
119	#define KBD_MODE_DISABLE_KBD 0x10 /* Disable keyboard interface */
120	#define KBD_MODE_DISABLE_MOUSE 0x20 /* Disable mouse interface */
121	#define KBD_MODE_KCC 0x40 /* Scan code conversion to PC format */
122	#define KBD_MODE_RFU 0x80
123
124	#ifndef VBOX_WITH_NEW_PS2M
125	/* Mouse Commands */
126	#define AUX_SET_SCALE11 0xE6 /* Set 1:1 scaling */
127	#define AUX_SET_SCALE21 0xE7 /* Set 2:1 scaling */
128	#define AUX_SET_RES 0xE8 /* Set resolution */
129	#define AUX_GET_SCALE 0xE9 /* Get scaling factor */
130	#define AUX_SET_STREAM 0xEA /* Set stream mode */
131	#define AUX_POLL 0xEB /* Poll */
132	#define AUX_RESET_WRAP 0xEC /* Reset wrap mode */
133	#define AUX_SET_WRAP 0xEE /* Set wrap mode */
134	#define AUX_SET_REMOTE 0xF0 /* Set remote mode */
135	#define AUX_GET_TYPE 0xF2 /* Get type */
136	#define AUX_SET_SAMPLE 0xF3 /* Set sample rate */
137	#define AUX_ENABLE_DEV 0xF4 /* Enable aux device */
138	#define AUX_DISABLE_DEV 0xF5 /* Disable aux device */
139	#define AUX_SET_DEFAULT 0xF6
140	#define AUX_RESET 0xFF /* Reset aux device */
141	#define AUX_ACK 0xFA /* Command byte ACK. */
142	#define AUX_NACK 0xFE /* Command byte NACK. */
143
144	#define MOUSE_STATUS_REMOTE 0x40
145	#define MOUSE_STATUS_ENABLED 0x20
146	#define MOUSE_STATUS_SCALE21 0x10
147
148	/** Supported mouse protocols */
149	enum
150	{
151	MOUSE_PROT_PS2 = 0,
152	MOUSE_PROT_IMPS2 = 3,
153	MOUSE_PROT_IMEX = 4
154	};
155
156	/** @name Mouse flags */
157	/** @{ */
158	/** IMEX horizontal scroll-wheel mode is active */
159	# define MOUSE_REPORT_HORIZONTAL 0x01
160	/** @} */
161
162	#define MOUSE_CMD_QUEUE_SIZE 8
163
164	typedef struct {
165	uint8_t data[MOUSE_CMD_QUEUE_SIZE];
166	int rptr, wptr, count;
167	} MouseCmdQueue;
168
169
170	#define MOUSE_EVENT_QUEUE_SIZE 256
171
172	typedef struct
173	{
174	uint8_t data[MOUSE_EVENT_QUEUE_SIZE];
175	int rptr;
176	int wptr;
177	int count;
178	} MouseEventQueue;
179	#endif
180
181	/**
182	* The keyboard controller/device state.
183	*
184	* @note We use the default critical section for serialize data access.
185	*/
186	typedef struct KBDState
187	{
188	#ifndef VBOX_WITH_NEW_PS2M
189	MouseCmdQueue mouse_command_queue;
190	MouseEventQueue mouse_event_queue;
191	#endif
192	uint8_t write_cmd; /* if non zero, write data to port 60 is expected */
193	uint8_t status;
194	uint8_t mode;
195	uint8_t dbbout; /* data buffer byte */
196	/* keyboard state */
197	int32_t translate;
198	int32_t xlat_state;
199	#ifndef VBOX_WITH_NEW_PS2M
200	/* mouse state */
201	int32_t mouse_write_cmd;
202	uint8_t mouse_status;
203	uint8_t mouse_resolution;
204	uint8_t mouse_sample_rate;
205	uint8_t mouse_wrap;
206	uint8_t mouse_type; /* MOUSE_PROT_PS2, _IMPS/2, _IMEX */
207	uint8_t mouse_detect_state;
208	int32_t mouse_dx; /* current values, needed for 'poll' mode */
209	int32_t mouse_dy;
210	int32_t mouse_dz;
211	int32_t mouse_dw;
212	int32_t mouse_flags;
213	uint8_t mouse_buttons;
214	uint8_t mouse_buttons_reported;
215	#endif
216
217	uint32_t Alignment0;
218
219	/** Pointer to the device instance - RC. */
220	PPDMDEVINSRC pDevInsRC;
221	/** Pointer to the device instance - R3 . */
222	PPDMDEVINSR3 pDevInsR3;
223	/** Pointer to the device instance. */
224	PPDMDEVINSR0 pDevInsR0;
225
226	/** Keyboard state (implemented in separate PS2K module). */
227	#ifdef VBOX_DEVICE_STRUCT_TESTCASE
228	uint8_t KbdFiller[PS2K_STRUCT_FILLER];
229	#else
230	PS2K Kbd;
231	#endif
232
233	#ifdef VBOX_WITH_NEW_PS2M
234	/** Mouse state (implemented in separate PS2M module). */
235	#ifdef VBOX_DEVICE_STRUCT_TESTCASE
236	uint8_t AuxFiller[PS2M_STRUCT_FILLER];
237	#else
238	PS2M Aux;
239	#endif
240	#else
241	/**
242	* Mouse port - LUN#1.
243	*
244	* @implements PDMIBASE
245	* @implements PDMIMOUSEPORT
246	*/
247	struct
248	{
249	/** The base interface for the mouse port. */
250	PDMIBASE IBase;
251	/** The mouse port base interface. */
252	PDMIMOUSEPORT IPort;
253
254	/** The base interface of the attached mouse driver. */
255	R3PTRTYPE(PPDMIBASE) pDrvBase;
256	/** The mouse interface of the attached mouse driver. */
257	R3PTRTYPE(PPDMIMOUSECONNECTOR) pDrv;
258	} Mouse;
259	#endif
260	} KBDState;
261
262	#ifndef VBOX_DEVICE_STRUCT_TESTCASE
263
264	/* update irq and KBD_STAT_[MOUSE_]OBF */
265	static void kbd_update_irq(KBDState *s)
266	{
267	#ifndef VBOX_WITH_NEW_PS2M
268	MouseCmdQueue *mcq = &s->mouse_command_queue;
269	MouseEventQueue *meq = &s->mouse_event_queue;
270	#endif
271	int irq12_level, irq1_level;
272	uint8_t val;
273
274	irq1_level = 0;
275	irq12_level = 0;
276
277	/* Determine new OBF state, but only if OBF is clear. If OBF was already
278	* set, we cannot risk changing the event type after an ISR potentially
279	* started executing! Only kbd_read_data() clears the OBF bits.
280	*/
281	if (!(s->status & KBD_STAT_OBF)) {
282	s->status &= ~KBD_STAT_MOUSE_OBF;
283	/* Keyboard data has priority if both kbd and aux data is available. */
284	if (!(s->mode & KBD_MODE_DISABLE_KBD) && PS2KByteFromKbd(&s->Kbd, &val) == VINF_SUCCESS)
285	{
286	bool fHaveData = true;
287
288	/* If scancode translation is on (it usually is), there's more work to do. */
289	if (s->translate)
290	{
291	uint8_t xlated_val;
292
293	s->xlat_state = XlateAT2PC(s->xlat_state, val, &xlated_val);
294	val = xlated_val;
295
296	/* If the translation state is XS_BREAK, there's nothing to report
297	* and we keep going until the state changes or there's no more data.
298	*/
299	while (s->xlat_state == XS_BREAK && PS2KByteFromKbd(&s->Kbd, &val) == VINF_SUCCESS)
300	{
301	s->xlat_state = XlateAT2PC(s->xlat_state, val, &xlated_val);
302	val = xlated_val;
303	}
304	/* This can happen if the last byte in the queue is F0... */
305	if (s->xlat_state == XS_BREAK)
306	fHaveData = false;
307	}
308	if (fHaveData)
309	{
310	s->dbbout = val;
311	s->status \|= KBD_STAT_OBF;
312	}
313	}
314	#ifdef VBOX_WITH_NEW_PS2M
315	else if (!(s->mode & KBD_MODE_DISABLE_MOUSE) && PS2MByteFromAux(&s->Aux, &val) == VINF_SUCCESS)
316	{
317	s->dbbout = val;
318	s->status \|= KBD_STAT_OBF \| KBD_STAT_MOUSE_OBF;
319	}
320	#else
321	else if ((mcq->count \|\| meq->count) && !(s->mode & KBD_MODE_DISABLE_MOUSE))
322	{
323	s->status \|= KBD_STAT_OBF \| KBD_STAT_MOUSE_OBF;
324	if (mcq->count)
325	{
326	s->dbbout = mcq->data[mcq->rptr];
327	if (++mcq->rptr == MOUSE_CMD_QUEUE_SIZE)
328	mcq->rptr = 0;
329	mcq->count--;
330	}
331	else
332	{
333	s->dbbout = meq->data[meq->rptr];
334	if (++meq->rptr == MOUSE_EVENT_QUEUE_SIZE)
335	meq->rptr = 0;
336	meq->count--;
337	}
338	}
339	#endif
340	}
341	/* Determine new IRQ state. */
342	if (s->status & KBD_STAT_OBF) {
343	if (s->status & KBD_STAT_MOUSE_OBF)
344	{
345	if (s->mode & KBD_MODE_MOUSE_INT)
346	irq12_level = 1;
347	}
348	else
349	{ /* KBD_STAT_OBF set but KBD_STAT_MOUSE_OBF isn't. */
350	if (s->mode & KBD_MODE_KBD_INT)
351	irq1_level = 1;
352	}
353	}
354	PDMDevHlpISASetIrq(s->CTX_SUFF(pDevIns), 1, irq1_level);
355	PDMDevHlpISASetIrq(s->CTX_SUFF(pDevIns), 12, irq12_level);
356	}
357
358	void KBCUpdateInterrupts(void *pKbc)
359	{
360	KBDState s = (KBDState )pKbc;
361	kbd_update_irq(s);
362	}
363
364	#ifndef VBOX_WITH_NEW_PS2M
365	static void kbd_queue(KBDState *s, int b, int aux)
366	{
367	MouseCmdQueue *mcq = &s->mouse_command_queue;
368	MouseEventQueue *meq = &s->mouse_event_queue;
369
370	#if defined(DEBUG_MOUSE) \|\| defined(DEBUG_KBD)
371	if (aux == 1)
372	LogRel3(("%s: mouse command response: 0x%02x\n", __PRETTY_FUNCTION__, b));
373	else if (aux == 2)
374	LogRel3(("%s: mouse event data: 0x%02x\n", __PRETTY_FUNCTION__, b));
375	#ifdef DEBUG_KBD
376	else
377	LogRel3(("%s: kbd event: 0x%02x\n", __PRETTY_FUNCTION__, b));
378	#endif
379	#endif
380	switch (aux)
381	{
382	case 0: /* keyboard */
383	AssertMsgFailed(("kbd_queue() no longer supported for keyboard!\n"));
384	break;
385	case 1: /* mouse command response */
386	if (mcq->count >= MOUSE_CMD_QUEUE_SIZE)
387	return;
388	mcq->data[mcq->wptr] = b;
389	if (++mcq->wptr == MOUSE_CMD_QUEUE_SIZE)
390	mcq->wptr = 0;
391	mcq->count++;
392	break;
393	case 2: /* mouse event data */
394	if (meq->count >= MOUSE_EVENT_QUEUE_SIZE)
395	return;
396	meq->data[meq->wptr] = b;
397	if (++meq->wptr == MOUSE_EVENT_QUEUE_SIZE)
398	meq->wptr = 0;
399	meq->count++;
400	break;
401	default:
402	AssertMsgFailed(("aux=%d\n", aux));
403	}
404	kbd_update_irq(s);
405	}
406	#endif
407
408	static void kbc_dbb_out(void *opaque, uint8_t val)
409	{
410	KBDState s = (KBDState)opaque;
411
412	s->dbbout = val;
413	/* Set the OBF and raise IRQ. */
414	s->status \|= KBD_STAT_OBF;
415	if (s->mode & KBD_MODE_KBD_INT)
416	PDMDevHlpISASetIrq(s->CTX_SUFF(pDevIns), 1, 1);
417	}
418
419	static void kbc_dbb_out_aux(void *opaque, uint8_t val)
420	{
421	KBDState s = (KBDState)opaque;
422
423	s->dbbout = val;
424	/* Set the aux OBF and raise IRQ. */
425	s->status \|= KBD_STAT_OBF \| KBD_STAT_MOUSE_OBF;
426	if (s->mode & KBD_MODE_MOUSE_INT)
427	PDMDevHlpISASetIrq(s->CTX_SUFF(pDevIns), 12, PDM_IRQ_LEVEL_HIGH);
428	}
429
430	static uint32_t kbd_read_status(void *opaque, uint32_t addr)
431	{
432	KBDState s = (KBDState)opaque;
433	int val = s->status;
434	NOREF(addr);
435
436	#if defined(DEBUG_KBD)
437	Log(("kbd: read status=0x%02x\n", val));
438	#endif
439	return val;
440	}
441
442	static int kbd_write_command(void *opaque, uint32_t addr, uint32_t val)
443	{
444	int rc = VINF_SUCCESS;
445	KBDState s = (KBDState)opaque;
446	NOREF(addr);
447
448	#ifdef DEBUG_KBD
449	Log(("kbd: write cmd=0x%02x\n", val));
450	#endif
451	switch(val) {
452	case KBD_CCMD_READ_MODE:
453	kbc_dbb_out(s, s->mode);
454	break;
455	case KBD_CCMD_WRITE_MODE:
456	case KBD_CCMD_WRITE_OBUF:
457	case KBD_CCMD_WRITE_AUX_OBUF:
458	case KBD_CCMD_WRITE_MOUSE:
459	case KBD_CCMD_WRITE_OUTPORT:
460	s->write_cmd = val;
461	break;
462	case KBD_CCMD_MOUSE_DISABLE:
463	s->mode \|= KBD_MODE_DISABLE_MOUSE;
464	break;
465	case KBD_CCMD_MOUSE_ENABLE:
466	s->mode &= ~KBD_MODE_DISABLE_MOUSE;
467	/* Check for queued input. */
468	kbd_update_irq(s);
469	break;
470	case KBD_CCMD_TEST_MOUSE:
471	kbc_dbb_out(s, 0x00);
472	break;
473	case KBD_CCMD_SELF_TEST:
474	/* Enable the A20 line - that is the power-on state(!). */
475	# ifndef IN_RING3
476	if (!PDMDevHlpA20IsEnabled(s->CTX_SUFF(pDevIns)))
477	{
478	rc = VINF_IOM_R3_IOPORT_WRITE;
479	break;
480	}
481	# else /* IN_RING3 */
482	PDMDevHlpA20Set(s->CTX_SUFF(pDevIns), true);
483	# endif /* IN_RING3 */
484	s->status \|= KBD_STAT_SELFTEST;
485	s->mode \|= KBD_MODE_DISABLE_KBD;
486	kbc_dbb_out(s, 0x55);
487	break;
488	case KBD_CCMD_KBD_TEST:
489	kbc_dbb_out(s, 0x00);
490	break;
491	case KBD_CCMD_KBD_DISABLE:
492	s->mode \|= KBD_MODE_DISABLE_KBD;
493	break;
494	case KBD_CCMD_KBD_ENABLE:
495	s->mode &= ~KBD_MODE_DISABLE_KBD;
496	/* Check for queued input. */
497	kbd_update_irq(s);
498	break;
499	case KBD_CCMD_READ_INPORT:
500	kbc_dbb_out(s, 0x00);
501	break;
502	case KBD_CCMD_READ_OUTPORT:
503	/* XXX: check that */
504	#ifdef TARGET_I386
505	val = 0x01 \| (PDMDevHlpA20IsEnabled(s->CTX_SUFF(pDevIns)) << 1);
506	#else
507	val = 0x01;
508	#endif
509	if (s->status & KBD_STAT_OBF)
510	val \|= 0x10;
511	if (s->status & KBD_STAT_MOUSE_OBF)
512	val \|= 0x20;
513	kbc_dbb_out(s, val);
514	break;
515	#ifdef TARGET_I386
516	case KBD_CCMD_ENABLE_A20:
517	# ifndef IN_RING3
518	if (!PDMDevHlpA20IsEnabled(s->CTX_SUFF(pDevIns)))
519	rc = VINF_IOM_R3_IOPORT_WRITE;
520	# else /* IN_RING3 */
521	PDMDevHlpA20Set(s->CTX_SUFF(pDevIns), true);
522	# endif /* IN_RING3 */
523	break;
524	case KBD_CCMD_DISABLE_A20:
525	# ifndef IN_RING3
526	if (PDMDevHlpA20IsEnabled(s->CTX_SUFF(pDevIns)))
527	rc = VINF_IOM_R3_IOPORT_WRITE;
528	# else /* IN_RING3 */
529	PDMDevHlpA20Set(s->CTX_SUFF(pDevIns), false);
530	# endif /* !IN_RING3 */
531	break;
532	#endif
533	case KBD_CCMD_READ_TSTINP:
534	/* Keyboard clock line is zero IFF keyboard is disabled */
535	val = (s->mode & KBD_MODE_DISABLE_KBD) ? 0 : 1;
536	kbc_dbb_out(s, val);
537	break;
538	case KBD_CCMD_RESET:
539	case KBD_CCMD_RESET_ALT:
540	#ifndef IN_RING3
541	rc = VINF_IOM_R3_IOPORT_WRITE;
542	#else /* IN_RING3 */
543	LogRel(("Reset initiated by keyboard controller\n"));
544	rc = PDMDevHlpVMReset(s->CTX_SUFF(pDevIns));
545	#endif /* !IN_RING3 */
546	break;
547	case 0xff:
548	/* ignore that - I don't know what is its use */
549	break;
550	/* Make OS/2 happy. */
551	/* The 8042 RAM is readable using commands 0x20 thru 0x3f, and writable
552	by 0x60 thru 0x7f. Now days only the firs byte, the mode, is used.
553	We'll ignore the writes (0x61..7f) and return 0 for all the reads
554	just to make some OS/2 debug stuff a bit happier. */
555	case 0x21: case 0x22: case 0x23: case 0x24: case 0x25: case 0x26: case 0x27:
556	case 0x28: case 0x29: case 0x2a: case 0x2b: case 0x2c: case 0x2d: case 0x2e: case 0x2f:
557	case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: case 0x35: case 0x36: case 0x37:
558	case 0x38: case 0x39: case 0x3a: case 0x3b: case 0x3c: case 0x3d: case 0x3e: case 0x3f:
559	kbc_dbb_out(s, 0);
560	Log(("kbd: reading non-standard RAM addr %#x\n", val & 0x1f));
561	break;
562	default:
563	Log(("kbd: unsupported keyboard cmd=0x%02x\n", val));
564	break;
565	}
566	return rc;
567	}
568
569	static uint32_t kbd_read_data(void *opaque, uint32_t addr)
570	{
571	KBDState s = (KBDState)opaque;
572	uint32_t val;
573	NOREF(addr);
574
575	/* Return the current DBB contents. */
576	val = s->dbbout;
577
578	/* Reading the DBB deasserts IRQs... */
579	if (s->status & KBD_STAT_MOUSE_OBF)
580	PDMDevHlpISASetIrq(s->CTX_SUFF(pDevIns), 12, 0);
581	else
582	PDMDevHlpISASetIrq(s->CTX_SUFF(pDevIns), 1, 0);
583	/* ...and clears the OBF bits. */
584	s->status &= ~(KBD_STAT_OBF \| KBD_STAT_MOUSE_OBF);
585
586	/* Check if more data is available. */
587	kbd_update_irq(s);
588	#ifdef DEBUG_KBD
589	Log(("kbd: read data=0x%02x\n", val));
590	#endif
591	return val;
592	}
593
594	PS2K *KBDGetPS2KFromDevIns(PPDMDEVINS pDevIns)
595	{
596	KBDState pThis = PDMINS_2_DATA(pDevIns, KBDState );
597	return &pThis->Kbd;
598	}
599
600	PS2M *KBDGetPS2MFromDevIns(PPDMDEVINS pDevIns)
601	{
602	KBDState pThis = PDMINS_2_DATA(pDevIns, KBDState );
603	#ifdef VBOX_WITH_NEW_PS2M
604	return &pThis->Aux;
605	#else
606	return NULL;
607	#endif
608	}
609
610	#ifndef VBOX_WITH_NEW_PS2M
611	static void kbd_mouse_set_reported_buttons(KBDState *s, unsigned fButtons, unsigned fButtonMask)
612	{
613	s->mouse_buttons_reported \|= (fButtons & fButtonMask);
614	s->mouse_buttons_reported &= (fButtons \| ~fButtonMask);
615	}
616
617	/**
618	* Send a single relative packet in 3-byte PS/2 format to the PS/2 controller.
619	* @param s keyboard state object
620	* @param dx relative X value, must be between -256 and +255
621	* @param dy relative y value, must be between -256 and +255
622	* @param fButtonsLow the state of the two first mouse buttons
623	* @param fButtonsPacked the state of the upper three mouse buttons and
624	* scroll wheel movement, packed as per the
625	* MOUSE_EXT_* defines. For standard PS/2 packets
626	* only pass the value of button 3 here.
627	*/
628	static void kbd_mouse_send_rel3_packet(KBDState *s, bool fToCmdQueue)
629	{
630	int aux = fToCmdQueue ? 1 : 2;
631	int dx1 = s->mouse_dx < 0 ? RT_MAX(s->mouse_dx, -256)
632	: RT_MIN(s->mouse_dx, 255);
633	int dy1 = s->mouse_dy < 0 ? RT_MAX(s->mouse_dy, -256)
634	: RT_MIN(s->mouse_dy, 255);
635	unsigned int b;
636	unsigned fButtonsLow = s->mouse_buttons & 0x07;
637	s->mouse_dx -= dx1;
638	s->mouse_dy -= dy1;
639	kbd_mouse_set_reported_buttons(s, fButtonsLow, 0x07);
640	LogRel3(("%s: dx1=%d, dy1=%d, fButtonsLow=0x%x\n",
641	__PRETTY_FUNCTION__, dx1, dy1, fButtonsLow));
642	b = 0x08 \| ((dx1 < 0 ? 1 : 0) << 4) \| ((dy1 < 0 ? 1 : 0) << 5)
643	\| fButtonsLow;
644	kbd_queue(s, b, aux);
645	kbd_queue(s, dx1 & 0xff, aux);
646	kbd_queue(s, dy1 & 0xff, aux);
647	}
648
649	static void kbd_mouse_send_imps2_byte4(KBDState *s, bool fToCmdQueue)
650	{
651	int aux = fToCmdQueue ? 1 : 2;
652
653	int dz1 = s->mouse_dz < 0 ? RT_MAX(s->mouse_dz, -127)
654	: RT_MIN(s->mouse_dz, 127);
655	LogRel3(("%s: dz1=%d\n", __PRETTY_FUNCTION__, dz1));
656	s->mouse_dz -= dz1;
657	kbd_queue(s, dz1 & 0xff, aux);
658	}
659
660	static void kbd_mouse_send_imex_byte4(KBDState *s, bool fToCmdQueue)
661	{
662	int aux = fToCmdQueue ? 1 : 2;
663	int dz1 = 0, dw1 = 0;
664	unsigned fButtonsHigh = s->mouse_buttons & 0x18;
665
666	if (s->mouse_dw > 0)
667	dw1 = 1;
668	else if (s->mouse_dw < 0)
669	dw1 = -1;
670	else if (s->mouse_dz > 0)
671	dz1 = 1;
672	else if (s->mouse_dz < 0)
673	dz1 = -1;
674	if (s->mouse_dw && s->mouse_flags & MOUSE_REPORT_HORIZONTAL)
675	{
676	LogRel3(("%s: dw1=%d\n", __PRETTY_FUNCTION__, dw1));
677	kbd_queue(s, 0x40 \| (dw1 & 0x3f), aux);
678	}
679	else
680	{
681	LogRel3(("%s: dz1=%d, dw1=%d, fButtonsHigh=0x%x\n",
682	__PRETTY_FUNCTION__, dz1, dw1, fButtonsHigh));
683	unsigned u4Low = dw1 > 0 ? 9 /* -7 & 0xf */
684	: dw1 < 0 ? 7
685	: dz1 > 0 ? 1
686	: dz1 < 0 ? 0xf /* -1 & 0xf */
687	: 0;
688	kbd_mouse_set_reported_buttons(s, fButtonsHigh, 0x18);
689	kbd_queue(s, (fButtonsHigh << 1) \| u4Low, aux);
690	}
691	s->mouse_dz -= dz1;
692	s->mouse_dw -= dw1;
693	}
694
695	/**
696	* Send a single relative packet in (IM)PS/2 or IMEX format to the PS/2
697	* controller.
698	* @param s keyboard state object
699	* @param fToCmdQueue should this packet go to the command queue (or the
700	* event queue)?
701	*/
702	static void kbd_mouse_send_packet(KBDState *s, bool fToCmdQueue)
703	{
704	kbd_mouse_send_rel3_packet(s, fToCmdQueue);
705	if (s->mouse_type == MOUSE_PROT_IMPS2)
706	kbd_mouse_send_imps2_byte4(s, fToCmdQueue);
707	if (s->mouse_type == MOUSE_PROT_IMEX)
708	kbd_mouse_send_imex_byte4(s, fToCmdQueue);
709	}
710
711	#ifdef IN_RING3
712
713	static bool kbd_mouse_unreported(KBDState *s)
714	{
715	return s->mouse_dx
716	\|\| s->mouse_dy
717	\|\| s->mouse_dz
718	\|\| s->mouse_dw
719	\|\| s->mouse_buttons != s->mouse_buttons_reported;
720	}
721
722	static size_t kbd_mouse_event_queue_free(KBDState *s)
723	{
724	AssertReturn(s->mouse_event_queue.count <= MOUSE_EVENT_QUEUE_SIZE, 0);
725	return MOUSE_EVENT_QUEUE_SIZE - s->mouse_event_queue.count;
726	}
727
728	static void pc_kbd_mouse_event(void *opaque, int dx, int dy, int dz, int dw,
729	int buttons_state)
730	{
731	LogRel3(("%s: dx=%d, dy=%d, dz=%d, dw=%d, buttons_state=0x%x\n",
732	__PRETTY_FUNCTION__, dx, dy, dz, dw, buttons_state));
733	KBDState s = (KBDState)opaque;
734
735	/* check if deltas are recorded when disabled */
736	if (!(s->mouse_status & MOUSE_STATUS_ENABLED))
737	return;
738	AssertReturnVoid((buttons_state & ~0x1f) == 0);
739
740	s->mouse_dx += dx;
741	s->mouse_dy -= dy;
742	if ( (s->mouse_type == MOUSE_PROT_IMPS2)
743	\|\| (s->mouse_type == MOUSE_PROT_IMEX))
744	s->mouse_dz += dz;
745	if (s->mouse_type == MOUSE_PROT_IMEX)
746	s->mouse_dw += dw;
747	s->mouse_buttons = buttons_state;
748	if (!(s->mouse_status & MOUSE_STATUS_REMOTE))
749	/* if not remote, send event. Multiple events are sent if
750	too big deltas */
751	while ( kbd_mouse_unreported(s)
752	&& kbd_mouse_event_queue_free(s) > 4)
753	kbd_mouse_send_packet(s, false);
754	}
755
756	/* Report a change in status down the driver chain */
757	static void kbd_mouse_update_downstream_status(KBDState *pThis)
758	{
759	PPDMIMOUSECONNECTOR pDrv = pThis->Mouse.pDrv;
760	bool fEnabled = !!(pThis->mouse_status & MOUSE_STATUS_ENABLED);
761	if (pDrv)
762	pDrv->pfnReportModes(pDrv, fEnabled, false, false);
763	}
764
765	#endif /* IN_RING3 */
766
767	static int kbd_write_mouse(KBDState *s, int val)
768	{
769	#ifdef DEBUG_MOUSE
770	LogRelFlowFunc(("kbd: write mouse 0x%02x\n", val));
771	#endif
772	int rc = VINF_SUCCESS;
773	/* Flush the mouse command response queue. */
774	s->mouse_command_queue.count = 0;
775	s->mouse_command_queue.rptr = 0;
776	s->mouse_command_queue.wptr = 0;
777	switch(s->mouse_write_cmd) {
778	default:
779	case -1:
780	/* mouse command */
781	if (s->mouse_wrap) {
782	if (val == AUX_RESET_WRAP) {
783	s->mouse_wrap = 0;
784	kbd_queue(s, AUX_ACK, 1);
785	return VINF_SUCCESS;
786	} else if (val != AUX_RESET) {
787	kbd_queue(s, val, 1);
788	return VINF_SUCCESS;
789	}
790	}
791	switch(val) {
792	case AUX_SET_SCALE11:
793	s->mouse_status &= ~MOUSE_STATUS_SCALE21;
794	kbd_queue(s, AUX_ACK, 1);
795	break;
796	case AUX_SET_SCALE21:
797	s->mouse_status \|= MOUSE_STATUS_SCALE21;
798	kbd_queue(s, AUX_ACK, 1);
799	break;
800	case AUX_SET_STREAM:
801	s->mouse_status &= ~MOUSE_STATUS_REMOTE;
802	kbd_queue(s, AUX_ACK, 1);
803	break;
804	case AUX_SET_WRAP:
805	s->mouse_wrap = 1;
806	kbd_queue(s, AUX_ACK, 1);
807	break;
808	case AUX_SET_REMOTE:
809	s->mouse_status \|= MOUSE_STATUS_REMOTE;
810	kbd_queue(s, AUX_ACK, 1);
811	break;
812	case AUX_GET_TYPE:
813	kbd_queue(s, AUX_ACK, 1);
814	kbd_queue(s, s->mouse_type, 1);
815	break;
816	case AUX_SET_RES:
817	case AUX_SET_SAMPLE:
818	s->mouse_write_cmd = val;
819	kbd_queue(s, AUX_ACK, 1);
820	break;
821	case AUX_GET_SCALE:
822	kbd_queue(s, AUX_ACK, 1);
823	kbd_queue(s, s->mouse_status, 1);
824	kbd_queue(s, s->mouse_resolution, 1);
825	kbd_queue(s, s->mouse_sample_rate, 1);
826	break;
827	case AUX_POLL:
828	kbd_queue(s, AUX_ACK, 1);
829	kbd_mouse_send_packet(s, true);
830	break;
831	case AUX_ENABLE_DEV:
832	#ifdef IN_RING3
833	LogRelFlowFunc(("Enabling mouse device\n"));
834	s->mouse_status \|= MOUSE_STATUS_ENABLED;
835	kbd_queue(s, AUX_ACK, 1);
836	kbd_mouse_update_downstream_status(s);
837	#else
838	LogRelFlowFunc(("Enabling mouse device, R0 stub\n"));
839	rc = VINF_IOM_R3_IOPORT_WRITE;
840	#endif
841	break;
842	case AUX_DISABLE_DEV:
843	#ifdef IN_RING3
844	s->mouse_status &= ~MOUSE_STATUS_ENABLED;
845	kbd_queue(s, AUX_ACK, 1);
846	/* Flush the mouse events queue. */
847	s->mouse_event_queue.count = 0;
848	s->mouse_event_queue.rptr = 0;
849	s->mouse_event_queue.wptr = 0;
850	kbd_mouse_update_downstream_status(s);
851	#else
852	rc = VINF_IOM_R3_IOPORT_WRITE;
853	#endif
854	break;
855	case AUX_SET_DEFAULT:
856	#ifdef IN_RING3
857	s->mouse_sample_rate = 100;
858	s->mouse_resolution = 2;
859	s->mouse_status = 0;
860	kbd_queue(s, AUX_ACK, 1);
861	kbd_mouse_update_downstream_status(s);
862	#else
863	rc = VINF_IOM_R3_IOPORT_WRITE;
864	#endif
865	break;
866	case AUX_RESET:
867	#ifdef IN_RING3
868	s->mouse_sample_rate = 100;
869	s->mouse_resolution = 2;
870	s->mouse_status = 0;
871	s->mouse_type = MOUSE_PROT_PS2;
872	kbd_queue(s, AUX_ACK, 1);
873	kbd_queue(s, 0xaa, 1);
874	kbd_queue(s, s->mouse_type, 1);
875	/* Flush the mouse events queue. */
876	s->mouse_event_queue.count = 0;
877	s->mouse_event_queue.rptr = 0;
878	s->mouse_event_queue.wptr = 0;
879	kbd_mouse_update_downstream_status(s);
880	#else
881	rc = VINF_IOM_R3_IOPORT_WRITE;
882	#endif
883	break;
884	default:
885	/* NACK all commands we don't know.
886
887	The usecase for this is the OS/2 mouse driver which will try
888	read 0xE2 in order to figure out if it's a trackpoint device
889	or not. If it doesn't get a NACK (or ACK) on the command it'll
890	do several hundred thousand status reads before giving up. This
891	is slows down the OS/2 boot up considerably. (It also seems that
892	the code is somehow vulnerable while polling like this and that
893	mouse or keyboard input at this point might screw things up badly.)
894
895	From http://www.win.tue.nl/~aeb/linux/kbd/scancodes-13.html:
896
897	Every command or data byte sent to the mouse (except for the
898	resend command fe) is ACKed with fa. If the command or data
899	is invalid, it is NACKed with fe. If the next byte is again
900	invalid, the reply is ERROR: fc. */
901	/** @todo send error if we NACKed the previous command? */
902	kbd_queue(s, AUX_NACK, 1);
903	break;
904	}
905	break;
906	case AUX_SET_SAMPLE:
907	s->mouse_sample_rate = val;
908	/* detect IMPS/2 or IMEX */
909	/* And enable horizontal scrolling reporting when requested */
910	switch(s->mouse_detect_state) {
911	default:
912	case 0:
913	if (val == 200)
914	s->mouse_detect_state = 1;
915	break;
916	case 1:
917	if (val == 100)
918	s->mouse_detect_state = 2;
919	else if (val == 200)
920	s->mouse_detect_state = 3;
921	else if ((val == 80) && s->mouse_type == MOUSE_PROT_IMEX)
922	/* enable horizontal scrolling, byte two */
923	s->mouse_detect_state = 4;
924	else
925	s->mouse_detect_state = 0;
926	break;
927	case 2:
928	if (val == 80 && s->mouse_type < MOUSE_PROT_IMEX)
929	{
930	LogRelFlowFunc(("switching mouse device to IMPS/2 mode\n"));
931	s->mouse_type = MOUSE_PROT_IMPS2;
932	}
933	s->mouse_detect_state = 0;
934	break;
935	case 3:
936	if (val == 80)
937	{
938	LogRelFlowFunc(("switching mouse device to IMEX mode\n"));
939	s->mouse_type = MOUSE_PROT_IMEX;
940	}
941	s->mouse_detect_state = 0;
942	break;
943	case 4:
944	if (val == 40)
945	{
946	LogRelFlowFunc(("enabling IMEX horizontal scrolling reporting\n"));
947	s->mouse_flags \|= MOUSE_REPORT_HORIZONTAL;
948	}
949	s->mouse_detect_state = 0;
950	break;
951	}
952	kbd_queue(s, AUX_ACK, 1);
953	s->mouse_write_cmd = -1;
954	break;
955	case AUX_SET_RES:
956	if (0 <= val && val < 4)
957	{
958	s->mouse_resolution = val;
959	kbd_queue(s, AUX_ACK, 1);
960	}
961	else
962	kbd_queue(s, AUX_NACK, 1);
963	s->mouse_write_cmd = -1;
964	break;
965	}
966	return rc;
967	}
968	#endif
969
970	static int kbd_write_data(void *opaque, uint32_t addr, uint32_t val)
971	{
972	int rc = VINF_SUCCESS;
973	KBDState s = (KBDState)opaque;
974	NOREF(addr);
975
976	#ifdef DEBUG_KBD
977	Log(("kbd: write data=0x%02x\n", val));
978	#endif
979
980	switch(s->write_cmd) {
981	case 0:
982	/* Automatically enables keyboard interface. */
983	s->mode &= ~KBD_MODE_DISABLE_KBD;
984	rc = PS2KByteToKbd(&s->Kbd, val);
985	if (rc == VINF_SUCCESS)
986	kbd_update_irq(s);
987	break;
988	case KBD_CCMD_WRITE_MODE:
989	s->mode = val;
990	s->translate = (s->mode & KBD_MODE_KCC) == KBD_MODE_KCC;
991	kbd_update_irq(s);
992	break;
993	case KBD_CCMD_WRITE_OBUF:
994	kbc_dbb_out(s, val);
995	break;
996	case KBD_CCMD_WRITE_AUX_OBUF:
997	kbc_dbb_out_aux(s, val);
998	break;
999	case KBD_CCMD_WRITE_OUTPORT:
1000	#ifdef TARGET_I386
1001	# ifndef IN_RING3
1002	if (PDMDevHlpA20IsEnabled(s->CTX_SUFF(pDevIns)) != !!(val & 2))
1003	rc = VINF_IOM_R3_IOPORT_WRITE;
1004	# else /* IN_RING3 */
1005	PDMDevHlpA20Set(s->CTX_SUFF(pDevIns), !!(val & 2));
1006	# endif /* !IN_RING3 */
1007	#endif
1008	if (!(val & 1)) {
1009	# ifndef IN_RING3
1010	rc = VINF_IOM_R3_IOPORT_WRITE;
1011	# else
1012	rc = PDMDevHlpVMReset(s->CTX_SUFF(pDevIns));
1013	# endif
1014	}
1015	break;
1016	case KBD_CCMD_WRITE_MOUSE:
1017	/* Automatically enables aux interface. */
1018	s->mode &= ~KBD_MODE_DISABLE_MOUSE;
1019	#ifdef VBOX_WITH_NEW_PS2M
1020	rc = PS2MByteToAux(&s->Aux, val);
1021	if (rc == VINF_SUCCESS)
1022	kbd_update_irq(s);
1023	#else
1024	rc = kbd_write_mouse(s, val);
1025	#endif
1026	break;
1027	default:
1028	break;
1029	}
1030	if (rc != VINF_IOM_R3_IOPORT_WRITE)
1031	s->write_cmd = 0;
1032	return rc;
1033	}
1034
1035	#ifdef IN_RING3
1036
1037	static void kbd_reset(void *opaque)
1038	{
1039	KBDState s = (KBDState)opaque;
1040	#ifndef VBOX_WITH_NEW_PS2M
1041	MouseCmdQueue *mcq;
1042	MouseEventQueue *meq;
1043
1044	s->mouse_write_cmd = -1;
1045	#endif
1046	s->mode = KBD_MODE_KBD_INT \| KBD_MODE_MOUSE_INT;
1047	s->status = KBD_STAT_CMD \| KBD_STAT_UNLOCKED;
1048	/* Resetting everything, keyword was not working right on NT4 reboot. */
1049	s->write_cmd = 0;
1050	s->translate = 0;
1051	#ifndef VBOX_WITH_NEW_PS2M
1052	if (s->mouse_status)
1053	{
1054	s->mouse_status = 0;
1055	kbd_mouse_update_downstream_status(s);
1056	}
1057	s->mouse_resolution = 0;
1058	s->mouse_sample_rate = 0;
1059	s->mouse_wrap = 0;
1060	s->mouse_type = MOUSE_PROT_PS2;
1061	s->mouse_detect_state = 0;
1062	s->mouse_dx = 0;
1063	s->mouse_dy = 0;
1064	s->mouse_dz = 0;
1065	s->mouse_dw = 0;
1066	s->mouse_flags = 0;
1067	s->mouse_buttons = 0;
1068	s->mouse_buttons_reported = 0;
1069	mcq = &s->mouse_command_queue;
1070	mcq->rptr = 0;
1071	mcq->wptr = 0;
1072	mcq->count = 0;
1073	meq = &s->mouse_event_queue;
1074	meq->rptr = 0;
1075	meq->wptr = 0;
1076	meq->count = 0;
1077	#endif
1078	}
1079
1080	static void kbd_save(PSSMHANDLE pSSM, KBDState *s)
1081	{
1082	#ifndef VBOX_WITH_NEW_PS2M
1083	uint32_t cItems;
1084	int i;
1085	#endif
1086
1087	SSMR3PutU8(pSSM, s->write_cmd);
1088	SSMR3PutU8(pSSM, s->status);
1089	SSMR3PutU8(pSSM, s->mode);
1090	SSMR3PutU8(pSSM, s->dbbout);
1091	#ifndef VBOX_WITH_NEW_PS2M
1092	SSMR3PutU32(pSSM, s->mouse_write_cmd);
1093	SSMR3PutU8(pSSM, s->mouse_status);
1094	SSMR3PutU8(pSSM, s->mouse_resolution);
1095	SSMR3PutU8(pSSM, s->mouse_sample_rate);
1096	SSMR3PutU8(pSSM, s->mouse_wrap);
1097	SSMR3PutU8(pSSM, s->mouse_type);
1098	SSMR3PutU8(pSSM, s->mouse_detect_state);
1099	SSMR3PutU32(pSSM, s->mouse_dx);
1100	SSMR3PutU32(pSSM, s->mouse_dy);
1101	SSMR3PutU32(pSSM, s->mouse_dz);
1102	SSMR3PutU32(pSSM, s->mouse_dw);
1103	SSMR3PutU32(pSSM, s->mouse_flags);
1104	SSMR3PutU8(pSSM, s->mouse_buttons);
1105	SSMR3PutU8(pSSM, s->mouse_buttons_reported);
1106
1107	cItems = s->mouse_command_queue.count;
1108	SSMR3PutU32(pSSM, cItems);
1109	for (i = s->mouse_command_queue.rptr; cItems-- > 0; i = (i + 1) % RT_ELEMENTS(s->mouse_command_queue.data))
1110	SSMR3PutU8(pSSM, s->mouse_command_queue.data[i]);
1111	Log(("kbd_save: %d mouse command queue items stored\n", s->mouse_command_queue.count));
1112
1113	cItems = s->mouse_event_queue.count;
1114	SSMR3PutU32(pSSM, cItems);
1115	for (i = s->mouse_event_queue.rptr; cItems-- > 0; i = (i + 1) % RT_ELEMENTS(s->mouse_event_queue.data))
1116	SSMR3PutU8(pSSM, s->mouse_event_queue.data[i]);
1117	Log(("kbd_save: %d mouse event queue items stored\n", s->mouse_event_queue.count));
1118	#endif
1119
1120	/* terminator */
1121	SSMR3PutU32(pSSM, ~0);
1122	}
1123
1124	static int kbd_load(PSSMHANDLE pSSM, KBDState *s, uint32_t version_id)
1125	{
1126	uint32_t u32, i;
1127	uint8_t u8Dummy;
1128	uint32_t u32Dummy;
1129	int rc;
1130
1131	#if 0
1132	/** @todo enable this and remove the "if (version_id == 4)" code at some
1133	* later time */
1134	/* Version 4 was never created by any publicly released version of VBox */
1135	AssertReturn(version_id != 4, VERR_NOT_SUPPORTED);
1136	#endif
1137	if (version_id < 2 \|\| version_id > PCKBD_SAVED_STATE_VERSION)
1138	return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
1139	SSMR3GetU8(pSSM, &s->write_cmd);
1140	SSMR3GetU8(pSSM, &s->status);
1141	SSMR3GetU8(pSSM, &s->mode);
1142	if (version_id <= 5)
1143	{
1144	SSMR3GetU32(pSSM, (uint32_t *)&u32Dummy);
1145	SSMR3GetU32(pSSM, (uint32_t *)&u32Dummy);
1146	}
1147	else
1148	{
1149	SSMR3GetU8(pSSM, &s->dbbout);
1150	}
1151	#ifndef VBOX_WITH_NEW_PS2M
1152	SSMR3GetU32(pSSM, (uint32_t *)&s->mouse_write_cmd);
1153	SSMR3GetU8(pSSM, &s->mouse_status);
1154	SSMR3GetU8(pSSM, &s->mouse_resolution);
1155	SSMR3GetU8(pSSM, &s->mouse_sample_rate);
1156	SSMR3GetU8(pSSM, &s->mouse_wrap);
1157	SSMR3GetU8(pSSM, &s->mouse_type);
1158	SSMR3GetU8(pSSM, &s->mouse_detect_state);
1159	SSMR3GetU32(pSSM, (uint32_t *)&s->mouse_dx);
1160	SSMR3GetU32(pSSM, (uint32_t *)&s->mouse_dy);
1161	SSMR3GetU32(pSSM, (uint32_t *)&s->mouse_dz);
1162	if (version_id > 2)
1163	{
1164	SSMR3GetS32(pSSM, &s->mouse_dw);
1165	SSMR3GetS32(pSSM, &s->mouse_flags);
1166	}
1167	SSMR3GetU8(pSSM, &s->mouse_buttons);
1168	if (version_id == 4)
1169	{
1170	SSMR3GetU32(pSSM, &u32Dummy);
1171	SSMR3GetU32(pSSM, &u32Dummy);
1172	}
1173	if (version_id > 3)
1174	SSMR3GetU8(pSSM, &s->mouse_buttons_reported);
1175	if (version_id == 4)
1176	SSMR3GetU8(pSSM, &u8Dummy);
1177	s->mouse_command_queue.count = 0;
1178	s->mouse_command_queue.rptr = 0;
1179	s->mouse_command_queue.wptr = 0;
1180	s->mouse_event_queue.count = 0;
1181	s->mouse_event_queue.rptr = 0;
1182	s->mouse_event_queue.wptr = 0;
1183	#endif
1184
1185	/* Determine the translation state. */
1186	s->translate = (s->mode & KBD_MODE_KCC) == KBD_MODE_KCC;
1187
1188	/*
1189	* Load the queues
1190	*/
1191	if (version_id <= 5)
1192	{
1193	rc = SSMR3GetU32(pSSM, &u32);
1194	if (RT_FAILURE(rc))
1195	return rc;
1196	for (i = 0; i < u32; i++)
1197	{
1198	rc = SSMR3GetU8(pSSM, &u8Dummy);
1199	if (RT_FAILURE(rc))
1200	return rc;
1201	}
1202	Log(("kbd_load: %d keyboard queue items discarded from old saved state\n", u32));
1203	}
1204
1205	#ifndef VBOX_WITH_NEW_PS2M
1206	rc = SSMR3GetU32(pSSM, &u32);
1207	if (RT_FAILURE(rc))
1208	return rc;
1209	if (u32 > RT_ELEMENTS(s->mouse_command_queue.data))
1210	{
1211	AssertMsgFailed(("u32=%#x\n", u32));
1212	return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
1213	}
1214	for (i = 0; i < u32; i++)
1215	{
1216	rc = SSMR3GetU8(pSSM, &s->mouse_command_queue.data[i]);
1217	if (RT_FAILURE(rc))
1218	return rc;
1219	}
1220	s->mouse_command_queue.wptr = u32 % RT_ELEMENTS(s->mouse_command_queue.data);
1221	s->mouse_command_queue.count = u32;
1222	Log(("kbd_load: %d mouse command queue items loaded\n", u32));
1223
1224	rc = SSMR3GetU32(pSSM, &u32);
1225	if (RT_FAILURE(rc))
1226	return rc;
1227	if (u32 > RT_ELEMENTS(s->mouse_event_queue.data))
1228	{
1229	AssertMsgFailed(("u32=%#x\n", u32));
1230	return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
1231	}
1232	for (i = 0; i < u32; i++)
1233	{
1234	rc = SSMR3GetU8(pSSM, &s->mouse_event_queue.data[i]);
1235	if (RT_FAILURE(rc))
1236	return rc;
1237	}
1238	s->mouse_event_queue.wptr = u32 % RT_ELEMENTS(s->mouse_event_queue.data);
1239	s->mouse_event_queue.count = u32;
1240	Log(("kbd_load: %d mouse event queue items loaded\n", u32));
1241	#else
1242	if (version_id <= 6)
1243	{
1244	rc = SSMR3GetU32(pSSM, &u32);
1245	if (RT_FAILURE(rc))
1246	return rc;
1247	for (i = 0; i < u32; i++)
1248	{
1249	rc = SSMR3GetU8(pSSM, &u8Dummy);
1250	if (RT_FAILURE(rc))
1251	return rc;
1252	}
1253	Log(("kbd_load: %d mouse event queue items discarded from old saved state\n", u32));
1254	}
1255	#endif
1256
1257	/* terminator */
1258	rc = SSMR3GetU32(pSSM, &u32);
1259	if (RT_FAILURE(rc))
1260	return rc;
1261	if (u32 != ~0U)
1262	{
1263	AssertMsgFailed(("u32=%#x\n", u32));
1264	return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
1265	}
1266	#ifndef VBOX_WITH_NEW_PS2M
1267	/* Resend a notification to Main if the device is active */
1268	kbd_mouse_update_downstream_status(s);
1269	#endif
1270	return 0;
1271	}
1272	#endif /* IN_RING3 */
1273
1274
1275	/* VirtualBox code start */
1276
1277	/* -=-=-=-=-=- wrappers -=-=-=-=-=- */
1278
1279	/**
1280	* Port I/O Handler for keyboard data IN operations.
1281	*
1282	* @returns VBox status code.
1283	*
1284	* @param pDevIns The device instance.
1285	* @param pvUser User argument - ignored.
1286	* @param Port Port number used for the IN operation.
1287	* @param pu32 Where to store the result.
1288	* @param cb Number of bytes read.
1289	*/
1290	PDMBOTHCBDECL(int) kbdIOPortDataRead(PPDMDEVINS pDevIns, void pvUser, RTIOPORT Port, uint32_t pu32, unsigned cb)
1291	{
1292	NOREF(pvUser);
1293	if (cb == 1)
1294	{
1295	KBDState pThis = PDMINS_2_DATA(pDevIns, KBDState );
1296	*pu32 = kbd_read_data(pThis, Port);
1297	Log2(("kbdIOPortDataRead: Port=%#x cb=%d pu32=%#x\n", Port, cb, pu32));
1298	return VINF_SUCCESS;
1299	}
1300	AssertMsgFailed(("Port=%#x cb=%d\n", Port, cb));
1301	return VERR_IOM_IOPORT_UNUSED;
1302	}
1303
1304	/**
1305	* Port I/O Handler for keyboard data OUT operations.
1306	*
1307	* @returns VBox status code.
1308	*
1309	* @param pDevIns The device instance.
1310	* @param pvUser User argument - ignored.
1311	* @param Port Port number used for the IN operation.
1312	* @param u32 The value to output.
1313	* @param cb The value size in bytes.
1314	*/
1315	PDMBOTHCBDECL(int) kbdIOPortDataWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
1316	{
1317	int rc = VINF_SUCCESS;
1318	NOREF(pvUser);
1319	if (cb == 1)
1320	{
1321	KBDState pThis = PDMINS_2_DATA(pDevIns, KBDState );
1322	rc = kbd_write_data(pThis, Port, u32);
1323	Log2(("kbdIOPortDataWrite: Port=%#x cb=%d u32=%#x\n", Port, cb, u32));
1324	}
1325	else
1326	AssertMsgFailed(("Port=%#x cb=%d\n", Port, cb));
1327	return rc;
1328	}
1329
1330	/**
1331	* Port I/O Handler for keyboard status IN operations.
1332	*
1333	* @returns VBox status code.
1334	*
1335	* @param pDevIns The device instance.
1336	* @param pvUser User argument - ignored.
1337	* @param Port Port number used for the IN operation.
1338	* @param pu32 Where to store the result.
1339	* @param cb Number of bytes read.
1340	*/
1341	PDMBOTHCBDECL(int) kbdIOPortStatusRead(PPDMDEVINS pDevIns, void pvUser, RTIOPORT Port, uint32_t pu32, unsigned cb)
1342	{
1343	NOREF(pvUser);
1344	if (cb == 1)
1345	{
1346	KBDState pThis = PDMINS_2_DATA(pDevIns, KBDState );
1347	*pu32 = kbd_read_status(pThis, Port);
1348	Log2(("kbdIOPortStatusRead: Port=%#x cb=%d -> pu32=%#x\n", Port, cb, pu32));
1349	return VINF_SUCCESS;
1350	}
1351	AssertMsgFailed(("Port=%#x cb=%d\n", Port, cb));
1352	return VERR_IOM_IOPORT_UNUSED;
1353	}
1354
1355	/**
1356	* Port I/O Handler for keyboard command OUT operations.
1357	*
1358	* @returns VBox status code.
1359	*
1360	* @param pDevIns The device instance.
1361	* @param pvUser User argument - ignored.
1362	* @param Port Port number used for the IN operation.
1363	* @param u32 The value to output.
1364	* @param cb The value size in bytes.
1365	*/
1366	PDMBOTHCBDECL(int) kbdIOPortCommandWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
1367	{
1368	int rc = VINF_SUCCESS;
1369	NOREF(pvUser);
1370	if (cb == 1)
1371	{
1372	KBDState pThis = PDMINS_2_DATA(pDevIns, KBDState );
1373	rc = kbd_write_command(pThis, Port, u32);
1374	Log2(("kbdIOPortCommandWrite: Port=%#x cb=%d u32=%#x rc=%Rrc\n", Port, cb, u32, rc));
1375	}
1376	else
1377	AssertMsgFailed(("Port=%#x cb=%d\n", Port, cb));
1378	return rc;
1379	}
1380
1381	#ifdef IN_RING3
1382
1383	/**
1384	* Saves a state of the keyboard device.
1385	*
1386	* @returns VBox status code.
1387	* @param pDevIns The device instance.
1388	* @param pSSM The handle to save the state to.
1389	*/
1390	static DECLCALLBACK(int) kbdSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
1391	{
1392	KBDState pThis = PDMINS_2_DATA(pDevIns, KBDState );
1393	kbd_save(pSSM, pThis);
1394	PS2KSaveState(&pThis->Kbd, pSSM);
1395	#ifdef VBOX_WITH_NEW_PS2M
1396	PS2MSaveState(&pThis->Aux, pSSM);
1397	#endif
1398	return VINF_SUCCESS;
1399	}
1400
1401
1402	/**
1403	* Loads a saved keyboard device state.
1404	*
1405	* @returns VBox status code.
1406	* @param pDevIns The device instance.
1407	* @param pSSM The handle to the saved state.
1408	* @param uVersion The data unit version number.
1409	* @param uPass The data pass.
1410	*/
1411	static DECLCALLBACK(int) kbdLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
1412	{
1413	KBDState pThis = PDMINS_2_DATA(pDevIns, KBDState );
1414	int rc;
1415
1416	Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
1417	rc = kbd_load(pSSM, pThis, uVersion);
1418	if (uVersion >= 6)
1419	rc = PS2KLoadState(&pThis->Kbd, pSSM, uVersion);
1420	#ifdef VBOX_WITH_NEW_PS2M
1421	if (uVersion >= 7)
1422	rc = PS2MLoadState(&pThis->Aux, pSSM, uVersion);
1423	#endif
1424	return rc;
1425	}
1426
1427	/**
1428	* @callback_method_impl{FNSSMDEVLOADDONE, Key state fix-up after loading
1429	*/
1430	static DECLCALLBACK(int) kbdLoadDone(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
1431	{
1432	KBDState pThis = PDMINS_2_DATA(pDevIns, KBDState );
1433	int rc;
1434
1435	rc = PS2KLoadDone(&pThis->Kbd, pSSM);
1436	return rc;
1437	}
1438
1439	/**
1440	* Reset notification.
1441	*
1442	* @returns VBox status.
1443	* @param pDevIns The device instance data.
1444	*/
1445	static DECLCALLBACK(void) kbdReset(PPDMDEVINS pDevIns)
1446	{
1447	KBDState pThis = PDMINS_2_DATA(pDevIns, KBDState );
1448
1449	kbd_reset(pThis);
1450	PS2KReset(&pThis->Kbd);
1451	#ifdef VBOX_WITH_NEW_PS2M
1452	PS2MReset(&pThis->Aux);
1453	#endif
1454	}
1455
1456
1457	#ifndef VBOX_WITH_NEW_PS2M
1458	/* -=-=-=-=-=- Mouse: IBase -=-=-=-=-=- */
1459
1460	/**
1461	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
1462	*/
1463	static DECLCALLBACK(void ) kbdMouseQueryInterface(PPDMIBASE pInterface, const char pszIID)
1464	{
1465	KBDState *pThis = RT_FROM_MEMBER(pInterface, KBDState, Mouse.IBase);
1466	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->Mouse.IBase);
1467	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMOUSEPORT, &pThis->Mouse.IPort);
1468	return NULL;
1469	}
1470
1471
1472	/* -=-=-=-=-=- Mouse: IMousePort -=-=-=-=-=- */
1473
1474	/**
1475	* @interface_method_impl{PDMIMOUSEPORT, pfnPutEvent}
1476	*/
1477	static DECLCALLBACK(int) kbdMousePutEvent(PPDMIMOUSEPORT pInterface, int32_t dx,
1478	int32_t dy, int32_t dz, int32_t dw,
1479	uint32_t fButtons)
1480	{
1481	KBDState *pThis = RT_FROM_MEMBER(pInterface, KBDState, Mouse.IPort);
1482	int rc = PDMCritSectEnter(pThis->pDevInsR3->pCritSectRoR3, VERR_SEM_BUSY);
1483	AssertReleaseRC(rc);
1484
1485	pc_kbd_mouse_event(pThis, dx, dy, dz, dw, fButtons);
1486
1487	PDMCritSectLeave(pThis->pDevInsR3->pCritSectRoR3);
1488	return VINF_SUCCESS;
1489	}
1490
1491	/**
1492	* @interface_method_impl{PDMIMOUSEPORT, pfnPutEventAbs}
1493	*/
1494	static DECLCALLBACK(int) kbdMousePutEventAbs(PPDMIMOUSEPORT pInterface,
1495	uint32_t x, uint32_t y, int32_t dz,
1496	int32_t dw, uint32_t fButtons)
1497	{
1498	AssertFailedReturn(VERR_NOT_SUPPORTED);
1499	NOREF(pInterface); NOREF(x); NOREF(y); NOREF(dz); NOREF(dw); NOREF(fButtons);
1500	}
1501
1502	/**
1503	* @interface_method_impl{PDMIMOUSEPORT, pfnPutEventMultiTouch}
1504	*/
1505	static DECLCALLBACK(int) kbdMousePutEventMultiTouch(PPDMIMOUSEPORT pInterface,
1506	uint8_t cContacts,
1507	const uint64_t *pau64Contacts,
1508	uint32_t u32ScanTime)
1509	{
1510	AssertFailedReturn(VERR_NOT_SUPPORTED);
1511	NOREF(pInterface); NOREF(cContacts); NOREF(pau64Contacts); NOREF(u32ScanTime);
1512	}
1513	#endif
1514
1515	/* -=-=-=-=-=- real code -=-=-=-=-=- */
1516
1517
1518	/**
1519	* Attach command.
1520	*
1521	* This is called to let the device attach to a driver for a specified LUN
1522	* during runtime. This is not called during VM construction, the device
1523	* constructor have to attach to all the available drivers.
1524	*
1525	* This is like plugging in the keyboard or mouse after turning on the PC.
1526	*
1527	* @returns VBox status code.
1528	* @param pDevIns The device instance.
1529	* @param iLUN The logical unit which is being detached.
1530	* @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
1531	* @remark The keyboard controller doesn't support this action, this is just
1532	* implemented to try out the driver<->device structure.
1533	*/
1534	static DECLCALLBACK(int) kbdAttach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
1535	{
1536	int rc;
1537	KBDState pThis = PDMINS_2_DATA(pDevIns, KBDState );
1538
1539	AssertMsgReturn(fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG,
1540	("PS/2 device does not support hotplugging\n"),
1541	VERR_INVALID_PARAMETER);
1542
1543	switch (iLUN)
1544	{
1545	/* LUN #0: keyboard */
1546	case 0:
1547	rc = PS2KAttach(&pThis->Kbd, pDevIns, iLUN, fFlags);
1548	if (RT_FAILURE(rc))
1549	return rc;
1550	break;
1551
1552	/* LUN #1: aux/mouse */
1553	case 1:
1554	#ifdef VBOX_WITH_NEW_PS2M
1555	rc = PS2MAttach(&pThis->Aux, pDevIns, iLUN, fFlags);
1556	#else
1557	rc = PDMDevHlpDriverAttach(pDevIns, iLUN, &pThis->Mouse.IBase, &pThis->Mouse.pDrvBase, "Aux (Mouse) Port");
1558	if (RT_SUCCESS(rc))
1559	{
1560	pThis->Mouse.pDrv = PDMIBASE_QUERY_INTERFACE(pThis->Mouse.pDrvBase, PDMIMOUSECONNECTOR);
1561	if (!pThis->Mouse.pDrv)
1562	{
1563	AssertLogRelMsgFailed(("LUN #1 doesn't have a mouse interface! rc=%Rrc\n", rc));
1564	rc = VERR_PDM_MISSING_INTERFACE;
1565	}
1566	}
1567	else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
1568	{
1569	Log(("%s/%d: warning: no driver attached to LUN #1!\n", pDevIns->pReg->szName, pDevIns->iInstance));
1570	rc = VINF_SUCCESS;
1571	}
1572	else
1573	AssertLogRelMsgFailed(("Failed to attach LUN #1! rc=%Rrc\n", rc));
1574	#endif
1575	break;
1576
1577	default:
1578	AssertMsgFailed(("Invalid LUN #%d\n", iLUN));
1579	return VERR_PDM_NO_SUCH_LUN;
1580	}
1581
1582	return rc;
1583	}
1584
1585
1586	/**
1587	* Detach notification.
1588	*
1589	* This is called when a driver is detaching itself from a LUN of the device.
1590	* The device should adjust it's state to reflect this.
1591	*
1592	* This is like unplugging the network cable to use it for the laptop or
1593	* something while the PC is still running.
1594	*
1595	* @param pDevIns The device instance.
1596	* @param iLUN The logical unit which is being detached.
1597	* @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
1598	* @remark The keyboard controller doesn't support this action, this is just
1599	* implemented to try out the driver<->device structure.
1600	*/
1601	static DECLCALLBACK(void) kbdDetach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
1602	{
1603	#if 0
1604	/*
1605	* Reset the interfaces and update the controller state.
1606	*/
1607	KBDState pThis = PDMINS_2_DATA(pDevIns, KBDState );
1608	switch (iLUN)
1609	{
1610	/* LUN #0: keyboard */
1611	case 0:
1612	pThis->Keyboard.pDrv = NULL;
1613	pThis->Keyboard.pDrvBase = NULL;
1614	break;
1615
1616	/* LUN #1: aux/mouse */
1617	case 1:
1618	pThis->Mouse.pDrv = NULL;
1619	pThis->Mouse.pDrvBase = NULL;
1620	break;
1621
1622	default:
1623	AssertMsgFailed(("Invalid LUN #%d\n", iLUN));
1624	break;
1625	}
1626	#else
1627	NOREF(pDevIns); NOREF(iLUN); NOREF(fFlags);
1628	#endif
1629	}
1630
1631
1632	/**
1633	* @copydoc FNPDMDEVRELOCATE
1634	*/
1635	static DECLCALLBACK(void) kbdRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
1636	{
1637	KBDState pThis = PDMINS_2_DATA(pDevIns, KBDState );
1638	pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
1639	PS2KRelocate(&pThis->Kbd, offDelta, pDevIns);
1640	#ifdef VBOX_WITH_NEW_PS2M
1641	PS2MRelocate(&pThis->Aux, offDelta, pDevIns);
1642	#endif
1643	}
1644
1645
1646	/**
1647	* @interface_method_impl{PDMDEVREG,pfnConstruct}
1648	*/
1649	static DECLCALLBACK(int) kbdConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
1650	{
1651	KBDState pThis = PDMINS_2_DATA(pDevIns, KBDState );
1652	int rc;
1653	bool fGCEnabled;
1654	bool fR0Enabled;
1655	Assert(iInstance == 0);
1656
1657	PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
1658
1659	/*
1660	* Validate and read the configuration.
1661	*/
1662	if (!CFGMR3AreValuesValid(pCfg, "GCEnabled\0R0Enabled\0"))
1663	return VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES;
1664	rc = CFGMR3QueryBoolDef(pCfg, "GCEnabled", &fGCEnabled, true);
1665	if (RT_FAILURE(rc))
1666	return PDMDEV_SET_ERROR(pDevIns, rc, N_("Failed to query \"GCEnabled\" from the config"));
1667	rc = CFGMR3QueryBoolDef(pCfg, "R0Enabled", &fR0Enabled, true);
1668	if (RT_FAILURE(rc))
1669	return PDMDEV_SET_ERROR(pDevIns, rc, N_("Failed to query \"R0Enabled\" from the config"));
1670	fGCEnabled = fR0Enabled = false;
1671	Log(("pckbd: fGCEnabled=%RTbool fR0Enabled=%RTbool\n", fGCEnabled, fR0Enabled));
1672
1673
1674	/*
1675	* Initialize the interfaces.
1676	*/
1677	pThis->pDevInsR3 = pDevIns;
1678	pThis->pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
1679	pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
1680
1681	rc = PS2KConstruct(&pThis->Kbd, pDevIns, pThis, iInstance);
1682	if (RT_FAILURE(rc))
1683	return rc;
1684
1685	#ifdef VBOX_WITH_NEW_PS2M
1686	rc = PS2MConstruct(&pThis->Aux, pDevIns, pThis, iInstance);
1687	if (RT_FAILURE(rc))
1688	return rc;
1689	#else
1690	pThis->Mouse.IBase.pfnQueryInterface = kbdMouseQueryInterface;
1691	pThis->Mouse.IPort.pfnPutEvent = kbdMousePutEvent;
1692	pThis->Mouse.IPort.pfnPutEventAbs = kbdMousePutEventAbs;
1693	pThis->Mouse.IPort.pfnPutEventMultiTouch = kbdMousePutEventMultiTouch;
1694	#endif
1695
1696	/*
1697	* Register I/O ports, save state, keyboard event handler and mouse event handlers.
1698	*/
1699	rc = PDMDevHlpIOPortRegister(pDevIns, 0x60, 1, NULL, kbdIOPortDataWrite, kbdIOPortDataRead, NULL, NULL, "PC Keyboard - Data");
1700	if (RT_FAILURE(rc))
1701	return rc;
1702	rc = PDMDevHlpIOPortRegister(pDevIns, 0x64, 1, NULL, kbdIOPortCommandWrite, kbdIOPortStatusRead, NULL, NULL, "PC Keyboard - Command / Status");
1703	if (RT_FAILURE(rc))
1704	return rc;
1705	if (fGCEnabled)
1706	{
1707	rc = PDMDevHlpIOPortRegisterRC(pDevIns, 0x60, 1, 0, "kbdIOPortDataWrite", "kbdIOPortDataRead", NULL, NULL, "PC Keyboard - Data");
1708	if (RT_FAILURE(rc))
1709	return rc;
1710	rc = PDMDevHlpIOPortRegisterRC(pDevIns, 0x64, 1, 0, "kbdIOPortCommandWrite", "kbdIOPortStatusRead", NULL, NULL, "PC Keyboard - Command / Status");
1711	if (RT_FAILURE(rc))
1712	return rc;
1713	}
1714	if (fR0Enabled)
1715	{
1716	rc = PDMDevHlpIOPortRegisterR0(pDevIns, 0x60, 1, 0, "kbdIOPortDataWrite", "kbdIOPortDataRead", NULL, NULL, "PC Keyboard - Data");
1717	if (RT_FAILURE(rc))
1718	return rc;
1719	rc = PDMDevHlpIOPortRegisterR0(pDevIns, 0x64, 1, 0, "kbdIOPortCommandWrite", "kbdIOPortStatusRead", NULL, NULL, "PC Keyboard - Command / Status");
1720	if (RT_FAILURE(rc))
1721	return rc;
1722	}
1723	rc = PDMDevHlpSSMRegisterEx(pDevIns, PCKBD_SAVED_STATE_VERSION, sizeof(*pThis), NULL,
1724	NULL, NULL, NULL,
1725	NULL, kbdSaveExec, NULL,
1726	NULL, kbdLoadExec, kbdLoadDone);
1727	if (RT_FAILURE(rc))
1728	return rc;
1729
1730	/*
1731	* Attach to the keyboard and mouse drivers.
1732	*/
1733	rc = kbdAttach(pDevIns, 0 /* keyboard LUN # */, PDM_TACH_FLAGS_NOT_HOT_PLUG);
1734	if (RT_FAILURE(rc))
1735	return rc;
1736	rc = kbdAttach(pDevIns, 1 /* aux/mouse LUN # */, PDM_TACH_FLAGS_NOT_HOT_PLUG);
1737	if (RT_FAILURE(rc))
1738	return rc;
1739
1740	/*
1741	* Initialize the device state.
1742	*/
1743	kbdReset(pDevIns);
1744
1745	return VINF_SUCCESS;
1746	}
1747
1748
1749	/**
1750	* The device registration structure.
1751	*/
1752	const PDMDEVREG g_DevicePS2KeyboardMouse =
1753	{
1754	/* u32Version */
1755	PDM_DEVREG_VERSION,
1756	/* szName */
1757	"pckbd",
1758	/* szRCMod */
1759	"VBoxDDGC.gc",
1760	/* szR0Mod */
1761	"VBoxDDR0.r0",
1762	/* pszDescription */
1763	"PS/2 Keyboard and Mouse device. Emulates both the keyboard, mouse and the keyboard controller. "
1764	"LUN #0 is the keyboard connector. "
1765	"LUN #1 is the aux/mouse connector.",
1766	/* fFlags */
1767	PDM_DEVREG_FLAGS_HOST_BITS_DEFAULT \| PDM_DEVREG_FLAGS_GUEST_BITS_32_64 \| PDM_DEVREG_FLAGS_PAE36 \| PDM_DEVREG_FLAGS_RC \| PDM_DEVREG_FLAGS_R0,
1768	/* fClass */
1769	PDM_DEVREG_CLASS_INPUT,
1770	/* cMaxInstances */
1771	1,
1772	/* cbInstance */
1773	sizeof(KBDState),
1774	/* pfnConstruct */
1775	kbdConstruct,
1776	/* pfnDestruct */
1777	NULL,
1778	/* pfnRelocate */
1779	kbdRelocate,
1780	/* pfnMemSetup */
1781	NULL,
1782	/* pfnPowerOn */
1783	NULL,
1784	/* pfnReset */
1785	kbdReset,
1786	/* pfnSuspend */
1787	NULL,
1788	/* pfnResume */
1789	NULL,
1790	/* pfnAttach */
1791	kbdAttach,
1792	/* pfnDetach */
1793	kbdDetach,
1794	/* pfnQueryInterface. */
1795	NULL,
1796	/* pfnInitComplete */
1797	NULL,
1798	/* pfnPowerOff */
1799	NULL,
1800	/* pfnSoftReset */
1801	NULL,
1802	/* u32VersionEnd */
1803	PDM_DEVREG_VERSION
1804	};
1805
1806	#endif /* IN_RING3 */
1807	#endif /* !VBOX_DEVICE_STRUCT_TESTCASE */
1808

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

source: vbox/trunk/src/VBox/Devices/Input/DevPS2.cpp@ 49886

Download in other formats: