DevPS2.cpp@ 3155

Last change on this file since 3155 was 2981, checked in by vboxsync, 18 years ago
InnoTek -> innotek: all the headers and comments.
Property svn:eol-style set to `native`
File size: 52.6 KB

Line
1	#ifdef VBOX
2	/** @file
3	*
4	* VBox input devices:
5	* PS/2 keyboard & mouse controller device
6	*/
7
8	/*
9	* Copyright (C) 2006-2007 innotek GmbH
10	*
11	* This file is part of VirtualBox Open Source Edition (OSE), as
12	* available from http://www.virtualbox.org. This file is free software;
13	* you can redistribute it and/or modify it under the terms of the GNU
14	* General Public License as published by the Free Software Foundation,
15	* in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
16	* distribution. VirtualBox OSE is distributed in the hope that it will
17	* be useful, but WITHOUT ANY WARRANTY of any kind.
18	*
19	* If you received this file as part of a commercial VirtualBox
20	* distribution, then only the terms of your commercial VirtualBox
21	* license agreement apply instead of the previous paragraph.
22	*
23	* --------------------------------------------------------------------
24	*
25	* This code is based on:
26	*
27	* QEMU PC keyboard emulation (revision 1.12)
28	*
29	* Copyright (c) 2003 Fabrice Bellard
30	*
31	* Permission is hereby granted, free of charge, to any person obtaining a copy
32	* of this software and associated documentation files (the "Software"), to deal
33	* in the Software without restriction, including without limitation the rights
34	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
35	* copies of the Software, and to permit persons to whom the Software is
36	* furnished to do so, subject to the following conditions:
37	*
38	* The above copyright notice and this permission notice shall be included in
39	* all copies or substantial portions of the Software.
40	*
41	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
42	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
43	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
44	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
45	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
46	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
47	* THE SOFTWARE.
48	*
49	*/
50
51
52	/*******************************************************************************
53	* Header Files *
54	*******************************************************************************/
55	#define LOG_GROUP LOG_GROUP_DEV_KBD
56	#include "vl_vbox.h"
57	#include <VBox/pdm.h>
58	#include <VBox/err.h>
59
60	#include <VBox/log.h>
61	#include <iprt/assert.h>
62
63	#include "Builtins.h"
64
65	#define PCKBD_SAVED_STATE_VERSION 2
66
67
68	#ifndef VBOX_DEVICE_STRUCT_TESTCASE
69	/*******************************************************************************
70	* Internal Functions *
71	*******************************************************************************/
72	__BEGIN_DECLS
73	PDMBOTHCBDECL(int) kbdIOPortDataRead(PPDMDEVINS pDevIns, void pvUser, RTIOPORT Port, uint32_t pu32, unsigned cb);
74	PDMBOTHCBDECL(int) kbdIOPortDataWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb);
75	PDMBOTHCBDECL(int) kbdIOPortStatusRead(PPDMDEVINS pDevIns, void pvUser, RTIOPORT Port, uint32_t pu32, unsigned cb);
76	PDMBOTHCBDECL(int) kbdIOPortCommandWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb);
77	__END_DECLS
78	#endif /* !VBOX_DEVICE_STRUCT_TESTCASE */
79	#endif /* VBOX */
80
81
82	#ifndef VBOX
83	#include "vl.h"
84	#endif
85
86	#ifdef VBOX
87	/* debug PC keyboard */
88	#define DEBUG_KBD
89
90	/* debug PC keyboard : only mouse */
91	#define DEBUG_MOUSE
92	#endif /* VBOX */
93
94	/* Keyboard Controller Commands */
95	#define KBD_CCMD_READ_MODE 0x20 /* Read mode bits */
96	#define KBD_CCMD_WRITE_MODE 0x60 /* Write mode bits */
97	#define KBD_CCMD_GET_VERSION 0xA1 /* Get controller version */
98	#define KBD_CCMD_MOUSE_DISABLE 0xA7 /* Disable mouse interface */
99	#define KBD_CCMD_MOUSE_ENABLE 0xA8 /* Enable mouse interface */
100	#define KBD_CCMD_TEST_MOUSE 0xA9 /* Mouse interface test */
101	#define KBD_CCMD_SELF_TEST 0xAA /* Controller self test */
102	#define KBD_CCMD_KBD_TEST 0xAB /* Keyboard interface test */
103	#define KBD_CCMD_KBD_DISABLE 0xAD /* Keyboard interface disable */
104	#define KBD_CCMD_KBD_ENABLE 0xAE /* Keyboard interface enable */
105	#define KBD_CCMD_READ_INPORT 0xC0 /* read input port */
106	#define KBD_CCMD_READ_OUTPORT 0xD0 /* read output port */
107	#define KBD_CCMD_WRITE_OUTPORT 0xD1 /* write output port */
108	#define KBD_CCMD_WRITE_OBUF 0xD2
109	#define KBD_CCMD_WRITE_AUX_OBUF 0xD3 /* Write to output buffer as if
110	initiated by the auxiliary device */
111	#define KBD_CCMD_WRITE_MOUSE 0xD4 /* Write the following byte to the mouse */
112	#define KBD_CCMD_DISABLE_A20 0xDD /* HP vectra only ? */
113	#define KBD_CCMD_ENABLE_A20 0xDF /* HP vectra only ? */
114	#define KBD_CCMD_RESET 0xFE
115
116	/* Keyboard Commands */
117	#define KBD_CMD_SET_LEDS 0xED /* Set keyboard leds */
118	#define KBD_CMD_ECHO 0xEE
119	#define KBD_CMD_GET_ID 0xF2 /* get keyboard ID */
120	#define KBD_CMD_SET_RATE 0xF3 /* Set typematic rate */
121	#define KBD_CMD_ENABLE 0xF4 /* Enable scanning */
122	#define KBD_CMD_RESET_DISABLE 0xF5 /* reset and disable scanning */
123	#define KBD_CMD_RESET_ENABLE 0xF6 /* reset and enable scanning */
124	#define KBD_CMD_RESET 0xFF /* Reset */
125
126	/* Keyboard Replies */
127	#define KBD_REPLY_POR 0xAA /* Power on reset */
128	#define KBD_REPLY_ACK 0xFA /* Command ACK */
129	#define KBD_REPLY_RESEND 0xFE /* Command NACK, send the cmd again */
130
131	/* Status Register Bits */
132	#define KBD_STAT_OBF 0x01 /* Keyboard output buffer full */
133	#define KBD_STAT_IBF 0x02 /* Keyboard input buffer full */
134	#define KBD_STAT_SELFTEST 0x04 /* Self test successful */
135	#define KBD_STAT_CMD 0x08 /* Last write was a command write (0=data) */
136	#define KBD_STAT_UNLOCKED 0x10 /* Zero if keyboard locked */
137	#define KBD_STAT_MOUSE_OBF 0x20 /* Mouse output buffer full */
138	#define KBD_STAT_GTO 0x40 /* General receive/xmit timeout */
139	#define KBD_STAT_PERR 0x80 /* Parity error */
140
141	/* Controller Mode Register Bits */
142	#define KBD_MODE_KBD_INT 0x01 /* Keyboard data generate IRQ1 */
143	#define KBD_MODE_MOUSE_INT 0x02 /* Mouse data generate IRQ12 */
144	#define KBD_MODE_SYS 0x04 /* The system flag (?) */
145	#define KBD_MODE_NO_KEYLOCK 0x08 /* The keylock doesn't affect the keyboard if set */
146	#define KBD_MODE_DISABLE_KBD 0x10 /* Disable keyboard interface */
147	#define KBD_MODE_DISABLE_MOUSE 0x20 /* Disable mouse interface */
148	#define KBD_MODE_KCC 0x40 /* Scan code conversion to PC format */
149	#define KBD_MODE_RFU 0x80
150
151	/* Mouse Commands */
152	#define AUX_SET_SCALE11 0xE6 /* Set 1:1 scaling */
153	#define AUX_SET_SCALE21 0xE7 /* Set 2:1 scaling */
154	#define AUX_SET_RES 0xE8 /* Set resolution */
155	#define AUX_GET_SCALE 0xE9 /* Get scaling factor */
156	#define AUX_SET_STREAM 0xEA /* Set stream mode */
157	#define AUX_POLL 0xEB /* Poll */
158	#define AUX_RESET_WRAP 0xEC /* Reset wrap mode */
159	#define AUX_SET_WRAP 0xEE /* Set wrap mode */
160	#define AUX_SET_REMOTE 0xF0 /* Set remote mode */
161	#define AUX_GET_TYPE 0xF2 /* Get type */
162	#define AUX_SET_SAMPLE 0xF3 /* Set sample rate */
163	#define AUX_ENABLE_DEV 0xF4 /* Enable aux device */
164	#define AUX_DISABLE_DEV 0xF5 /* Disable aux device */
165	#define AUX_SET_DEFAULT 0xF6
166	#define AUX_RESET 0xFF /* Reset aux device */
167	#define AUX_ACK 0xFA /* Command byte ACK. */
168
169	#define MOUSE_STATUS_REMOTE 0x40
170	#define MOUSE_STATUS_ENABLED 0x20
171	#define MOUSE_STATUS_SCALE21 0x10
172
173	#define KBD_QUEUE_SIZE 256
174
175	typedef struct {
176	#ifndef VBOX
177	uint8_t aux[KBD_QUEUE_SIZE];
178	#endif /* !VBOX */
179	uint8_t data[KBD_QUEUE_SIZE];
180	int rptr, wptr, count;
181	} KBDQueue;
182
183	#ifdef VBOX
184
185	#define MOUSE_CMD_QUEUE_SIZE 8
186
187	typedef struct {
188	uint8_t data[MOUSE_CMD_QUEUE_SIZE];
189	int rptr, wptr, count;
190	} MouseCmdQueue;
191
192
193	#define MOUSE_EVENT_QUEUE_SIZE 256
194
195	typedef struct {
196	uint8_t data[MOUSE_EVENT_QUEUE_SIZE];
197	int rptr, wptr, count;
198	} MouseEventQueue;
199
200	#endif /* VBOX */
201
202	typedef struct KBDState {
203	KBDQueue queue;
204	#ifdef VBOX
205	MouseCmdQueue mouse_command_queue;
206	MouseEventQueue mouse_event_queue;
207	#endif /* VBOX */
208	uint8_t write_cmd; /* if non zero, write data to port 60 is expected */
209	uint8_t status;
210	uint8_t mode;
211	/* keyboard state */
212	int32_t kbd_write_cmd;
213	int32_t scan_enabled;
214	/* mouse state */
215	int32_t mouse_write_cmd;
216	uint8_t mouse_status;
217	uint8_t mouse_resolution;
218	uint8_t mouse_sample_rate;
219	uint8_t mouse_wrap;
220	uint8_t mouse_type; /* 0 = PS2, 3 = IMPS/2, 4 = IMEX */
221	uint8_t mouse_detect_state;
222	int32_t mouse_dx; /* current values, needed for 'poll' mode */
223	int32_t mouse_dy;
224	int32_t mouse_dz;
225	uint8_t mouse_buttons;
226
227	#ifdef VBOX
228	/** Pointer to the device instance. */
229	PPDMDEVINSGC pDevInsGC;
230	/** Pointer to the device instance. */
231	PPDMDEVINSHC pDevInsHC;
232	/**
233	* Keyboard port - LUN#0.
234	*/
235	struct
236	{
237	/** The base interface for the keyboard port. */
238	PDMIBASE Base;
239	/** The keyboard port base interface. */
240	PDMIKEYBOARDPORT Port;
241
242	/** The base interface of the attached keyboard driver. */
243	HCPTRTYPE(PPDMIBASE) pDrvBase;
244	/** The keyboard interface of the attached keyboard driver. */
245	HCPTRTYPE(PPDMIKEYBOARDCONNECTOR) pDrv;
246	} Keyboard;
247
248	/**
249	* Mouse port - LUN#1.
250	*/
251	struct
252	{
253	/** The base interface for the mouse port. */
254	PDMIBASE Base;
255	/** The mouse port base interface. */
256	PDMIMOUSEPORT Port;
257
258	/** The base interface of the attached mouse driver. */
259	HCPTRTYPE(PPDMIBASE) pDrvBase;
260	/** The mouse interface of the attached mouse driver. */
261	HCPTRTYPE(PPDMIMOUSECONNECTOR) pDrv;
262	} Mouse;
263	#endif
264	} KBDState;
265
266	#ifndef VBOX_DEVICE_STRUCT_TESTCASE
267	#ifndef VBOX
268	KBDState kbd_state;
269	#endif
270
271	/* update irq and KBD_STAT_[MOUSE_]OBF */
272	/* XXX: not generating the irqs if KBD_MODE_DISABLE_KBD is set may be
273	incorrect, but it avoids having to simulate exact delays */
274	static void kbd_update_irq(KBDState *s)
275	{
276	KBDQueue *q = &s->queue;
277	#ifdef VBOX
278	MouseCmdQueue *mcq = &s->mouse_command_queue;
279	MouseEventQueue *meq = &s->mouse_event_queue;
280	#endif /* VBOX */
281	int irq12_level, irq1_level;
282
283	irq1_level = 0;
284	irq12_level = 0;
285	s->status &= ~(KBD_STAT_OBF \| KBD_STAT_MOUSE_OBF);
286	#ifdef VBOX
287	if (q->count != 0)
288	{
289	s->status \|= KBD_STAT_OBF;
290	if ((s->mode & KBD_MODE_KBD_INT) && !(s->mode & KBD_MODE_DISABLE_KBD))
291	irq1_level = 1;
292	}
293	else if (mcq->count != 0 \|\| meq->count != 0)
294	{
295	s->status \|= KBD_STAT_OBF \| KBD_STAT_MOUSE_OBF;
296	if (s->mode & KBD_MODE_MOUSE_INT)
297	irq12_level = 1;
298	}
299	#else /* !VBOX */
300	if (q->count != 0) {
301	s->status \|= KBD_STAT_OBF;
302	if (q->aux[q->rptr]) {
303	s->status \|= KBD_STAT_MOUSE_OBF;
304	if (s->mode & KBD_MODE_MOUSE_INT)
305	irq12_level = 1;
306	} else {
307	if ((s->mode & KBD_MODE_KBD_INT) &&
308	!(s->mode & KBD_MODE_DISABLE_KBD))
309	irq1_level = 1;
310	}
311	}
312	#endif /* !VBOX */
313	#ifndef VBOX
314	pic_set_irq(1, irq1_level);
315	pic_set_irq(12, irq12_level);
316	#else /* VBOX */
317	PDMDevHlpISASetIrq(CTXSUFF(s->pDevIns), 1, irq1_level);
318	PDMDevHlpISASetIrq(CTXSUFF(s->pDevIns), 12, irq12_level);
319	#endif /* VBOX */
320	}
321
322	static void kbd_queue(KBDState *s, int b, int aux)
323	{
324	KBDQueue *q = &s->queue;
325	#ifdef VBOX
326	MouseCmdQueue *mcq = &s->mouse_command_queue;
327	MouseEventQueue *meq = &s->mouse_event_queue;
328	#endif /* VBOX */
329
330	#if defined(DEBUG_MOUSE) \|\| defined(DEBUG_KBD)
331	if (aux)
332	Log(("mouse event: 0x%02x\n", b));
333	#ifdef DEBUG_KBD
334	else
335	Log(("kbd event: 0x%02x\n", b));
336	#endif
337	#endif
338	#ifdef VBOX
339	switch (aux)
340	{
341	case 0: /* keyboard */
342	if (q->count >= KBD_QUEUE_SIZE)
343	return;
344	q->data[q->wptr] = b;
345	if (++q->wptr == KBD_QUEUE_SIZE)
346	q->wptr = 0;
347	q->count++;
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	#else /* !VBOX */
369	if (q->count >= KBD_QUEUE_SIZE)
370	return;
371	q->aux[q->wptr] = aux;
372	q->data[q->wptr] = b;
373	if (++q->wptr == KBD_QUEUE_SIZE)
374	q->wptr = 0;
375	q->count++;
376	#endif /* !VBOX */
377	kbd_update_irq(s);
378	}
379
380	#ifdef IN_RING3
381	static void pc_kbd_put_keycode(void *opaque, int keycode)
382	{
383	KBDState s = (KBDState)opaque;
384	kbd_queue(s, keycode, 0);
385	}
386	#endif /* IN_RING3 */
387
388	static uint32_t kbd_read_status(void *opaque, uint32_t addr)
389	{
390	KBDState s = (KBDState)opaque;
391	int val;
392	val = s->status;
393	#if defined(DEBUG_KBD)
394	Log(("kbd: read status=0x%02x\n", val));
395	#endif
396	return val;
397	}
398
399	#ifndef VBOX
400	static void kbd_write_command(void *opaque, uint32_t addr, uint32_t val)
401	{
402	#else /* VBOX (we need VMReset return code passed back) */
403	static int kbd_write_command(void *opaque, uint32_t addr, uint32_t val)
404	{
405	int rc = VINF_SUCCESS;
406	#endif /* VBOX */
407	KBDState s = (KBDState)opaque;
408
409	#ifdef DEBUG_KBD
410	Log(("kbd: write cmd=0x%02x\n", val));
411	#endif
412	switch(val) {
413	case KBD_CCMD_READ_MODE:
414	kbd_queue(s, s->mode, 0);
415	break;
416	case KBD_CCMD_WRITE_MODE:
417	case KBD_CCMD_WRITE_OBUF:
418	case KBD_CCMD_WRITE_AUX_OBUF:
419	case KBD_CCMD_WRITE_MOUSE:
420	case KBD_CCMD_WRITE_OUTPORT:
421	s->write_cmd = val;
422	break;
423	case KBD_CCMD_MOUSE_DISABLE:
424	s->mode \|= KBD_MODE_DISABLE_MOUSE;
425	break;
426	case KBD_CCMD_MOUSE_ENABLE:
427	s->mode &= ~KBD_MODE_DISABLE_MOUSE;
428	break;
429	case KBD_CCMD_TEST_MOUSE:
430	kbd_queue(s, 0x00, 0);
431	break;
432	case KBD_CCMD_SELF_TEST:
433	s->status \|= KBD_STAT_SELFTEST;
434	kbd_queue(s, 0x55, 0);
435	break;
436	case KBD_CCMD_KBD_TEST:
437	kbd_queue(s, 0x00, 0);
438	break;
439	case KBD_CCMD_KBD_DISABLE:
440	s->mode \|= KBD_MODE_DISABLE_KBD;
441	kbd_update_irq(s);
442	break;
443	case KBD_CCMD_KBD_ENABLE:
444	s->mode &= ~KBD_MODE_DISABLE_KBD;
445	kbd_update_irq(s);
446	break;
447	case KBD_CCMD_READ_INPORT:
448	kbd_queue(s, 0x00, 0);
449	break;
450	case KBD_CCMD_READ_OUTPORT:
451	/* XXX: check that */
452	#ifdef TARGET_I386
453	# ifndef VBOX
454	val = 0x01 \| (ioport_get_a20() << 1);
455	# else /* VBOX */
456	val = 0x01 \| (PDMDevHlpA20IsEnabled(CTXSUFF(s->pDevIns)) << 1);
457	# endif /* VBOX */
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	kbd_queue(s, val, 0);
466	break;
467	#ifdef TARGET_I386
468	case KBD_CCMD_ENABLE_A20:
469	#ifndef VBOX
470	ioport_set_a20(1);
471	#else /* VBOX */
472	# ifndef IN_RING3
473	if (!PDMDevHlpA20IsEnabled(CTXSUFF(s->pDevIns)))
474	rc = VINF_IOM_HC_IOPORT_WRITE;
475	# else /* IN_RING3 */
476	PDMDevHlpA20Set(CTXSUFF(s->pDevIns), true);
477	# endif /* IN_RING3 */
478	#endif /* VBOX */
479	break;
480	case KBD_CCMD_DISABLE_A20:
481	#ifndef VBOX
482	ioport_set_a20(0);
483	#else /* VBOX */
484	# ifndef IN_RING3
485	if (PDMDevHlpA20IsEnabled(CTXSUFF(s->pDevIns)))
486	rc = VINF_IOM_HC_IOPORT_WRITE;
487	# else /* IN_RING3 */
488	PDMDevHlpA20Set(CTXSUFF(s->pDevIns), false);
489	# endif /* !IN_RING3 */
490	#endif /* VBOX */
491	break;
492	#endif
493	case KBD_CCMD_RESET:
494	#ifndef VBOX
495	qemu_system_reset_request();
496	#else /* VBOX */
497	# ifndef IN_RING3
498	rc = VINF_IOM_HC_IOPORT_WRITE;
499	# else /* IN_RING3 */
500	rc = PDMDevHlpVMReset(CTXSUFF(s->pDevIns));
501	# endif /* !IN_RING3 */
502	#endif /* VBOX */
503	break;
504	case 0xff:
505	/* ignore that - I don't know what is its use */
506	break;
507	default:
508	Log(("kbd: unsupported keyboard cmd=0x%02x\n", val));
509	break;
510	}
511	#ifdef VBOX
512	return rc;
513	#endif
514	}
515
516	static uint32_t kbd_read_data(void *opaque, uint32_t addr)
517	{
518	KBDState s = (KBDState)opaque;
519	KBDQueue *q;
520	#ifdef VBOX
521	MouseCmdQueue *mcq;
522	MouseEventQueue *meq;
523	#endif /* VBOX */
524	int val, index, aux;
525
526	q = &s->queue;
527	#ifdef VBOX
528	mcq = &s->mouse_command_queue;
529	meq = &s->mouse_event_queue;
530	if (q->count == 0 && mcq->count == 0 && meq->count == 0) {
531	#else /* !VBOX */
532	if (q->count == 0) {
533	#endif /* !VBOX */
534	/* NOTE: if no data left, we return the last keyboard one
535	(needed for EMM386) */
536	/* XXX: need a timer to do things correctly */
537	index = q->rptr - 1;
538	if (index < 0)
539	index = KBD_QUEUE_SIZE - 1;
540	val = q->data[index];
541	} else {
542	#ifdef VBOX
543	aux = (s->status & KBD_STAT_MOUSE_OBF);
544	if (!aux)
545	{
546	val = q->data[q->rptr];
547	if (++q->rptr == KBD_QUEUE_SIZE)
548	q->rptr = 0;
549	q->count--;
550	}
551	else
552	{
553	if (mcq->count)
554	{
555	val = mcq->data[mcq->rptr];
556	if (++mcq->rptr == MOUSE_CMD_QUEUE_SIZE)
557	mcq->rptr = 0;
558	mcq->count--;
559	}
560	else
561	{
562	val = meq->data[meq->rptr];
563	if (++meq->rptr == MOUSE_EVENT_QUEUE_SIZE)
564	meq->rptr = 0;
565	meq->count--;
566	}
567	}
568	#else /* !VBOX */
569	aux = q->aux[q->rptr];
570	val = q->data[q->rptr];
571	if (++q->rptr == KBD_QUEUE_SIZE)
572	q->rptr = 0;
573	q->count--;
574	#endif /* !VBOX */
575	/* reading deasserts IRQ */
576	#ifndef VBOX
577	if (aux)
578	pic_set_irq(12, 0);
579	else
580	pic_set_irq(1, 0);
581	#else /* VBOX */
582	if (aux)
583	PDMDevHlpISASetIrq(CTXSUFF(s->pDevIns), 12, 0);
584	else
585	PDMDevHlpISASetIrq(CTXSUFF(s->pDevIns), 1, 0);
586	#endif /* VBOX */
587	}
588	/* reassert IRQs if data left */
589	kbd_update_irq(s);
590	#ifdef DEBUG_KBD
591	Log(("kbd: read data=0x%02x\n", val));
592	#endif
593	return val;
594	}
595
596	static void kbd_reset_keyboard(KBDState *s)
597	{
598	s->scan_enabled = 1;
599	}
600
601	#ifndef VBOX
602	static void kbd_write_keyboard(KBDState *s, int val)
603	#else
604	static int kbd_write_keyboard(KBDState *s, int val)
605	#endif
606	{
607	switch(s->kbd_write_cmd) {
608	default:
609	case -1:
610	switch(val) {
611	case 0x00:
612	kbd_queue(s, KBD_REPLY_ACK, 0);
613	break;
614	case 0x05:
615	kbd_queue(s, KBD_REPLY_RESEND, 0);
616	break;
617	case KBD_CMD_GET_ID:
618	kbd_queue(s, KBD_REPLY_ACK, 0);
619	kbd_queue(s, 0xab, 0);
620	kbd_queue(s, 0x83, 0);
621	break;
622	case KBD_CMD_ECHO:
623	kbd_queue(s, KBD_CMD_ECHO, 0);
624	break;
625	case KBD_CMD_ENABLE:
626	s->scan_enabled = 1;
627	kbd_queue(s, KBD_REPLY_ACK, 0);
628	break;
629	case KBD_CMD_SET_LEDS:
630	case KBD_CMD_SET_RATE:
631	s->kbd_write_cmd = val;
632	kbd_queue(s, KBD_REPLY_ACK, 0);
633	break;
634	case KBD_CMD_RESET_DISABLE:
635	kbd_reset_keyboard(s);
636	s->scan_enabled = 0;
637	kbd_queue(s, KBD_REPLY_ACK, 0);
638	break;
639	case KBD_CMD_RESET_ENABLE:
640	kbd_reset_keyboard(s);
641	s->scan_enabled = 1;
642	kbd_queue(s, KBD_REPLY_ACK, 0);
643	break;
644	case KBD_CMD_RESET:
645	kbd_reset_keyboard(s);
646	kbd_queue(s, KBD_REPLY_ACK, 0);
647	kbd_queue(s, KBD_REPLY_POR, 0);
648	break;
649	default:
650	kbd_queue(s, KBD_REPLY_ACK, 0);
651	break;
652	}
653	break;
654	case KBD_CMD_SET_LEDS:
655	{
656	#ifdef IN_RING3
657	PDMKEYBLEDS enmLeds = PDMKEYBLEDS_NONE;
658	if (val & 0x01)
659	enmLeds = (PDMKEYBLEDS)(enmLeds \| PDMKEYBLEDS_SCROLLLOCK);
660	if (val & 0x02)
661	enmLeds = (PDMKEYBLEDS)(enmLeds \| PDMKEYBLEDS_NUMLOCK);
662	if (val & 0x04)
663	enmLeds = (PDMKEYBLEDS)(enmLeds \| PDMKEYBLEDS_CAPSLOCK);
664	s->Keyboard.pDrv->pfnLedStatusChange(s->Keyboard.pDrv, enmLeds);
665	#else
666	return VINF_IOM_HC_IOPORT_WRITE;
667	#endif
668	kbd_queue(s, KBD_REPLY_ACK, 0);
669	s->kbd_write_cmd = -1;
670	}
671	break;
672	case KBD_CMD_SET_RATE:
673	kbd_queue(s, KBD_REPLY_ACK, 0);
674	s->kbd_write_cmd = -1;
675	break;
676	}
677
678	return VINF_SUCCESS;
679	}
680
681	#ifdef VBOX
682	static void kbd_mouse_send_packet(KBDState *s, bool fToCmdQueue)
683	#else /* !VBOX */
684	static void kbd_mouse_send_packet(KBDState *s)
685	#endif /* !VBOX */
686	{
687	#ifdef VBOX
688	int aux = fToCmdQueue ? 1 : 2;
689	#endif /* VBOX */
690	unsigned int b;
691	int dx1, dy1, dz1;
692
693	dx1 = s->mouse_dx;
694	dy1 = s->mouse_dy;
695	dz1 = s->mouse_dz;
696	/* XXX: increase range to 8 bits ? */
697	if (dx1 > 127)
698	dx1 = 127;
699	else if (dx1 < -127)
700	dx1 = -127;
701	if (dy1 > 127)
702	dy1 = 127;
703	else if (dy1 < -127)
704	dy1 = -127;
705	b = 0x08 \| ((dx1 < 0) << 4) \| ((dy1 < 0) << 5) \| (s->mouse_buttons & 0x07);
706	#ifdef VBOX
707	kbd_queue(s, b, aux);
708	kbd_queue(s, dx1 & 0xff, aux);
709	kbd_queue(s, dy1 & 0xff, aux);
710	#else /* !VBOX */
711	kbd_queue(s, b, 1);
712	kbd_queue(s, dx1 & 0xff, 1);
713	kbd_queue(s, dy1 & 0xff, 1);
714	#endif /* !VBOX */
715	/* extra byte for IMPS/2 or IMEX */
716	switch(s->mouse_type) {
717	default:
718	break;
719	case 3:
720	if (dz1 > 127)
721	dz1 = 127;
722	else if (dz1 < -127)
723	dz1 = -127;
724	#ifdef VBOX
725	kbd_queue(s, dz1 & 0xff, aux);
726	#else /* !VBOX */
727	kbd_queue(s, dz1 & 0xff, 1);
728	#endif /* !VBOX */
729	break;
730	case 4:
731	if (dz1 > 7)
732	dz1 = 7;
733	else if (dz1 < -7)
734	dz1 = -7;
735	b = (dz1 & 0x0f) \| ((s->mouse_buttons & 0x18) << 1);
736	#ifdef VBOX
737	kbd_queue(s, b, aux);
738	#else /* !VBOX */
739	kbd_queue(s, b, 1);
740	#endif /* !VBOX */
741	break;
742	}
743
744	/* update deltas */
745	s->mouse_dx -= dx1;
746	s->mouse_dy -= dy1;
747	s->mouse_dz -= dz1;
748	}
749
750	#ifdef IN_RING3
751	static void pc_kbd_mouse_event(void *opaque,
752	int dx, int dy, int dz, int buttons_state)
753	{
754	KBDState s = (KBDState)opaque;
755
756	/* check if deltas are recorded when disabled */
757	if (!(s->mouse_status & MOUSE_STATUS_ENABLED))
758	return;
759
760	s->mouse_dx += dx;
761	s->mouse_dy -= dy;
762	s->mouse_dz += dz;
763	/* XXX: SDL sometimes generates nul events: we delete them */
764	if (s->mouse_dx == 0 && s->mouse_dy == 0 && s->mouse_dz == 0 &&
765	s->mouse_buttons == buttons_state)
766	return;
767	s->mouse_buttons = buttons_state;
768
769	#ifdef VBOX
770	if (!(s->mouse_status & MOUSE_STATUS_REMOTE) &&
771	(s->mouse_event_queue.count < (MOUSE_EVENT_QUEUE_SIZE - 4))) {
772	for(;;) {
773	/* if not remote, send event. Multiple events are sent if
774	too big deltas */
775	kbd_mouse_send_packet(s, false);
776	if (s->mouse_dx == 0 && s->mouse_dy == 0 && s->mouse_dz == 0)
777	break;
778	}
779	}
780	#else /* !VBOX */
781	if (!(s->mouse_status & MOUSE_STATUS_REMOTE) &&
782	(s->queue.count < (KBD_QUEUE_SIZE - 16))) {
783	for(;;) {
784	/* if not remote, send event. Multiple events are sent if
785	too big deltas */
786	kbd_mouse_send_packet(s);
787	if (s->mouse_dx == 0 && s->mouse_dy == 0 && s->mouse_dz == 0)
788	break;
789	}
790	}
791	#endif /* !VBOX */
792	}
793	#endif /* IN_RING3 */
794
795	static void kbd_write_mouse(KBDState *s, int val)
796	{
797	#ifdef DEBUG_MOUSE
798	Log(("kbd: write mouse 0x%02x\n", val));
799	#endif
800	#ifdef VBOX
801	/* Flush the mouse command response queue. */
802	s->mouse_command_queue.count = 0;
803	s->mouse_command_queue.rptr = 0;
804	s->mouse_command_queue.wptr = 0;
805	#endif /* VBOX */
806	switch(s->mouse_write_cmd) {
807	default:
808	case -1:
809	/* mouse command */
810	if (s->mouse_wrap) {
811	if (val == AUX_RESET_WRAP) {
812	s->mouse_wrap = 0;
813	kbd_queue(s, AUX_ACK, 1);
814	return;
815	} else if (val != AUX_RESET) {
816	kbd_queue(s, val, 1);
817	return;
818	}
819	}
820	switch(val) {
821	case AUX_SET_SCALE11:
822	s->mouse_status &= ~MOUSE_STATUS_SCALE21;
823	kbd_queue(s, AUX_ACK, 1);
824	break;
825	case AUX_SET_SCALE21:
826	s->mouse_status \|= MOUSE_STATUS_SCALE21;
827	kbd_queue(s, AUX_ACK, 1);
828	break;
829	case AUX_SET_STREAM:
830	s->mouse_status &= ~MOUSE_STATUS_REMOTE;
831	kbd_queue(s, AUX_ACK, 1);
832	break;
833	case AUX_SET_WRAP:
834	s->mouse_wrap = 1;
835	kbd_queue(s, AUX_ACK, 1);
836	break;
837	case AUX_SET_REMOTE:
838	s->mouse_status \|= MOUSE_STATUS_REMOTE;
839	kbd_queue(s, AUX_ACK, 1);
840	break;
841	case AUX_GET_TYPE:
842	kbd_queue(s, AUX_ACK, 1);
843	kbd_queue(s, s->mouse_type, 1);
844	break;
845	case AUX_SET_RES:
846	case AUX_SET_SAMPLE:
847	s->mouse_write_cmd = val;
848	kbd_queue(s, AUX_ACK, 1);
849	break;
850	case AUX_GET_SCALE:
851	kbd_queue(s, AUX_ACK, 1);
852	kbd_queue(s, s->mouse_status, 1);
853	kbd_queue(s, s->mouse_resolution, 1);
854	kbd_queue(s, s->mouse_sample_rate, 1);
855	break;
856	case AUX_POLL:
857	kbd_queue(s, AUX_ACK, 1);
858	#ifdef VBOX
859	kbd_mouse_send_packet(s, true);
860	#else /* !VBOX */
861	kbd_mouse_send_packet(s);
862	#endif /* !VBOX */
863	break;
864	case AUX_ENABLE_DEV:
865	s->mouse_status \|= MOUSE_STATUS_ENABLED;
866	kbd_queue(s, AUX_ACK, 1);
867	break;
868	case AUX_DISABLE_DEV:
869	s->mouse_status &= ~MOUSE_STATUS_ENABLED;
870	kbd_queue(s, AUX_ACK, 1);
871	#ifdef VBOX
872	/* Flush the mouse events queue. */
873	s->mouse_event_queue.count = 0;
874	s->mouse_event_queue.rptr = 0;
875	s->mouse_event_queue.wptr = 0;
876	#endif /* VBOX */
877	break;
878	case AUX_SET_DEFAULT:
879	s->mouse_sample_rate = 100;
880	s->mouse_resolution = 2;
881	s->mouse_status = 0;
882	kbd_queue(s, AUX_ACK, 1);
883	break;
884	case AUX_RESET:
885	s->mouse_sample_rate = 100;
886	s->mouse_resolution = 2;
887	s->mouse_status = 0;
888	s->mouse_type = 0;
889	kbd_queue(s, AUX_ACK, 1);
890	kbd_queue(s, 0xaa, 1);
891	kbd_queue(s, s->mouse_type, 1);
892	#ifdef VBOX
893	/* Flush the mouse events queue. */
894	s->mouse_event_queue.count = 0;
895	s->mouse_event_queue.rptr = 0;
896	s->mouse_event_queue.wptr = 0;
897	#endif /* VBOX */
898	break;
899	default:
900	break;
901	}
902	break;
903	case AUX_SET_SAMPLE:
904	s->mouse_sample_rate = val;
905	/* detect IMPS/2 or IMEX */
906	switch(s->mouse_detect_state) {
907	default:
908	case 0:
909	if (val == 200)
910	s->mouse_detect_state = 1;
911	break;
912	case 1:
913	if (val == 100)
914	s->mouse_detect_state = 2;
915	else if (val == 200)
916	s->mouse_detect_state = 3;
917	else
918	s->mouse_detect_state = 0;
919	break;
920	case 2:
921	if (val == 80)
922	s->mouse_type = 3; /* IMPS/2 */
923	s->mouse_detect_state = 0;
924	break;
925	case 3:
926	if (val == 80)
927	s->mouse_type = 4; /* IMEX */
928	s->mouse_detect_state = 0;
929	break;
930	}
931	kbd_queue(s, AUX_ACK, 1);
932	s->mouse_write_cmd = -1;
933	break;
934	case AUX_SET_RES:
935	s->mouse_resolution = val;
936	kbd_queue(s, AUX_ACK, 1);
937	s->mouse_write_cmd = -1;
938	break;
939	}
940	}
941
942	#ifndef VBOX
943	static void kbd_write_data(void *opaque, uint32_t addr, uint32_t val)
944	{
945	#else /* VBOX */
946	static int kbd_write_data(void *opaque, uint32_t addr, uint32_t val)
947	{
948	int rc = VINF_SUCCESS;
949	#endif /* VBOX */
950	KBDState s = (KBDState)opaque;
951
952	#ifdef DEBUG_KBD
953	Log(("kbd: write data=0x%02x\n", val));
954	#endif
955
956	switch(s->write_cmd) {
957	case 0:
958	rc = kbd_write_keyboard(s, val);
959	break;
960	case KBD_CCMD_WRITE_MODE:
961	s->mode = val;
962	kbd_update_irq(s);
963	break;
964	case KBD_CCMD_WRITE_OBUF:
965	kbd_queue(s, val, 0);
966	break;
967	case KBD_CCMD_WRITE_AUX_OBUF:
968	kbd_queue(s, val, 1);
969	break;
970	case KBD_CCMD_WRITE_OUTPORT:
971	#ifdef TARGET_I386
972	# ifndef VBOX
973	ioport_set_a20((val >> 1) & 1);
974	# else /* VBOX */
975	# ifndef IN_RING3
976	if (PDMDevHlpA20IsEnabled(CTXSUFF(s->pDevIns)) != !!(val & 2))
977	rc = VINF_IOM_HC_IOPORT_WRITE;
978	# else /* IN_RING3 */
979	PDMDevHlpA20Set(CTXSUFF(s->pDevIns), !!(val & 2));
980	# endif /* !IN_RING3 */
981	# endif /* VBOX */
982	#endif
983	if (!(val & 1)) {
984	#ifndef VBOX
985	qemu_system_reset_request();
986	#else /* VBOX */
987	# ifndef IN_RING3
988	rc = VINF_IOM_HC_IOPORT_WRITE;
989	# else
990	rc = PDMDevHlpVMReset(CTXSUFF(s->pDevIns));
991	# endif
992	#endif /* VBOX */
993	}
994	break;
995	case KBD_CCMD_WRITE_MOUSE:
996	kbd_write_mouse(s, val);
997	break;
998	default:
999	break;
1000	}
1001	s->write_cmd = 0;
1002
1003	#ifdef VBOX
1004	return rc;
1005	#endif
1006	}
1007
1008	#ifdef IN_RING3
1009
1010	static void kbd_reset(void *opaque)
1011	{
1012	KBDState s = (KBDState)opaque;
1013	KBDQueue *q;
1014	#ifdef VBOX
1015	MouseCmdQueue *mcq;
1016	MouseEventQueue *meq;
1017	#endif /* VBOX */
1018
1019	s->kbd_write_cmd = -1;
1020	s->mouse_write_cmd = -1;
1021	s->mode = KBD_MODE_KBD_INT \| KBD_MODE_MOUSE_INT;
1022	s->status = KBD_STAT_CMD \| KBD_STAT_UNLOCKED;
1023	#ifdef VBOX /* Resetting everything, keyword was not working right on NT4 reboot. */
1024	s->write_cmd = 0;
1025	s->scan_enabled = 0;
1026	s->mouse_status = 0;
1027	s->mouse_resolution = 0;
1028	s->mouse_sample_rate = 0;
1029	s->mouse_wrap = 0;
1030	s->mouse_type = 0;
1031	s->mouse_detect_state = 0;
1032	s->mouse_dx = 0;
1033	s->mouse_dy = 0;
1034	s->mouse_dz = 0;
1035	s->mouse_buttons = 0;
1036	#endif
1037	q = &s->queue;
1038	q->rptr = 0;
1039	q->wptr = 0;
1040	q->count = 0;
1041	#ifdef VBOX
1042	mcq = &s->mouse_command_queue;
1043	mcq->rptr = 0;
1044	mcq->wptr = 0;
1045	mcq->count = 0;
1046	meq = &s->mouse_event_queue;
1047	meq->rptr = 0;
1048	meq->wptr = 0;
1049	meq->count = 0;
1050	#endif /* VBOX */
1051	}
1052
1053	static void kbd_save(QEMUFile* f, void* opaque)
1054	{
1055	#ifdef VBOX
1056	uint32_t cItems;
1057	int i;
1058	#endif /* VBOX */
1059	KBDState s = (KBDState)opaque;
1060
1061	qemu_put_8s(f, &s->write_cmd);
1062	qemu_put_8s(f, &s->status);
1063	qemu_put_8s(f, &s->mode);
1064	qemu_put_be32s(f, &s->kbd_write_cmd);
1065	qemu_put_be32s(f, &s->scan_enabled);
1066	qemu_put_be32s(f, &s->mouse_write_cmd);
1067	qemu_put_8s(f, &s->mouse_status);
1068	qemu_put_8s(f, &s->mouse_resolution);
1069	qemu_put_8s(f, &s->mouse_sample_rate);
1070	qemu_put_8s(f, &s->mouse_wrap);
1071	qemu_put_8s(f, &s->mouse_type);
1072	qemu_put_8s(f, &s->mouse_detect_state);
1073	qemu_put_be32s(f, &s->mouse_dx);
1074	qemu_put_be32s(f, &s->mouse_dy);
1075	qemu_put_be32s(f, &s->mouse_dz);
1076	qemu_put_8s(f, &s->mouse_buttons);
1077
1078	#ifdef VBOX
1079	/*
1080	* We have to save the queues too.
1081	*/
1082	cItems = s->queue.count;
1083	SSMR3PutU32(f, cItems);
1084	for (i = s->queue.rptr; cItems-- > 0; i = (i + 1) % ELEMENTS(s->queue.data))
1085	SSMR3PutU8(f, s->queue.data[i]);
1086	Log(("kbd_save: %d keyboard queue items stored\n", s->queue.count));
1087
1088	cItems = s->mouse_command_queue.count;
1089	SSMR3PutU32(f, cItems);
1090	for (i = s->mouse_command_queue.rptr; cItems-- > 0; i = (i + 1) % ELEMENTS(s->mouse_command_queue.data))
1091	SSMR3PutU8(f, s->mouse_command_queue.data[i]);
1092	Log(("kbd_save: %d mouse command queue items stored\n", s->mouse_command_queue.count));
1093
1094	cItems = s->mouse_event_queue.count;
1095	SSMR3PutU32(f, cItems);
1096	for (i = s->mouse_event_queue.rptr; cItems-- > 0; i = (i + 1) % ELEMENTS(s->mouse_event_queue.data))
1097	SSMR3PutU8(f, s->mouse_event_queue.data[i]);
1098	Log(("kbd_save: %d mouse event queue items stored\n", s->mouse_event_queue.count));
1099
1100	/* terminator */
1101	SSMR3PutU32(f, ~0);
1102	#endif /* VBOX */
1103	}
1104
1105	static int kbd_load(QEMUFile* f, void* opaque, int version_id)
1106	{
1107	#ifdef VBOX
1108	uint32_t u32, i;
1109	int rc;
1110	#endif
1111	KBDState s = (KBDState)opaque;
1112
1113	if (version_id != PCKBD_SAVED_STATE_VERSION)
1114	#ifndef VBOX
1115	return -EINVAL;
1116	#else
1117	return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
1118	#endif
1119	qemu_get_8s(f, &s->write_cmd);
1120	qemu_get_8s(f, &s->status);
1121	qemu_get_8s(f, &s->mode);
1122	qemu_get_be32s(f, (uint32_t *)&s->kbd_write_cmd);
1123	qemu_get_be32s(f, (uint32_t *)&s->scan_enabled);
1124	qemu_get_be32s(f, (uint32_t *)&s->mouse_write_cmd);
1125	qemu_get_8s(f, &s->mouse_status);
1126	qemu_get_8s(f, &s->mouse_resolution);
1127	qemu_get_8s(f, &s->mouse_sample_rate);
1128	qemu_get_8s(f, &s->mouse_wrap);
1129	qemu_get_8s(f, &s->mouse_type);
1130	qemu_get_8s(f, &s->mouse_detect_state);
1131	qemu_get_be32s(f, (uint32_t *)&s->mouse_dx);
1132	qemu_get_be32s(f, (uint32_t *)&s->mouse_dy);
1133	qemu_get_be32s(f, (uint32_t *)&s->mouse_dz);
1134	qemu_get_8s(f, &s->mouse_buttons);
1135	#ifdef VBOX
1136	s->queue.count = 0;
1137	s->queue.rptr = 0;
1138	s->queue.wptr = 0;
1139	s->mouse_command_queue.count = 0;
1140	s->mouse_command_queue.rptr = 0;
1141	s->mouse_command_queue.wptr = 0;
1142	s->mouse_event_queue.count = 0;
1143	s->mouse_event_queue.rptr = 0;
1144	s->mouse_event_queue.wptr = 0;
1145
1146	/*
1147	* Load the queues
1148	*/
1149	rc = SSMR3GetU32(f, &u32);
1150	if (VBOX_FAILURE(rc))
1151	return rc;
1152	if (u32 > ELEMENTS(s->queue.data))
1153	{
1154	AssertMsgFailed(("u32=%#x\n", u32));
1155	return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
1156	}
1157	for (i = 0; i < u32; i++)
1158	{
1159	rc = SSMR3GetU8(f, &s->queue.data[i]);
1160	if (VBOX_FAILURE(rc))
1161	return rc;
1162	}
1163	s->queue.wptr = u32 % ELEMENTS(s->queue.data);
1164	s->queue.count = u32;
1165	Log(("kbd_load: %d keyboard queue items loaded\n", u32));
1166
1167	rc = SSMR3GetU32(f, &u32);
1168	if (VBOX_FAILURE(rc))
1169	return rc;
1170	if (u32 > ELEMENTS(s->mouse_command_queue.data))
1171	{
1172	AssertMsgFailed(("u32=%#x\n", u32));
1173	return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
1174	}
1175	for (i = 0; i < u32; i++)
1176	{
1177	rc = SSMR3GetU8(f, &s->mouse_command_queue.data[i]);
1178	if (VBOX_FAILURE(rc))
1179	return rc;
1180	}
1181	s->mouse_command_queue.wptr = u32 % ELEMENTS(s->mouse_command_queue.data);
1182	s->mouse_command_queue.count = u32;
1183	Log(("kbd_load: %d mouse command queue items loaded\n", u32));
1184
1185	rc = SSMR3GetU32(f, &u32);
1186	if (VBOX_FAILURE(rc))
1187	return rc;
1188	if (u32 > ELEMENTS(s->mouse_event_queue.data))
1189	{
1190	AssertMsgFailed(("u32=%#x\n", u32));
1191	return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
1192	}
1193	for (i = 0; i < u32; i++)
1194	{
1195	rc = SSMR3GetU8(f, &s->mouse_event_queue.data[i]);
1196	if (VBOX_FAILURE(rc))
1197	return rc;
1198	}
1199	s->mouse_event_queue.wptr = u32 % ELEMENTS(s->mouse_event_queue.data);
1200	s->mouse_event_queue.count = u32;
1201	Log(("kbd_load: %d mouse event queue items loaded\n", u32));
1202
1203	/* terminator */
1204	rc = SSMR3GetU32(f, &u32);
1205	if (VBOX_FAILURE(rc))
1206	return rc;
1207	if (u32 != ~0U)
1208	{
1209	AssertMsgFailed(("u32=%#x\n", u32));
1210	return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
1211	}
1212	#endif /* VBOX */
1213	return 0;
1214	}
1215
1216	#ifndef VBOX
1217	void kbd_init(void)
1218	{
1219	KBDState *s = &kbd_state;
1220
1221	kbd_reset(s);
1222	register_savevm("pckbd", 0, 1, kbd_save, kbd_load, s);
1223	register_ioport_read(0x60, 1, 1, kbd_read_data, s);
1224	register_ioport_write(0x60, 1, 1, kbd_write_data, s);
1225	register_ioport_read(0x64, 1, 1, kbd_read_status, s);
1226	register_ioport_write(0x64, 1, 1, kbd_write_command, s);
1227
1228	qemu_add_kbd_event_handler(pc_kbd_put_keycode, s);
1229	qemu_add_mouse_event_handler(pc_kbd_mouse_event, s);
1230	qemu_register_reset(kbd_reset, s);
1231	}
1232	#endif /* !VBOX */
1233
1234	#endif /* IN_RING3 */
1235
1236
1237	#ifdef VBOX /* innotek code start */
1238
1239	/* -=-=-=-=-=- wrappers -=-=-=-=-=- */
1240
1241	/**
1242	* Port I/O Handler for keyboard data IN operations.
1243	*
1244	* @returns VBox status code.
1245	*
1246	* @param pDevIns The device instance.
1247	* @param pvUser User argument - ignored.
1248	* @param Port Port number used for the IN operation.
1249	* @param pu32 Where to store the result.
1250	* @param cb Number of bytes read.
1251	*/
1252	PDMBOTHCBDECL(int) kbdIOPortDataRead(PPDMDEVINS pDevIns, void pvUser, RTIOPORT Port, uint32_t pu32, unsigned cb)
1253	{
1254	NOREF(pvUser);
1255	if (cb == 1)
1256	{
1257	pu32 = kbd_read_data(PDMINS2DATA(pDevIns, KBDState ), Port);
1258	Log2(("kbdIOPortDataRead: Port=%#x cb=%d pu32=%#x\n", Port, cb, pu32));
1259	return VINF_SUCCESS;
1260	}
1261	AssertMsgFailed(("Port=%#x cb=%d\n", Port, cb));
1262	return VERR_IOM_IOPORT_UNUSED;
1263	}
1264
1265	/**
1266	* Port I/O Handler for keyboard data OUT operations.
1267	*
1268	* @returns VBox status code.
1269	*
1270	* @param pDevIns The device instance.
1271	* @param pvUser User argument - ignored.
1272	* @param Port Port number used for the IN operation.
1273	* @param u32 The value to output.
1274	* @param cb The value size in bytes.
1275	*/
1276	PDMBOTHCBDECL(int) kbdIOPortDataWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
1277	{
1278	int rc = VINF_SUCCESS;
1279	NOREF(pvUser);
1280	if (cb == 1)
1281	{
1282	rc = kbd_write_data(PDMINS2DATA(pDevIns, KBDState *), Port, u32);
1283	Log2(("kbdIOPortDataWrite: Port=%#x cb=%d u32=%#x\n", Port, cb, u32));
1284	}
1285	else
1286	AssertMsgFailed(("Port=%#x cb=%d\n", Port, cb));
1287	return rc;
1288	}
1289
1290	/**
1291	* Port I/O Handler for keyboard status IN operations.
1292	*
1293	* @returns VBox status code.
1294	*
1295	* @param pDevIns The device instance.
1296	* @param pvUser User argument - ignored.
1297	* @param Port Port number used for the IN operation.
1298	* @param pu32 Where to store the result.
1299	* @param cb Number of bytes read.
1300	*/
1301	PDMBOTHCBDECL(int) kbdIOPortStatusRead(PPDMDEVINS pDevIns, void pvUser, RTIOPORT Port, uint32_t pu32, unsigned cb)
1302	{
1303	NOREF(pvUser);
1304	if (cb == 1)
1305	{
1306	pu32 = kbd_read_status(PDMINS2DATA(pDevIns, KBDState ), Port);
1307	Log2(("kbdIOPortStatusRead: Port=%#x cb=%d -> pu32=%#x\n", Port, cb, pu32));
1308	return VINF_SUCCESS;
1309	}
1310	AssertMsgFailed(("Port=%#x cb=%d\n", Port, cb));
1311	return VERR_IOM_IOPORT_UNUSED;
1312	}
1313
1314	/**
1315	* Port I/O Handler for keyboard command OUT operations.
1316	*
1317	* @returns VBox status code.
1318	*
1319	* @param pDevIns The device instance.
1320	* @param pvUser User argument - ignored.
1321	* @param Port Port number used for the IN operation.
1322	* @param u32 The value to output.
1323	* @param cb The value size in bytes.
1324	*/
1325	PDMBOTHCBDECL(int) kbdIOPortCommandWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
1326	{
1327	NOREF(pvUser);
1328	if (cb == 1)
1329	{
1330	int rc = kbd_write_command(PDMINS2DATA(pDevIns, KBDState *), Port, u32);
1331	Log2(("kbdIOPortCommandWrite: Port=%#x cb=%d u32=%#x rc=%Vrc\n", Port, cb, u32, rc));
1332	return rc;
1333	}
1334	AssertMsgFailed(("Port=%#x cb=%d\n", Port, cb));
1335	return VINF_SUCCESS;
1336	}
1337
1338	#ifdef IN_RING3
1339
1340	/**
1341	* Saves a state of the keyboard device.
1342	*
1343	* @returns VBox status code.
1344	* @param pDevIns The device instance.
1345	* @param pSSMHandle The handle to save the state to.
1346	*/
1347	static DECLCALLBACK(int) kbdSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle)
1348	{
1349	kbd_save(pSSMHandle, PDMINS2DATA(pDevIns, KBDState *));
1350	return VINF_SUCCESS;
1351	}
1352
1353
1354	/**
1355	* Loads a saved keyboard device state.
1356	*
1357	* @returns VBox status code.
1358	* @param pDevIns The device instance.
1359	* @param pSSMHandle The handle to the saved state.
1360	* @param u32Version The data unit version number.
1361	*/
1362	static DECLCALLBACK(int) kbdLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t u32Version)
1363	{
1364	return kbd_load(pSSMHandle, PDMINS2DATA(pDevIns, KBDState *), u32Version);
1365	}
1366
1367	/**
1368	* Reset notification.
1369	*
1370	* @returns VBox status.
1371	* @param pDevIns The device instance data.
1372	*/
1373	static DECLCALLBACK(void) kbdReset(PPDMDEVINS pDevIns)
1374	{
1375	kbd_reset(PDMINS2DATA(pDevIns, KBDState *));
1376	}
1377
1378
1379	/* -=-=-=-=-=- Keyboard: IBase -=-=-=-=-=- */
1380
1381	/**
1382	* Queries an interface to the driver.
1383	*
1384	* @returns Pointer to interface.
1385	* @returns NULL if the interface was not supported by the device.
1386	* @param pInterface Pointer to the keyboard port base interface (KBDState::Keyboard.Base).
1387	* @param enmInterface The requested interface identification.
1388	*/
1389	static DECLCALLBACK(void *) kbdKeyboardQueryInterface(PPDMIBASE pInterface, PDMINTERFACE enmInterface)
1390	{
1391	KBDState pData = (KBDState )((uintptr_t)pInterface - RT_OFFSETOF(KBDState, Keyboard.Base));
1392	switch (enmInterface)
1393	{
1394	case PDMINTERFACE_BASE:
1395	return &pData->Keyboard.Base;
1396	case PDMINTERFACE_KEYBOARD_PORT:
1397	return &pData->Keyboard.Port;
1398	default:
1399	return NULL;
1400	}
1401	}
1402
1403
1404	/* -=-=-=-=-=- Keyboard: IKeyboardPort -=-=-=-=-=- */
1405
1406	/** Converts a keyboard port interface pointer to a keyboard state pointer. */
1407	#define IKEYBOARDPORT_2_KBDSTATE(pInterface) ( (KBDState *)((uintptr_t)pInterface - RT_OFFSETOF(KBDState, Keyboard.Port)) )
1408
1409	/**
1410	* Keyboard event handler.
1411	*
1412	* @returns VBox status code.
1413	* @param pInterface Pointer to the keyboard port interface (KBDState::Keyboard.Port).
1414	* @param u8KeyCode The keycode.
1415	*/
1416	static DECLCALLBACK(int) kbdKeyboardPutEvent(PPDMIKEYBOARDPORT pInterface, uint8_t u8KeyCode)
1417	{
1418	KBDState *pData = IKEYBOARDPORT_2_KBDSTATE(pInterface);
1419	pc_kbd_put_keycode(pData, u8KeyCode);
1420	return VINF_SUCCESS;
1421	}
1422
1423
1424	/* -=-=-=-=-=- Mouse: IBase -=-=-=-=-=- */
1425
1426	/**
1427	* Queries an interface to the driver.
1428	*
1429	* @returns Pointer to interface.
1430	* @returns NULL if the interface was not supported by the device.
1431	* @param pInterface Pointer to the mouse port base interface (KBDState::Mouse.Base).
1432	* @param enmInterface The requested interface identification.
1433	*/
1434	static DECLCALLBACK(void *) kbdMouseQueryInterface(PPDMIBASE pInterface, PDMINTERFACE enmInterface)
1435	{
1436	KBDState pData = (KBDState )((uintptr_t)pInterface - RT_OFFSETOF(KBDState, Mouse.Base));
1437	switch (enmInterface)
1438	{
1439	case PDMINTERFACE_BASE:
1440	return &pData->Mouse.Base;
1441	case PDMINTERFACE_MOUSE_PORT:
1442	return &pData->Mouse.Port;
1443	default:
1444	return NULL;
1445	}
1446	}
1447
1448
1449	/* -=-=-=-=-=- Mouse: IMousePort -=-=-=-=-=- */
1450
1451	/** Converts a mouse port interface pointer to a keyboard state pointer. */
1452	#define IMOUSEPORT_2_KBDSTATE(pInterface) ( (KBDState *)((uintptr_t)pInterface - RT_OFFSETOF(KBDState, Mouse.Port)) )
1453
1454	/**
1455	* Mouse event handler.
1456	*
1457	* @returns VBox status code.
1458	* @param pInterface Pointer to the mouse port interface (KBDState::Mouse.Port).
1459	* @param i32DeltaX The X delta.
1460	* @param i32DeltaY The Y delta.
1461	* @param i32DeltaZ The Z delta.
1462	* @param fButtonStates The button states.
1463	*/
1464	static DECLCALLBACK(int) kbdMousePutEvent(PPDMIMOUSEPORT pInterface, int32_t i32DeltaX, int32_t i32DeltaY, int32_t i32DeltaZ, uint32_t fButtonStates)
1465	{
1466	KBDState *pData = IMOUSEPORT_2_KBDSTATE(pInterface);
1467	pc_kbd_mouse_event(pData, i32DeltaX, i32DeltaY, i32DeltaZ, fButtonStates);
1468	return VINF_SUCCESS;
1469	}
1470
1471
1472	/* -=-=-=-=-=- real code -=-=-=-=-=- */
1473
1474
1475	/**
1476	* Attach command.
1477	*
1478	* This is called to let the device attach to a driver for a specified LUN
1479	* during runtime. This is not called during VM construction, the device
1480	* constructor have to attach to all the available drivers.
1481	*
1482	* This is like plugging in the keyboard or mouse after turning on the PC.
1483	*
1484	* @returns VBox status code.
1485	* @param pDevIns The device instance.
1486	* @param iLUN The logical unit which is being detached.
1487	* @remark The keyboard controller doesn't support this action, this is just
1488	* implemented to try out the driver<->device structure.
1489	*/
1490	static DECLCALLBACK(int) kbdAttach(PPDMDEVINS pDevIns, unsigned iLUN)
1491	{
1492	int rc;
1493	KBDState pData = PDMINS2DATA(pDevIns, KBDState );
1494	switch (iLUN)
1495	{
1496	/* LUN #0: keyboard */
1497	case 0:
1498	rc = PDMDevHlpDriverAttach(pDevIns, iLUN, &pData->Keyboard.Base, &pData->Keyboard.pDrvBase, "Keyboard Port");
1499	if (VBOX_SUCCESS(rc))
1500	{
1501	pData->Keyboard.pDrv = (PDMIKEYBOARDCONNECTOR*)(pData->Keyboard.pDrvBase->pfnQueryInterface(pData->Keyboard.pDrvBase, PDMINTERFACE_KEYBOARD_CONNECTOR));
1502	if (!pData->Keyboard.pDrv)
1503	{
1504	AssertMsgFailed(("LUN #0 doesn't have a keyboard interface! rc=%Vrc\n", rc));
1505	rc = VERR_PDM_MISSING_INTERFACE;
1506	}
1507	}
1508	else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
1509	{
1510	Log(("%s/%d: warning: no driver attached to LUN #0!\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
1511	rc = VINF_SUCCESS;
1512	}
1513	else
1514	AssertMsgFailed(("Failed to attach LUN #0! rc=%Vrc\n", rc));
1515	break;
1516
1517	/* LUN #1: aux/mouse */
1518	case 1:
1519	rc = PDMDevHlpDriverAttach(pDevIns, iLUN, &pData->Mouse.Base, &pData->Mouse.pDrvBase, "Aux (Mouse) Port");
1520	if (VBOX_SUCCESS(rc))
1521	{
1522	pData->Mouse.pDrv = (PDMIMOUSECONNECTOR*)(pData->Mouse.pDrvBase->pfnQueryInterface(pData->Mouse.pDrvBase, PDMINTERFACE_MOUSE_CONNECTOR));
1523	if (!pData->Mouse.pDrv)
1524	{
1525	AssertMsgFailed(("LUN #1 doesn't have a mouse interface! rc=%Vrc\n", rc));
1526	rc = VERR_PDM_MISSING_INTERFACE;
1527	}
1528	}
1529	else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
1530	{
1531	Log(("%s/%d: warning: no driver attached to LUN #1!\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
1532	rc = VINF_SUCCESS;
1533	}
1534	else
1535	AssertMsgFailed(("Failed to attach LUN #1! rc=%Vrc\n", rc));
1536	break;
1537
1538	default:
1539	AssertMsgFailed(("Invalid LUN #%d\n", iLUN));
1540	return VERR_PDM_NO_SUCH_LUN;
1541	}
1542
1543	return rc;
1544	}
1545
1546
1547	/**
1548	* Detach notification.
1549	*
1550	* This is called when a driver is detaching itself from a LUN of the device.
1551	* The device should adjust it's state to reflect this.
1552	*
1553	* This is like unplugging the network cable to use it for the laptop or
1554	* something while the PC is still running.
1555	*
1556	* @param pDevIns The device instance.
1557	* @param iLUN The logical unit which is being detached.
1558	* @remark The keyboard controller doesn't support this action, this is just
1559	* implemented to try out the driver<->device structure.
1560	*/
1561	static DECLCALLBACK(void) kbdDetach(PPDMDEVINS pDevIns, unsigned iLUN)
1562	{
1563	#if 0
1564	/*
1565	* Reset the interfaces and update the controller state.
1566	*/
1567	KBDState pData = PDMINS2DATA(pDevIns, KBDState );
1568	switch (iLUN)
1569	{
1570	/* LUN #0: keyboard */
1571	case 0:
1572	pData->Keyboard.pDrv = NULL;
1573	pData->Keyboard.pDrvBase = NULL;
1574	break;
1575
1576	/* LUN #1: aux/mouse */
1577	case 1:
1578	pData->Mouse.pDrv = NULL;
1579	pData->Mouse.pDrvBase = NULL;
1580	break;
1581
1582	default:
1583	AssertMsgFailed(("Invalid LUN #%d\n", iLUN));
1584	break;
1585	}
1586	#endif
1587	}
1588
1589	/**
1590	* @copydoc FNPDMDEVRELOCATE
1591	*/
1592	static DECLCALLBACK(void) kdbRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
1593	{
1594	KBDState pData = PDMINS2DATA(pDevIns, KBDState );
1595	pData->pDevInsGC = PDMDEVINS_2_GCPTR(pDevIns);
1596	}
1597
1598
1599	/**
1600	* Construct a device instance for a VM.
1601	*
1602	* @returns VBox status.
1603	* @param pDevIns The device instance data.
1604	* If the registration structure is needed, pDevIns->pDevReg points to it.
1605	* @param iInstance Instance number. Use this to figure out which registers and such to use.
1606	* The device number is also found in pDevIns->iInstance, but since it's
1607	* likely to be freqently used PDM passes it as parameter.
1608	* @param pCfgHandle Configuration node handle for the device. Use this to obtain the configuration
1609	* of the device instance. It's also found in pDevIns->pCfgHandle, but like
1610	* iInstance it's expected to be used a bit in this function.
1611	*/
1612	static DECLCALLBACK(int) kbdConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)
1613	{
1614	KBDState pData = PDMINS2DATA(pDevIns, KBDState );
1615	int rc;
1616	bool fGCEnabled;
1617	bool fR0Enabled;
1618	Assert(iInstance == 0);
1619
1620	/*
1621	* Validate and read the configuration.
1622	*/
1623	if (!CFGMR3AreValuesValid(pCfgHandle, "GCEnabled\0R0Enabled\0"))
1624	return VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES;
1625	rc = CFGMR3QueryBool(pCfgHandle, "GCEnabled", &fGCEnabled);
1626	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1627	fGCEnabled = true;
1628	else if (VBOX_FAILURE(rc))
1629	{
1630	AssertMsgFailed(("configuration error: failed to read GCEnabled as boolean. rc=%Vrc\n", rc));
1631	return rc;
1632	}
1633	rc = CFGMR3QueryBool(pCfgHandle, "R0Enabled", &fR0Enabled);
1634	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1635	fR0Enabled = true;
1636	else if (VBOX_FAILURE(rc))
1637	{
1638	AssertMsgFailed(("configuration error: failed to read R0Enabled as boolean. rc=%Vrc\n", rc));
1639	return rc;
1640	}
1641	Log(("pckbd: fGCEnabled=%d fR0Enabled=%d\n", fGCEnabled, fR0Enabled));
1642
1643
1644	/*
1645	* Initialize the interfaces.
1646	*/
1647	pData->pDevInsHC = pDevIns;
1648	pData->pDevInsGC = PDMDEVINS_2_GCPTR(pDevIns);
1649	pData->Keyboard.Base.pfnQueryInterface = kbdKeyboardQueryInterface;
1650	pData->Keyboard.Port.pfnPutEvent = kbdKeyboardPutEvent;
1651
1652	pData->Mouse.Base.pfnQueryInterface = kbdMouseQueryInterface;
1653	pData->Mouse.Port.pfnPutEvent = kbdMousePutEvent;
1654
1655	/*
1656	* Register I/O ports, save state, keyboard event handler and mouse event handlers.
1657	*/
1658	rc = PDMDevHlpIOPortRegister(pDevIns, 0x60, 1, NULL, kbdIOPortDataWrite, kbdIOPortDataRead, NULL, NULL, "PC Keyboard - Data");
1659	if (VBOX_FAILURE(rc))
1660	return rc;
1661	rc = PDMDevHlpIOPortRegister(pDevIns, 0x64, 1, NULL, kbdIOPortCommandWrite, kbdIOPortStatusRead, NULL, NULL, "PC Keyboard - Command / Status");
1662	if (VBOX_FAILURE(rc))
1663	return rc;
1664	if (fGCEnabled)
1665	{
1666	rc = PDMDevHlpIOPortRegisterGC(pDevIns, 0x60, 1, 0, "kbdIOPortDataWrite", "kbdIOPortDataRead", NULL, NULL, "PC Keyboard - Data");
1667	if (VBOX_FAILURE(rc))
1668	return rc;
1669	rc = PDMDevHlpIOPortRegisterGC(pDevIns, 0x64, 1, 0, "kbdIOPortCommandWrite", "kbdIOPortStatusRead", NULL, NULL, "PC Keyboard - Command / Status");
1670	if (VBOX_FAILURE(rc))
1671	return rc;
1672	}
1673	if (fR0Enabled)
1674	{
1675	rc = pDevIns->pDevHlp->pfnIOPortRegisterR0(pDevIns, 0x60, 1, 0, "kbdIOPortDataWrite", "kbdIOPortDataRead", NULL, NULL, "PC Keyboard - Data");
1676	if (VBOX_FAILURE(rc))
1677	return rc;
1678	rc = pDevIns->pDevHlp->pfnIOPortRegisterR0(pDevIns, 0x64, 1, 0, "kbdIOPortCommandWrite", "kbdIOPortStatusRead", NULL, NULL, "PC Keyboard - Command / Status");
1679	if (VBOX_FAILURE(rc))
1680	return rc;
1681	}
1682	rc = PDMDevHlpSSMRegister(pDevIns, g_DevicePS2KeyboardMouse.szDeviceName, iInstance, PCKBD_SAVED_STATE_VERSION, sizeof(*pData),
1683	NULL, kbdSaveExec, NULL,
1684	NULL, kbdLoadExec, NULL);
1685	if (VBOX_FAILURE(rc))
1686	return rc;
1687
1688	/*
1689	* Attach to the keyboard and mouse drivers.
1690	*/
1691	rc = kbdAttach(pDevIns, 0 /* keyboard LUN # */);
1692	if (VBOX_FAILURE(rc))
1693	return rc;
1694	rc = kbdAttach(pDevIns, 1 /* aux/mouse LUN # */);
1695	if (VBOX_FAILURE(rc))
1696	return rc;
1697
1698	/*
1699	* Initialize the device state.
1700	*/
1701	kbdReset(pDevIns);
1702
1703	return VINF_SUCCESS;
1704	}
1705
1706
1707	/**
1708	* The device registration structure.
1709	*/
1710	const PDMDEVREG g_DevicePS2KeyboardMouse =
1711	{
1712	/* u32Version */
1713	PDM_DEVREG_VERSION,
1714	/* szDeviceName */
1715	"pckbd",
1716	/* szGCMod */
1717	"VBoxDDGC.gc",
1718	/* szR0Mod */
1719	"VBoxDDR0.r0",
1720	/* pszDescription */
1721	"PS/2 Keyboard and Mouse device. Emulates both the keyboard, mouse and the keyboard controller. "
1722	"LUN #0 is the keyboard connector. "
1723	"LUN #1 is the aux/mouse connector.",
1724	/* fFlags */
1725	PDM_DEVREG_FLAGS_HOST_BITS_DEFAULT \| PDM_DEVREG_FLAGS_GUEST_BITS_32_64 \| PDM_DEVREG_FLAGS_PAE36 \| PDM_DEVREG_FLAGS_GC \| PDM_DEVREG_FLAGS_R0,
1726	/* fClass */
1727	PDM_DEVREG_CLASS_INPUT,
1728	/* cMaxInstances */
1729	1,
1730	/* cbInstance */
1731	sizeof(KBDState),
1732	/* pfnConstruct */
1733	kbdConstruct,
1734	/* pfnDestruct */
1735	NULL,
1736	/* pfnRelocate */
1737	kdbRelocate,
1738	/* pfnIOCtl */
1739	NULL,
1740	/* pfnPowerOn */
1741	NULL,
1742	/* pfnReset */
1743	kbdReset,
1744	/* pfnSuspend */
1745	NULL,
1746	/* pfnResume */
1747	NULL,
1748	/* pfnAttach */
1749	kbdAttach,
1750	/* pfnDetach */
1751	kbdDetach,
1752	/* pfnQueryInterface. */
1753	NULL
1754	};
1755
1756	#endif /* IN_RING3 */
1757	#endif /* VBOX */
1758	#endif /* !VBOX_DEVICE_STRUCT_TESTCASE */
1759

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

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

Download in other formats: