DevPS2.cpp@ 40040

Last change on this file since 40040 was 40040, checked in by vboxsync, 13 years ago
Removed old keyboard code.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 54.6 KB

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

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

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

Download in other formats: