PS2K.cpp@ 68080

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

Line
1	/* $Id: PS2K.cpp 65648 2017-02-07 11:43:22Z vboxsync $ */
2	/** @file
3	* PS2K - PS/2 keyboard emulation.
4	*/
5
6	/*
7	* Copyright (C) 2007-2016 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	/*
19	* References:
20	*
21	* IBM PS/2 Technical Reference, Keyboards (101- and 102-Key), 1990
22	* Keyboard Scan Code Specification, Microsoft, 2000
23	*
24	* Notes:
25	* - The keyboard never sends partial scan-code sequences; if there isn't enough
26	* room left in the buffer for the entire sequence, the keystroke is discarded
27	* and an overrun code is sent instead.
28	* - Command responses do not disturb stored keystrokes and always have priority.
29	* - Caps Lock and Scroll Lock are normal keys from the keyboard's point of view.
30	* However, Num Lock is not and the keyboard internally tracks its state.
31	* - The way Print Screen works in scan set 1/2 is totally insane.
32	*/
33
34
35	/*********************************************************************************************************************************
36	* Header Files *
37	*********************************************************************************************************************************/
38	#define LOG_GROUP LOG_GROUP_DEV_KBD
39	#include <VBox/vmm/pdmdev.h>
40	#include <VBox/err.h>
41	#include <iprt/assert.h>
42	#include <iprt/uuid.h>
43	#include "VBoxDD.h"
44	#define IN_PS2K
45	#include "PS2Dev.h"
46
47
48	/*********************************************************************************************************************************
49	* Defined Constants And Macros *
50	*********************************************************************************************************************************/
51	/** @name Keyboard commands sent by the system.
52	* @{ */
53	#define KCMD_LEDS 0xED
54	#define KCMD_ECHO 0xEE
55	#define KCMD_INVALID_1 0xEF
56	#define KCMD_SCANSET 0xF0
57	#define KCMD_INVALID_2 0xF1
58	#define KCMD_READ_ID 0xF2
59	#define KCMD_RATE_DELAY 0xF3
60	#define KCMD_ENABLE 0xF4
61	#define KCMD_DFLT_DISABLE 0xF5
62	#define KCMD_SET_DEFAULT 0xF6
63	#define KCMD_ALL_TYPEMATIC 0xF7
64	#define KCMD_ALL_MK_BRK 0xF8
65	#define KCMD_ALL_MAKE 0xF9
66	#define KCMD_ALL_TMB 0xFA
67	#define KCMD_TYPE_MATIC 0xFB
68	#define KCMD_TYPE_MK_BRK 0xFC
69	#define KCMD_TYPE_MAKE 0xFD
70	#define KCMD_RESEND 0xFE
71	#define KCMD_RESET 0xFF
72	/** @} */
73
74	/** @name Keyboard responses sent to the system.
75	* @{ */
76	#define KRSP_ID1 0xAB
77	#define KRSP_ID2 0x83
78	#define KRSP_BAT_OK 0xAA
79	#define KRSP_BAT_FAIL 0xFC /* Also a 'release keys' signal. */
80	#define KRSP_ECHO 0xEE
81	#define KRSP_ACK 0xFA
82	#define KRSP_RESEND 0xFE
83	/** @} */
84
85	/** @name HID modifier range.
86	* @{ */
87	#define HID_MODIFIER_FIRST 0xE0
88	#define HID_MODIFIER_LAST 0xE8
89	/** @} */
90
91	/** @name USB HID additional constants
92	* @{ */
93	/** The highest USB usage code reported by VirtualBox. */
94	#define VBOX_USB_MAX_USAGE_CODE 0xE7
95	/** The size of an array needed to store all USB usage codes */
96	#define VBOX_USB_USAGE_ARRAY_SIZE (VBOX_USB_MAX_USAGE_CODE + 1)
97	/** @} */
98
99	/** @name Modifier key states. Sorted in USB HID code order.
100	* @{ */
101	#define MOD_LCTRL 0x01
102	#define MOD_LSHIFT 0x02
103	#define MOD_LALT 0x04
104	#define MOD_LGUI 0x08
105	#define MOD_RCTRL 0x10
106	#define MOD_RSHIFT 0x20
107	#define MOD_RALT 0x40
108	#define MOD_RGUI 0x80
109	/** @} */
110
111	/* Default typematic value. */
112	#define KBD_DFL_RATE_DELAY 0x2B
113
114	/** Define a simple PS/2 input device queue. */
115	#define DEF_PS2Q_TYPE(name, size) \
116	typedef struct { \
117	uint32_t rpos; \
118	uint32_t wpos; \
119	uint32_t cUsed; \
120	uint32_t cSize; \
121	uint8_t abQueue[size]; \
122	} name
123
124	/* Internal keyboard queue sizes. The input queue doesn't need to be
125	* extra huge and the command queue only needs to handle a few bytes.
126	*/
127	#define KBD_KEY_QUEUE_SIZE 64
128	#define KBD_CMD_QUEUE_SIZE 4
129
130
131	/*********************************************************************************************************************************
132	* Structures and Typedefs *
133	*********************************************************************************************************************************/
134
135	/** Scancode translator state. */
136	typedef enum {
137	SS_IDLE, /*< Starting state. /
138	SS_EXT, /*< E0 byte was received. /
139	SS_EXT1 /*< E1 byte was received. /
140	} scan_state_t;
141
142	/** Typematic state. */
143	typedef enum {
144	KBD_TMS_IDLE = 0, /* No typematic key active. */
145	KBD_TMS_DELAY = 1, /* In the initial delay period. */
146	KBD_TMS_REPEAT = 2, /* Key repeating at set rate. */
147	KBD_TMS_32BIT_HACK = 0x7fffffff
148	} tmatic_state_t;
149
150
151	DEF_PS2Q_TYPE(KbdKeyQ, KBD_KEY_QUEUE_SIZE);
152	DEF_PS2Q_TYPE(KbdCmdQ, KBD_CMD_QUEUE_SIZE);
153	DEF_PS2Q_TYPE(GeneriQ, 1);
154
155	/**
156	* The PS/2 keyboard instance data.
157	*/
158	typedef struct PS2K
159	{
160	/** Pointer to parent device (keyboard controller). */
161	R3PTRTYPE(void *) pParent;
162	/** Set if keyboard is enabled ('scans' for input). */
163	bool fScanning;
164	/** Set NumLock is on. */
165	bool fNumLockOn;
166	/** Selected scan set. */
167	uint8_t u8ScanSet;
168	/** Modifier key state. */
169	uint8_t u8Modifiers;
170	/** Currently processed command (if any). */
171	uint8_t u8CurrCmd;
172	/** Status indicator (LED) state. */
173	uint8_t u8LEDs;
174	/** Selected typematic delay/rate. */
175	uint8_t u8Typematic;
176	/** Usage code of current typematic key, if any. */
177	uint8_t u8TypematicKey;
178	/** Current typematic repeat state. */
179	tmatic_state_t enmTypematicState;
180	/** Buffer holding scan codes to be sent to the host. */
181	KbdKeyQ keyQ;
182	/** Command response queue (priority). */
183	KbdCmdQ cmdQ;
184	/** Currently depressed keys. */
185	uint8_t abDepressedKeys[VBOX_USB_USAGE_ARRAY_SIZE];
186	/** Typematic delay in milliseconds. */
187	unsigned uTypematicDelay;
188	/** Typematic repeat period in milliseconds. */
189	unsigned uTypematicRepeat;
190	#if HC_ARCH_BITS == 32
191	uint32_t Alignment0;
192	#endif
193
194	/** Command delay timer - RC Ptr. */
195	PTMTIMERRC pKbdDelayTimerRC;
196	/** Typematic timer - RC Ptr. */
197	PTMTIMERRC pKbdTypematicTimerRC;
198
199	/** The device critical section protecting everything - R3 Ptr */
200	R3PTRTYPE(PPDMCRITSECT) pCritSectR3;
201	/** Command delay timer - R3 Ptr. */
202	PTMTIMERR3 pKbdDelayTimerR3;
203	/** Typematic timer - R3 Ptr. */
204	PTMTIMERR3 pKbdTypematicTimerR3;
205	RTR3PTR Alignment2;
206
207	/** Command delay timer - R0 Ptr. */
208	PTMTIMERR0 pKbdDelayTimerR0;
209	/** Typematic timer - R0 Ptr. */
210	PTMTIMERR0 pKbdTypematicTimerR0;
211
212	scan_state_t XlatState; /// @todo temporary
213	uint32_t Alignment1;
214
215	/**
216	* Keyboard port - LUN#0.
217	*
218	* @implements PDMIBASE
219	* @implements PDMIKEYBOARDPORT
220	*/
221	struct
222	{
223	/** The base interface for the keyboard port. */
224	PDMIBASE IBase;
225	/** The keyboard port base interface. */
226	PDMIKEYBOARDPORT IPort;
227
228	/** The base interface of the attached keyboard driver. */
229	R3PTRTYPE(PPDMIBASE) pDrvBase;
230	/** The keyboard interface of the attached keyboard driver. */
231	R3PTRTYPE(PPDMIKEYBOARDCONNECTOR) pDrv;
232	} Keyboard;
233	} PS2K, *PPS2K;
234
235	AssertCompile(PS2K_STRUCT_FILLER >= sizeof(PS2K));
236
237	#ifndef VBOX_DEVICE_STRUCT_TESTCASE
238
239	/* Key type flags. */
240	#define KF_E0 0x01 /* E0 prefix. */
241	#define KF_NB 0x02 /* No break code. */
242	#define KF_GK 0x04 /* Gray navigation key. */
243	#define KF_PS 0x08 /* Print Screen key. */
244	#define KF_PB 0x10 /* Pause/Break key. */
245	#define KF_NL 0x20 /* Num Lock key. */
246	#define KF_NS 0x40 /* NumPad '/' key. */
247
248	/* Scan Set 3 typematic defaults. */
249	#define T_U 0x00 /* Unknown value. */
250	#define T_T 0x01 /* Key is typematic. */
251	#define T_M 0x02 /* Key is make only. */
252	#define T_B 0x04 /* Key is make/break. */
253
254	/* Special key values. */
255	#define NONE 0x93 /* No PS/2 scan code returned. */
256	#define UNAS 0x94 /* No PS/2 scan assigned to key. */
257	#define RSVD 0x95 /* Reserved, do not use. */
258	#define UNKN 0x96 /* Translation unknown. */
259
260	/* Key definition structure. */
261	typedef struct {
262	uint8_t makeS1; /* Set 1 make code. */
263	uint8_t makeS2; /* Set 2 make code. */
264	uint8_t makeS3; /* Set 3 make code. */
265	uint8_t keyFlags; /* Key flags. */
266	uint8_t keyMatic; /* Set 3 typematic default. */
267	} key_def;
268
269
270	/*********************************************************************************************************************************
271	* Global Variables *
272	*********************************************************************************************************************************/
273	#ifdef IN_RING3
274	/* USB to PS/2 conversion table for regular keys. */
275	static const key_def aPS2Keys[] = {
276	/* 00 / {NONE, NONE, NONE, KF_NB, T_U }, / Key N/A: No Event */
277	/* 01 / {0xFF, 0x00, 0x00, KF_NB, T_U }, / Key N/A: Overrun Error */
278	/* 02 / {0xFC, 0xFC, 0xFC, KF_NB, T_U }, / Key N/A: POST Fail */
279	/* 03 / {UNAS, UNAS, UNAS, 0, T_U }, / Key N/A: ErrorUndefined */
280	/* 04 / {0x1E, 0x1C, 0x1C, 0, T_T }, / Key 31: a A */
281	/* 05 / {0x30, 0x32, 0x32, 0, T_T }, / Key 50: b B */
282	/* 06 / {0x2E, 0x21, 0x21, 0, T_T }, / Key 48: c C */
283	/* 07 / {0x20, 0x23, 0x23, 0, T_T }, / Key 33: d D */
284	/* 08 / {0x12, 0x24, 0x24, 0, T_T }, / Key 19: e E */
285	/* 09 / {0x21, 0x2B, 0x2B, 0, T_T }, / Key 34: f F */
286	/* 0A / {0x22, 0x34, 0x34, 0, T_T }, / Key 35: g G */
287	/* 0B / {0x23, 0x33, 0x33, 0, T_T }, / Key 36: h H */
288	/* 0C / {0x17, 0x43, 0x43, 0, T_T }, / Key 24: i I */
289	/* 0D / {0x24, 0x3B, 0x3B, 0, T_T }, / Key 37: j J */
290	/* 0E / {0x25, 0x42, 0x42, 0, T_T }, / Key 38: k K */
291	/* 0F / {0x26, 0x4B, 0x4B, 0, T_T }, / Key 39: l L */
292	/* 10 / {0x32, 0x3A, 0x3A, 0, T_T }, / Key 52: m M */
293	/* 11 / {0x31, 0x31, 0x31, 0, T_T }, / Key 51: n N */
294	/* 12 / {0x18, 0x44, 0x44, 0, T_T }, / Key 25: o O */
295	/* 13 / {0x19, 0x4D, 0x4D, 0, T_T }, / Key 26: p P */
296	/* 14 / {0x10, 0x15, 0x15, 0, T_T }, / Key 17: q Q */
297	/* 15 / {0x13, 0x2D, 0x2D, 0, T_T }, / Key 20: r R */
298	/* 16 / {0x1F, 0x1B, 0x1B, 0, T_T }, / Key 32: s S */
299	/* 17 / {0x14, 0x2C, 0x2C, 0, T_T }, / Key 21: t T */
300	/* 18 / {0x16, 0x3C, 0x3C, 0, T_T }, / Key 23: u U */
301	/* 19 / {0x2F, 0x2A, 0x2A, 0, T_T }, / Key 49: v V */
302	/* 1A / {0x11, 0x1D, 0x1D, 0, T_T }, / Key 18: w W */
303	/* 1B / {0x2D, 0x22, 0x22, 0, T_T }, / Key 47: x X */
304	/* 1C / {0x15, 0x35, 0x35, 0, T_T }, / Key 22: y Y */
305	/* 1D / {0x2C, 0x1A, 0x1A, 0, T_T }, / Key 46: z Z */
306	/* 1E / {0x02, 0x16, 0x16, 0, T_T }, / Key 2: 1 ! */
307	/* 1F / {0x03, 0x1E, 0x1E, 0, T_T }, / Key 3: 2 @ */
308	/* 20 / {0x04, 0x26, 0x26, 0, T_T }, / Key 4: 3 # */
309	/* 21 / {0x05, 0x25, 0x25, 0, T_T }, / Key 5: 4 $ */
310	/* 22 / {0x06, 0x2E, 0x2E, 0, T_T }, / Key 6: 5 % */
311	/* 23 / {0x07, 0x36, 0x36, 0, T_T }, / Key 7: 6 ^ */
312	/* 24 / {0x08, 0x3D, 0x3D, 0, T_T }, / Key 8: 7 & */
313	/* 25 / {0x09, 0x3E, 0x3E, 0, T_T }, / Key 9: 8 * */
314	/* 26 / {0x0A, 0x46, 0x46, 0, T_T }, / Key 10: 9 ( */
315	/* 27 / {0x0B, 0x45, 0x45, 0, T_T }, / Key 11: 0 ) */
316	/* 28 / {0x1C, 0x5A, 0x5A, 0, T_T }, / Key 43: Return */
317	/* 29 / {0x01, 0x76, 0x08, 0, T_M }, / Key 110: Escape */
318	/* 2A / {0x0E, 0x66, 0x66, 0, T_T }, / Key 15: Backspace */
319	/* 2B / {0x0F, 0x0D, 0x0D, 0, T_T }, / Key 16: Tab */
320	/* 2C / {0x39, 0x29, 0x29, 0, T_T }, / Key 61: Space */
321	/* 2D / {0x0C, 0x4E, 0x4E, 0, T_T }, / Key 12: - _ */
322	/* 2E / {0x0D, 0x55, 0x55, 0, T_T }, / Key 13: = + */
323	/* 2F / {0x1A, 0x54, 0x54, 0, T_T }, / Key 27: [ { */
324	/* 30 / {0x1B, 0x5B, 0x5B, 0, T_T }, / Key 28: ] } */
325	/* 31 / {0x2B, 0x5D, 0x5C, 0, T_T }, / Key 29: \ \| */
326	/* 32 / {0x2B, 0x5D, 0x5D, 0, T_T }, / Key 42: Europe 1 (Note 2) */
327	/* 33 / {0x27, 0x4C, 0x4C, 0, T_T }, / Key 40: ; : */
328	/* 34 / {0x28, 0x52, 0x52, 0, T_T }, / Key 41: ' " */
329	/* 35 / {0x29, 0x0E, 0x0E, 0, T_T }, / Key 1: ` ~ */
330	/* 36 / {0x33, 0x41, 0x41, 0, T_T }, / Key 53: , < */
331	/* 37 / {0x34, 0x49, 0x49, 0, T_T }, / Key 54: . > */
332	/* 38 / {0x35, 0x4A, 0x4A, 0, T_T }, / Key 55: / ? */
333	/* 39 / {0x3A, 0x58, 0x14, 0, T_B }, / Key 30: Caps Lock */
334	/* 3A / {0x3B, 0x05, 0x07, 0, T_M }, / Key 112: F1 */
335	/* 3B / {0x3C, 0x06, 0x0F, 0, T_M }, / Key 113: F2 */
336	/* 3C / {0x3D, 0x04, 0x17, 0, T_M }, / Key 114: F3 */
337	/* 3D / {0x3E, 0x0C, 0x1F, 0, T_M }, / Key 115: F4 */
338	/* 3E / {0x3F, 0x03, 0x27, 0, T_M }, / Key 116: F5 */
339	/* 3F / {0x40, 0x0B, 0x2F, 0, T_M }, / Key 117: F6 */
340	/* 40 / {0x41, 0x83, 0x37, 0, T_M }, / Key 118: F7 */
341	/* 41 / {0x42, 0x0A, 0x3F, 0, T_M }, / Key 119: F8 */
342	/* 42 / {0x43, 0x01, 0x47, 0, T_M }, / Key 120: F9 */
343	/* 43 / {0x44, 0x09, 0x4F, 0, T_M }, / Key 121: F10 */
344	/* 44 / {0x57, 0x78, 0x56, 0, T_M }, / Key 122: F11 */
345	/* 45 / {0x58, 0x07, 0x5E, 0, T_M }, / Key 123: F12 */
346	/* 46 / {0x37, 0x7C, 0x57, KF_PS, T_M }, / Key 124: Print Screen (Note 1) */
347	/* 47 / {0x46, 0x7E, 0x5F, 0, T_M }, / Key 125: Scroll Lock */
348	/* 48 / {RSVD, RSVD, RSVD, KF_PB, T_M }, / Key 126: Break (Ctrl-Pause) */
349	/* 49 / {0x52, 0x70, 0x67, KF_GK, T_M }, / Key 75: Insert (Note 1) */
350	/* 4A / {0x47, 0x6C, 0x6E, KF_GK, T_M }, / Key 80: Home (Note 1) */
351	/* 4B / {0x49, 0x7D, 0x6F, KF_GK, T_M }, / Key 85: Page Up (Note 1) */
352	/* 4C / {0x53, 0x71, 0x64, KF_GK, T_T }, / Key 76: Delete (Note 1) */
353	/* 4D / {0x4F, 0x69, 0x65, KF_GK, T_M }, / Key 81: End (Note 1) */
354	/* 4E / {0x51, 0x7A, 0x6D, KF_GK, T_M }, / Key 86: Page Down (Note 1) */
355	/* 4F / {0x4D, 0x74, 0x6A, KF_GK, T_T }, / Key 89: Right Arrow (Note 1) */
356	/* 50 / {0x4B, 0x6B, 0x61, KF_GK, T_T }, / Key 79: Left Arrow (Note 1) */
357	/* 51 / {0x50, 0x72, 0x60, KF_GK, T_T }, / Key 84: Down Arrow (Note 1) */
358	/* 52 / {0x48, 0x75, 0x63, KF_GK, T_T }, / Key 83: Up Arrow (Note 1) */
359	/* 53 / {0x45, 0x77, 0x76, KF_NL, T_M }, / Key 90: Num Lock */
360	/* 54 / {0x35, 0x4A, 0x77, KF_NS, T_M }, / Key 95: Keypad / (Note 1) */
361	/* 55 / {0x37, 0x7C, 0x7E, 0, T_M }, / Key 100: Keypad * */
362	/* 56 / {0x4A, 0x7B, 0x84, 0, T_M }, / Key 105: Keypad - */
363	/* 57 / {0x4E, 0x79, 0x7C, 0, T_T }, / Key 106: Keypad + */
364	/* 58 / {0x1C, 0x5A, 0x79, KF_E0, T_M }, / Key 108: Keypad Enter */
365	/* 59 / {0x4F, 0x69, 0x69, 0, T_M }, / Key 93: Keypad 1 End */
366	/* 5A / {0x50, 0x72, 0x72, 0, T_M }, / Key 98: Keypad 2 Down */
367	/* 5B / {0x51, 0x7A, 0x7A, 0, T_M }, / Key 103: Keypad 3 PageDn */
368	/* 5C / {0x4B, 0x6B, 0x6B, 0, T_M }, / Key 92: Keypad 4 Left */
369	/* 5D / {0x4C, 0x73, 0x73, 0, T_M }, / Key 97: Keypad 5 */
370	/* 5E / {0x4D, 0x74, 0x74, 0, T_M }, / Key 102: Keypad 6 Right */
371	/* 5F / {0x47, 0x6C, 0x6C, 0, T_M }, / Key 91: Keypad 7 Home */
372	/* 60 / {0x48, 0x75, 0x75, 0, T_M }, / Key 96: Keypad 8 Up */
373	/* 61 / {0x49, 0x7D, 0x7D, 0, T_M }, / Key 101: Keypad 9 PageUp */
374	/* 62 / {0x52, 0x70, 0x70, 0, T_M }, / Key 99: Keypad 0 Insert */
375	/* 63 / {0x53, 0x71, 0x71, 0, T_M }, / Key 104: Keypad . Delete */
376	/* 64 / {0x56, 0x61, 0x13, 0, T_T }, / Key 45: Europe 2 (Note 2) */
377	/* 65 / {0x5D, 0x2F, UNKN, KF_E0, T_U }, / Key 129: App */
378	/* 66 / {0x5E, 0x37, UNKN, KF_E0, T_U }, / Key Unk: Keyboard Power */
379	/* 67 / {0x59, 0x0F, UNKN, 0, T_U }, / Key Unk: Keypad = */
380	/* 68 / {0x64, 0x08, UNKN, 0, T_U }, / Key Unk: F13 */
381	/* 69 / {0x65, 0x10, UNKN, 0, T_U }, / Key Unk: F14 */
382	/* 6A / {0x66, 0x18, UNKN, 0, T_U }, / Key Unk: F15 */
383	/* 6B / {0x67, 0x20, UNKN, 0, T_U }, / Key Unk: F16 */
384	/* 6C / {0x68, 0x28, UNKN, 0, T_U }, / Key Unk: F17 */
385	/* 6D / {0x69, 0x30, UNKN, 0, T_U }, / Key Unk: F18 */
386	/* 6E / {0x6A, 0x38, UNKN, 0, T_U }, / Key Unk: F19 */
387	/* 6F / {0x6B, 0x40, UNKN, 0, T_U }, / Key Unk: F20 */
388	/* 70 / {0x6C, 0x48, UNKN, 0, T_U }, / Key Unk: F21 */
389	/* 71 / {0x6D, 0x50, UNKN, 0, T_U }, / Key Unk: F22 */
390	/* 72 / {0x6E, 0x57, UNKN, 0, T_U }, / Key Unk: F23 */
391	/* 73 / {0x76, 0x5F, UNKN, 0, T_U }, / Key Unk: F24 */
392	/* 74 / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Execute */
393	/* 75 / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Help */
394	/* 76 / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Menu */
395	/* 77 / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Select */
396	/* 78 / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Stop */
397	/* 79 / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Again */
398	/* 7A / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Undo */
399	/* 7B / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Cut */
400	/* 7C / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Copy */
401	/* 7D / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Paste */
402	/* 7E / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Find */
403	/* 7F / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Mute */
404	/* 80 / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Volume Up */
405	/* 81 / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Volume Dn */
406	/* 82 / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Locking Caps Lock */
407	/* 83 / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Locking Num Lock */
408	/* 84 / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Locking Scroll Lock */
409	/* 85 / {0x7E, 0x6D, UNKN, 0, T_U }, / Key Unk: Keypad , (Brazilian Keypad .) */
410	/* 86 / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Equal Sign */
411	/* 87 / {0x73, 0x51, UNKN, 0, T_U }, / Key Unk: Keyboard Intl 1 (Ro) */
412	/* 88 / {0x70, 0x13, UNKN, 0, T_U }, / Key Unk: Keyboard Intl2 (K'kana/H'gana) */
413	/* 89 / {0x7D, 0x6A, UNKN, 0, T_U }, / Key Unk: Keyboard Intl 2 (Yen) */
414	/* 8A / {0x79, 0x64, UNKN, 0, T_U }, / Key Unk: Keyboard Intl 4 (Henkan) */
415	/* 8B / {0x7B, 0x67, UNKN, 0, T_U }, / Key Unk: Keyboard Intl 5 (Muhenkan) */
416	/* 8C / {0x5C, 0x27, UNKN, 0, T_U }, / Key Unk: Keyboard Intl 6 (PC9800 Pad ,) */
417	/* 8D / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Intl 7 */
418	/* 8E / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Intl 8 */
419	/* 8F / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Intl 9 */
420	/* 90 / {0xF2, 0xF2, UNKN, KF_NB, T_U }, / Key Unk: Keyboard Lang 1 (Hang'l/Engl) */
421	/* 91 / {0xF1, 0xF1, UNKN, KF_NB, T_U }, / Key Unk: Keyboard Lang 2 (Hanja) */
422	/* 92 / {0x78, 0x63, UNKN, 0, T_U }, / Key Unk: Keyboard Lang 3 (Katakana) */
423	/* 93 / {0x77, 0x62, UNKN, 0, T_U }, / Key Unk: Keyboard Lang 4 (Hiragana) */
424	/* 94 / {0x76, 0x5F, UNKN, 0, T_U }, / Key Unk: Keyboard Lang 5 (Zen/Han) */
425	/* 95 / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Lang 6 */
426	/* 96 / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Lang 7 */
427	/* 97 / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Lang 8 */
428	/* 98 / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Lang 9 */
429	/* 99 / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Alternate Erase */
430	/* 9A / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard SysReq/Attention (Note 3) */
431	/* 9B / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Cancel */
432	/* 9C / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Clear */
433	/* 9D / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Prior */
434	/* 9E / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Return */
435	/* 9F / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Separator */
436	/* A0 / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Out */
437	/* A1 / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Oper */
438	/* A2 / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard Clear/Again */
439	/* A3 / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard CrSel/Props */
440	/* A4 / {UNAS, UNAS, UNAS, 0, T_U }, / Key Unk: Keyboard ExSel */
441	};
442
443	/*
444	* Note 1: The behavior of these keys depends on the state of modifier keys
445	* at the time the key was pressed.
446	*
447	* Note 2: The key label depends on the national version of the keyboard.
448	*
449	* Note 3: Certain keys which have their own PS/2 scancodes do not exist on
450	* USB keyboards; the SysReq key is an example. The SysReq key scancode needs
451	* to be translated to the Print Screen HID usage code. The HID usage to PS/2
452	* scancode conversion then generates the correct sequence depending on the
453	* keyboard state.
454	*/
455
456	/* USB to PS/2 conversion table for modifier keys. */
457	static const key_def aPS2ModKeys[] = {
458	/* E0 / {0x1D, 0x14, 0x11, 0, T_B }, / Key 58: Left Control */
459	/* E1 / {0x2A, 0x12, 0x12, 0, T_B }, / Key 44: Left Shift */
460	/* E2 / {0x38, 0x11, 0x19, 0, T_B }, / Key 60: Left Alt */
461	/* E3 / {0x5B, 0x1F, UNKN, KF_E0, T_U }, / Key 127: Left GUI */
462	/* E4 / {0x1D, 0x14, 0x58, KF_E0, T_M }, / Key 64: Right Control */
463	/* E5 / {0x36, 0x59, 0x59, 0, T_B }, / Key 57: Right Shift */
464	/* E6 / {0x38, 0x11, 0x39, KF_E0, T_M }, / Key 62: Right Alt */
465	/* E7 / {0x5C, 0x27, UNKN, KF_E0, T_U }, / Key 128: Right GUI */
466	};
467
468	#endif /* IN_RING3 */
469
470
471
472	/**
473	* Clear a queue.
474	*
475	* @param pQ Pointer to the queue.
476	*/
477	static void ps2kClearQueue(GeneriQ *pQ)
478	{
479	LogFlowFunc(("Clearing queue %p\n", pQ));
480	pQ->wpos = pQ->rpos;
481	pQ->cUsed = 0;
482	}
483
484
485	/**
486	* Add a byte to a queue.
487	*
488	* @param pQ Pointer to the queue.
489	* @param val The byte to store.
490	*/
491	static void ps2kInsertQueue(GeneriQ *pQ, uint8_t val)
492	{
493	/* Check if queue is full. */
494	if (pQ->cUsed >= pQ->cSize)
495	{
496	LogRelFlowFunc(("queue %p full (%d entries)\n", pQ, pQ->cUsed));
497	return;
498	}
499	/* Insert data and update circular buffer write position. */
500	pQ->abQueue[pQ->wpos] = val;
501	if (++pQ->wpos == pQ->cSize)
502	pQ->wpos = 0; /* Roll over. */
503	++pQ->cUsed;
504	LogRelFlowFunc(("inserted 0x%02X into queue %p\n", val, pQ));
505	}
506
507	#ifdef IN_RING3
508
509	/**
510	* Save a queue state.
511	*
512	* @param pSSM SSM handle to write the state to.
513	* @param pQ Pointer to the queue.
514	*/
515	static void ps2kSaveQueue(PSSMHANDLE pSSM, GeneriQ *pQ)
516	{
517	uint32_t cItems = pQ->cUsed;
518	int i;
519
520	/* Only save the number of items. Note that the read/write
521	* positions aren't saved as they will be rebuilt on load.
522	*/
523	SSMR3PutU32(pSSM, cItems);
524
525	LogFlow(("Storing %d items from queue %p\n", cItems, pQ));
526
527	/* Save queue data - only the bytes actually used (typically zero). */
528	for (i = pQ->rpos; cItems-- > 0; i = (i + 1) % pQ->cSize)
529	SSMR3PutU8(pSSM, pQ->abQueue[i]);
530	}
531
532	/**
533	* Load a queue state.
534	*
535	* @param pSSM SSM handle to read the state from.
536	* @param pQ Pointer to the queue.
537	*
538	* @return int VBox status/error code.
539	*/
540	static int ps2kLoadQueue(PSSMHANDLE pSSM, GeneriQ *pQ)
541	{
542	/* On load, always put the read pointer at zero. */
543	int rc = SSMR3GetU32(pSSM, &pQ->cUsed);
544	AssertRCReturn(rc, rc);
545	LogFlow(("Loading %u items to queue %p\n", pQ->cUsed, pQ));
546	AssertMsgReturn(pQ->cUsed <= pQ->cSize, ("Saved size=%u, actual=%u\n", pQ->cUsed, pQ->cSize),
547	VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
548
549	/* Recalculate queue positions and load data in one go. */
550	pQ->rpos = 0;
551	pQ->wpos = pQ->cUsed;
552	rc = SSMR3GetMem(pSSM, pQ->abQueue, pQ->cUsed);
553
554	return rc;
555	}
556
557	/**
558	* Notify listener about LEDs state change.
559	*
560	* @param pThis The PS/2 keyboard instance data.
561	* @param u8State Bitfield which reflects LEDs state.
562	*/
563	static void ps2kNotifyLedsState(PPS2K pThis, uint8_t u8State)
564	{
565
566	PDMKEYBLEDS enmLeds = PDMKEYBLEDS_NONE;
567
568	if (u8State & 0x01)
569	enmLeds = (PDMKEYBLEDS)(enmLeds \| PDMKEYBLEDS_SCROLLLOCK);
570	if (u8State & 0x02)
571	enmLeds = (PDMKEYBLEDS)(enmLeds \| PDMKEYBLEDS_NUMLOCK);
572	if (u8State & 0x04)
573	enmLeds = (PDMKEYBLEDS)(enmLeds \| PDMKEYBLEDS_CAPSLOCK);
574
575	pThis->Keyboard.pDrv->pfnLedStatusChange(pThis->Keyboard.pDrv, enmLeds);
576
577	}
578	#endif /* IN_RING3 */
579
580	/**
581	* Retrieve a byte from a queue.
582	*
583	* @param pQ Pointer to the queue.
584	* @param pVal Pointer to storage for the byte.
585	*
586	* @return int VINF_TRY_AGAIN if queue is empty,
587	* VINF_SUCCESS if a byte was read.
588	*/
589	static int ps2kRemoveQueue(GeneriQ pQ, uint8_t pVal)
590	{
591	int rc = VINF_TRY_AGAIN;
592
593	Assert(pVal);
594	if (pQ->cUsed)
595	{
596	*pVal = pQ->abQueue[pQ->rpos];
597	if (++pQ->rpos == pQ->cSize)
598	pQ->rpos = 0; /* Roll over. */
599	--pQ->cUsed;
600	rc = VINF_SUCCESS;
601	LogFlowFunc(("removed 0x%02X from queue %p\n", *pVal, pQ));
602	} else
603	LogFlowFunc(("queue %p empty\n", pQ));
604	return rc;
605	}
606
607	/* Convert encoded typematic value to milliseconds. Note that the values are rated
608	* with +/- 20% accuracy, so there's no need for high precision.
609	*/
610	static void ps2kSetupTypematic(PPS2K pThis, uint8_t val)
611	{
612	int A, B;
613	unsigned period;
614
615	pThis->u8Typematic = val;
616	/* The delay is easy: (1 + value) * 250 ms */
617	pThis->uTypematicDelay = (1 + ((val >> 5) & 3)) * 250;
618	/* The rate is more complicated: (8 + A) * 2^B * 4.17 ms */
619	A = val & 7;
620	B = (val >> 3) & 3;
621	period = (8 + A) * (1 << B) * 417 / 100;
622	pThis->uTypematicRepeat = period;
623	Log(("Typematic delay %u ms, repeat period %u ms\n",
624	pThis->uTypematicDelay, pThis->uTypematicRepeat));
625	}
626
627	static void ps2kSetDefaults(PPS2K pThis)
628	{
629	LogFlowFunc(("Set keyboard defaults\n"));
630	ps2kClearQueue((GeneriQ *)&pThis->keyQ);
631	/* Set default Scan Set 3 typematic values. */
632	/* Set default typematic rate/delay. */
633	ps2kSetupTypematic(pThis, KBD_DFL_RATE_DELAY);
634	/* Clear last typematic key?? */
635	}
636
637	/**
638	* Receive and process a byte sent by the keyboard controller.
639	*
640	* @param pThis The PS/2 keyboard instance data.
641	* @param cmd The command (or data) byte.
642	*/
643	int PS2KByteToKbd(PPS2K pThis, uint8_t cmd)
644	{
645	bool fHandled = true;
646
647	LogFlowFunc(("new cmd=0x%02X, active cmd=0x%02X\n", cmd, pThis->u8CurrCmd));
648
649	if (pThis->u8CurrCmd == KCMD_RESET)
650	/* In reset mode, do not respond at all. */
651	return VINF_SUCCESS;
652
653	switch (cmd)
654	{
655	case KCMD_ECHO:
656	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ECHO);
657	pThis->u8CurrCmd = 0;
658	break;
659	case KCMD_READ_ID:
660	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
661	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ID1);
662	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ID2);
663	pThis->u8CurrCmd = 0;
664	break;
665	case KCMD_ENABLE:
666	pThis->fScanning = true;
667	ps2kClearQueue((GeneriQ *)&pThis->keyQ);
668	/* Clear last typematic key?? */
669	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
670	pThis->u8CurrCmd = 0;
671	break;
672	case KCMD_DFLT_DISABLE:
673	pThis->fScanning = false;
674	ps2kSetDefaults(pThis);
675	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
676	pThis->u8CurrCmd = 0;
677	break;
678	case KCMD_SET_DEFAULT:
679	ps2kSetDefaults(pThis);
680	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
681	pThis->u8CurrCmd = 0;
682	break;
683	case KCMD_ALL_TYPEMATIC:
684	case KCMD_ALL_MK_BRK:
685	case KCMD_ALL_MAKE:
686	case KCMD_ALL_TMB:
687	/// @todo Set the key types here.
688	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
689	pThis->u8CurrCmd = 0;
690	break;
691	case KCMD_RESEND:
692	pThis->u8CurrCmd = 0;
693	break;
694	case KCMD_RESET:
695	pThis->u8ScanSet = 2;
696	ps2kSetDefaults(pThis);
697	/// @todo reset more?
698	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
699	pThis->u8CurrCmd = cmd;
700	/* Delay BAT completion; the test may take hundreds of ms. */
701	TMTimerSetMillies(pThis->CTX_SUFF(pKbdDelayTimer), 2);
702	break;
703	/* The following commands need a parameter. */
704	case KCMD_LEDS:
705	case KCMD_SCANSET:
706	case KCMD_RATE_DELAY:
707	case KCMD_TYPE_MATIC:
708	case KCMD_TYPE_MK_BRK:
709	case KCMD_TYPE_MAKE:
710	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
711	pThis->u8CurrCmd = cmd;
712	break;
713	default:
714	/* Sending a command instead of a parameter starts the new command. */
715	switch (pThis->u8CurrCmd)
716	{
717	case KCMD_LEDS:
718	#ifndef IN_RING3
719	return VINF_IOM_R3_IOPORT_WRITE;
720	#else
721	{
722	ps2kNotifyLedsState(pThis, cmd);
723	pThis->fNumLockOn = !!(cmd & 0x02); /* Sync internal Num Lock state. */
724	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
725	pThis->u8LEDs = cmd;
726	pThis->u8CurrCmd = 0;
727	}
728	#endif
729	break;
730	case KCMD_SCANSET:
731	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
732	if (cmd == 0)
733	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, pThis->u8ScanSet);
734	else if (cmd < 4)
735	{
736	pThis->u8ScanSet = cmd;
737	LogRel(("PS2K: Selected scan set %d\n", cmd));
738	}
739	/* Other values are simply ignored. */
740	pThis->u8CurrCmd = 0;
741	break;
742	case KCMD_RATE_DELAY:
743	ps2kSetupTypematic(pThis, cmd);
744	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
745	pThis->u8CurrCmd = 0;
746	break;
747	default:
748	fHandled = false;
749	}
750	/* Fall through only to handle unrecognized commands. */
751	if (fHandled)
752	break;
753	/* fall thru */
754
755	case KCMD_INVALID_1:
756	case KCMD_INVALID_2:
757	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_RESEND);
758	pThis->u8CurrCmd = 0;
759	break;
760	}
761	LogFlowFunc(("Active cmd now 0x%02X; updating interrupts\n", pThis->u8CurrCmd));
762	// KBCUpdateInterrupts(pThis->pParent);
763	return VINF_SUCCESS;
764	}
765
766	/**
767	* Send a byte (keystroke or command response) to the keyboard controller.
768	*
769	* @returns VINF_SUCCESS or VINF_TRY_AGAIN.
770	* @param pThis The PS/2 keyboard instance data.
771	* @param pb Where to return the byte we've read.
772	* @remarks Caller must have entered the device critical section.
773	*/
774	int PS2KByteFromKbd(PPS2K pThis, uint8_t *pb)
775	{
776	int rc;
777
778	AssertPtr(pb);
779
780	/* Anything in the command queue has priority over data
781	* in the keystroke queue. Additionally, keystrokes are
782	* blocked if a command is currently in progress, even if
783	* the command queue is empty.
784	*/
785	rc = ps2kRemoveQueue((GeneriQ *)&pThis->cmdQ, pb);
786	if (rc != VINF_SUCCESS && !pThis->u8CurrCmd && pThis->fScanning)
787	rc = ps2kRemoveQueue((GeneriQ *)&pThis->keyQ, pb);
788
789	LogFlowFunc(("keyboard sends 0x%02x (%svalid data)\n", *pb, rc == VINF_SUCCESS ? "" : "not "));
790	return rc;
791	}
792
793	#ifdef IN_RING3
794
795	static int ps2kProcessKeyEvent(PPS2K pThis, uint8_t u8HidCode, bool fKeyDown)
796	{
797	unsigned int i = 0;
798	key_def const *pKeyDef;
799	uint8_t abCodes[16];
800	uint8_t u8MakeCode;
801
802	LogFlowFunc(("key %s: 0x%02x (set %d)\n", fKeyDown ? "down" : "up", u8HidCode, pThis->u8ScanSet));
803
804	/* Find the key definition in somewhat sparse storage. */
805	pKeyDef = u8HidCode >= HID_MODIFIER_FIRST ? &aPS2ModKeys[u8HidCode - HID_MODIFIER_FIRST] : &aPS2Keys[u8HidCode];
806
807	/* Some keys are not processed at all; early return. */
808	if (pKeyDef->makeS1 == NONE)
809	{
810	LogFlow(("Skipping key processing.\n"));
811	return VINF_SUCCESS;
812	}
813
814	/* Handle modifier keys (Ctrl/Alt/Shift/GUI). We need to keep track
815	* of their state in addition to sending the scan code.
816	*/
817	if (u8HidCode >= HID_MODIFIER_FIRST)
818	{
819	unsigned mod_bit = 1 << (u8HidCode - HID_MODIFIER_FIRST);
820
821	Assert((u8HidCode <= HID_MODIFIER_LAST));
822	if (fKeyDown)
823	pThis->u8Modifiers \|= mod_bit;
824	else
825	pThis->u8Modifiers &= ~mod_bit;
826	}
827
828	/* Toggle NumLock state. */
829	if ((pKeyDef->keyFlags & KF_NL) && fKeyDown)
830	pThis->fNumLockOn ^= true;
831
832	if (pThis->u8ScanSet == 1 \|\| pThis->u8ScanSet == 2)
833	{
834	/* The basic scan set 1 and 2 logic is the same, only the scan codes differ.
835	* Since scan set 2 is used almost all the time, that case is handled first.
836	*/
837	abCodes[0] = 0;
838	if (fKeyDown)
839	{
840	/* Process key down event. */
841	if (pKeyDef->keyFlags & KF_PB)
842	{
843	/* Pause/Break sends different data if either Ctrl is held. */
844	if (pThis->u8Modifiers & (MOD_LCTRL \| MOD_RCTRL))
845	strcpy((char *)abCodes, pThis->u8ScanSet == 2 ?
846	"\xE0\x7E\xE0\xF0\x7E" : "\xE0\x46\xE0\xC6");
847	else
848	strcpy((char *)abCodes, pThis->u8ScanSet == 2 ?
849	"\xE1\x14\x77\xE1\xF0\x14\xF0\x77" : "\xE1\x1D\x45\xE1\x9D\xC5");
850	}
851	else if (pKeyDef->keyFlags & KF_PS)
852	{
853	/* Print Screen depends on all of Ctrl, Shift, and Alt! */
854	if (pThis->u8Modifiers & (MOD_LALT \| MOD_RALT))
855	strcpy((char *)abCodes, pThis->u8ScanSet == 2 ?
856	"\x84" : "\x54");
857	else if (pThis->u8Modifiers & (MOD_LSHIFT \| MOD_RSHIFT))
858	strcpy((char *)abCodes, pThis->u8ScanSet == 2 ?
859	"\xE0\x7C" : "\xE0\x37");
860	else
861	strcpy((char *)abCodes, pThis->u8ScanSet == 2 ?
862	"\xE0\x12\xE0\x7C" : "\xE0\x2A\xE0\x37");
863	}
864	else if (pKeyDef->keyFlags & (KF_GK \| KF_NS))
865	{
866	/* The numeric pad keys fake Shift presses or releases
867	* depending on Num Lock and Shift key state. The '/'
868	* key behaves in a similar manner but does not depend on
869	* the Num Lock state.
870	*/
871	if (!pThis->fNumLockOn \|\| (pKeyDef->keyFlags & KF_NS))
872	{
873	if (pThis->u8Modifiers & MOD_LSHIFT)
874	strcat((char *)abCodes, pThis->u8ScanSet == 2 ?
875	"\xE0\xF0\x12" : "\xE0\xAA");
876	if (pThis->u8Modifiers & MOD_RSHIFT)
877	strcat((char *)abCodes, pThis->u8ScanSet == 2 ?
878	"\xE0\xF0\x59" : "\xE0\xB6");
879	}
880	else
881	{
882	Assert(pThis->fNumLockOn); /* Not for KF_NS! */
883	if ((pThis->u8Modifiers & (MOD_LSHIFT \| MOD_RSHIFT)) == 0)
884	strcpy((char *)abCodes, pThis->u8ScanSet == 2 ?
885	"\xE0\x12" : "\xE0\x2A");
886	/* Else Shift cancels NumLock, so no prefix! */
887	}
888	}
889	/* Feed the bytes to the queue if there is room. */
890	/// @todo check empty space!
891	while (abCodes[i])
892	ps2kInsertQueue((GeneriQ *)&pThis->keyQ, abCodes[i++]);
893	Assert(i < sizeof(abCodes));
894
895	/* Standard processing for regular keys only. */
896	u8MakeCode = pThis->u8ScanSet == 2 ? pKeyDef->makeS2 : pKeyDef->makeS1;
897	if (!(pKeyDef->keyFlags & (KF_PB \| KF_PS)))
898	{
899	if (pKeyDef->keyFlags & (KF_E0 \| KF_GK \| KF_NS))
900	ps2kInsertQueue((GeneriQ *)&pThis->keyQ, 0xE0);
901	ps2kInsertQueue((GeneriQ *)&pThis->keyQ, u8MakeCode);
902	}
903	}
904	else if (!(pKeyDef->keyFlags & (KF_NB \| KF_PB)))
905	{
906	/* Process key up event except for keys which produce none. */
907
908	/* Handle Print Screen release. */
909	if (pKeyDef->keyFlags & KF_PS)
910	{
911	/* Undo faked Print Screen state as needed. */
912	if (pThis->u8Modifiers & (MOD_LALT \| MOD_RALT))
913	strcpy((char *)abCodes, pThis->u8ScanSet == 2 ?
914	"\xF0\x84" : "\xD4");
915	else if (pThis->u8Modifiers & (MOD_LSHIFT \| MOD_RSHIFT))
916	strcpy((char *)abCodes, pThis->u8ScanSet == 2 ?
917	"\xE0\xF0\x7C" : "\xE0\xB7");
918	else
919	strcpy((char *)abCodes, pThis->u8ScanSet == 2 ?
920	"\xE0\xF0\x7C\xE0\xF0\x12" : "\xE0\xB7\xE0\xAA");
921	}
922	else
923	{
924	/* Process base scan code for less unusual keys. */
925	if (pKeyDef->keyFlags & (KF_E0 \| KF_GK \| KF_NS))
926	ps2kInsertQueue((GeneriQ *)&pThis->keyQ, 0xE0);
927	if (pThis->u8ScanSet == 2) {
928	ps2kInsertQueue((GeneriQ *)&pThis->keyQ, 0xF0);
929	ps2kInsertQueue((GeneriQ *)&pThis->keyQ, pKeyDef->makeS2);
930	} else {
931	Assert(pThis->u8ScanSet == 1);
932	ps2kInsertQueue((GeneriQ *)&pThis->keyQ, pKeyDef->makeS1 \| 0x80);
933	}
934
935	/* Restore shift state for gray keys. */
936	if (pKeyDef->keyFlags & (KF_GK \| KF_NS))
937	{
938	if (!pThis->fNumLockOn \|\| (pKeyDef->keyFlags & KF_NS))
939	{
940	if (pThis->u8Modifiers & MOD_LSHIFT)
941	strcat((char *)abCodes, pThis->u8ScanSet == 2 ?
942	"\xE0\x12" : "\xE0\x2A");
943	if (pThis->u8Modifiers & MOD_RSHIFT)
944	strcat((char *)abCodes, pThis->u8ScanSet == 2 ?
945	"\xE0\x59" : "\xE0\x36");
946	}
947	else
948	{
949	Assert(pThis->fNumLockOn); /* Not for KF_NS! */
950	if ((pThis->u8Modifiers & (MOD_LSHIFT \| MOD_RSHIFT)) == 0)
951	strcpy((char *)abCodes, pThis->u8ScanSet == 2 ?
952	"\xE0\xF0\x12" : "\xE0\xAA");
953	}
954	}
955	}
956
957	/* Feed any additional bytes to the queue if there is room. */
958	/// @todo check empty space!
959	while (abCodes[i])
960	ps2kInsertQueue((GeneriQ *)&pThis->keyQ, abCodes[i++]);
961	Assert(i < sizeof(abCodes));
962	}
963	}
964	else
965	{
966	/* Handle Scan Set 3 - very straightforward. */
967	Assert(pThis->u8ScanSet == 3);
968	if (fKeyDown)
969	{
970	ps2kInsertQueue((GeneriQ *)&pThis->keyQ, pKeyDef->makeS3);
971	}
972	else
973	{
974	/* Send a key release code unless it's a make only key. */
975	/// @todo Look up the current typematic setting, not the default!
976	if (pKeyDef->keyMatic != T_M)
977	{
978	ps2kInsertQueue((GeneriQ *)&pThis->keyQ, 0xF0);
979	ps2kInsertQueue((GeneriQ *)&pThis->keyQ, pKeyDef->makeS3);
980	}
981	}
982	}
983
984	/* Set up or cancel typematic key repeat. */
985	if (fKeyDown)
986	{
987	if (pThis->u8TypematicKey != u8HidCode)
988	{
989	pThis->enmTypematicState = KBD_TMS_DELAY;
990	pThis->u8TypematicKey = u8HidCode;
991	TMTimerSetMillies(pThis->CTX_SUFF(pKbdTypematicTimer), pThis->uTypematicDelay);
992	Log(("Typematic delay %u ms, key %02X\n", pThis->uTypematicDelay, u8HidCode));
993	}
994	}
995	else
996	{
997	pThis->u8TypematicKey = 0;
998	pThis->enmTypematicState = KBD_TMS_IDLE;
999	/// @todo Cancel timer right away?
1000	/// @todo Cancel timer before pushing key up code!?
1001	}
1002
1003	/* Poke the KBC to update its state. */
1004	KBCUpdateInterrupts(pThis->pParent);
1005
1006	return VINF_SUCCESS;
1007	}
1008
1009	/* Timer handler for emulating typematic keys. Note that only the last key
1010	* held down repeats (if typematic).
1011	*/
1012	static DECLCALLBACK(void) ps2kTypematicTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
1013	{
1014	RT_NOREF2(pDevIns, pTimer);
1015	PPS2K pThis = (PS2K *)pvUser;
1016	LogFlowFunc(("Typematic state=%d, key %02X\n", pThis->enmTypematicState, pThis->u8TypematicKey));
1017
1018	/* If the current typematic key is zero, the repeat was canceled just when
1019	* the timer was about to run. In that case, do nothing.
1020	*/
1021	if (pThis->u8TypematicKey)
1022	{
1023	if (pThis->enmTypematicState == KBD_TMS_DELAY)
1024	pThis->enmTypematicState = KBD_TMS_REPEAT;
1025
1026	if (pThis->enmTypematicState == KBD_TMS_REPEAT)
1027	{
1028	ps2kProcessKeyEvent(pThis, pThis->u8TypematicKey, true /* Key down */ );
1029	TMTimerSetMillies(pThis->CTX_SUFF(pKbdTypematicTimer), pThis->uTypematicRepeat);
1030	}
1031	}
1032	}
1033
1034	/* The keyboard BAT is specified to take several hundred milliseconds. We need
1035	* to delay sending the result to the host for at least a tiny little while.
1036	*/
1037	static DECLCALLBACK(void) ps2kDelayTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
1038	{
1039	RT_NOREF2(pDevIns, pTimer);
1040	PPS2K pThis = (PS2K *)pvUser;
1041
1042	LogFlowFunc(("Delay timer: cmd %02X\n", pThis->u8CurrCmd));
1043
1044	AssertMsg(pThis->u8CurrCmd == KCMD_RESET, ("u8CurrCmd=%02x\n", pThis->u8CurrCmd));
1045	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_BAT_OK);
1046	pThis->fScanning = true; /* BAT completion enables scanning! */
1047	pThis->u8CurrCmd = 0;
1048
1049	/// @todo Might want a PS2KCompleteCommand() to push last response, clear command, and kick the KBC...
1050	/* Give the KBC a kick. */
1051	KBCUpdateInterrupts(pThis->pParent);
1052	}
1053
1054	/* Release any and all currently depressed keys. Used whenever the guest keyboard
1055	* is likely to be out of sync with the host, such as when loading a saved state
1056	* or resuming a suspended host.
1057	*/
1058	static void ps2kReleaseKeys(PPS2K pThis)
1059	{
1060	LogFlowFunc(("Releasing keys...\n"));
1061
1062	for (unsigned uKey = 0; uKey < sizeof(pThis->abDepressedKeys); ++uKey)
1063	if (pThis->abDepressedKeys[uKey])
1064	{
1065	ps2kProcessKeyEvent(pThis, uKey, false /* key up */);
1066	pThis->abDepressedKeys[uKey] = 0;
1067	}
1068	LogFlowFunc(("Done releasing keys\n"));
1069	}
1070
1071
1072	/**
1073	* Debug device info handler. Prints basic keyboard state.
1074	*
1075	* @param pDevIns Device instance which registered the info.
1076	* @param pHlp Callback functions for doing output.
1077	* @param pszArgs Argument string. Optional and specific to the handler.
1078	*/
1079	static DECLCALLBACK(void) ps2kInfoState(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
1080	{
1081	PPS2K pThis = KBDGetPS2KFromDevIns(pDevIns);
1082	NOREF(pszArgs);
1083
1084	pHlp->pfnPrintf(pHlp, "PS/2 Keyboard: scan set %d, scanning %s\n",
1085	pThis->u8ScanSet, pThis->fScanning ? "enabled" : "disabled");
1086	pHlp->pfnPrintf(pHlp, "Active command %02X\n", pThis->u8CurrCmd);
1087	pHlp->pfnPrintf(pHlp, "LED state %02X, Num Lock %s\n", pThis->u8LEDs,
1088	pThis->fNumLockOn ? "on" : "off");
1089	pHlp->pfnPrintf(pHlp, "Typematic delay %ums, repeat period %ums\n",
1090	pThis->uTypematicDelay, pThis->uTypematicRepeat);
1091	pHlp->pfnPrintf(pHlp, "Command queue: %d items (%d max)\n",
1092	pThis->cmdQ.cUsed, pThis->cmdQ.cSize);
1093	pHlp->pfnPrintf(pHlp, "Input queue : %d items (%d max)\n",
1094	pThis->keyQ.cUsed, pThis->keyQ.cSize);
1095	if (pThis->enmTypematicState != KBD_TMS_IDLE)
1096	pHlp->pfnPrintf(pHlp, "Active typematic key %02X (%s)\n", pThis->u8Typematic,
1097	pThis->enmTypematicState == KBD_TMS_DELAY ? "delay" : "repeat");
1098	}
1099
1100	/* -=-=-=-=-=- Keyboard: IBase -=-=-=-=-=- */
1101
1102	/**
1103	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
1104	*/
1105	static DECLCALLBACK(void ) ps2kQueryInterface(PPDMIBASE pInterface, const char pszIID)
1106	{
1107	PPS2K pThis = RT_FROM_MEMBER(pInterface, PS2K, Keyboard.IBase);
1108	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->Keyboard.IBase);
1109	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIKEYBOARDPORT, &pThis->Keyboard.IPort);
1110	return NULL;
1111	}
1112
1113
1114	/* -=-=-=-=-=- Keyboard: IKeyboardPort -=-=-=-=-=- */
1115
1116	/**
1117	* Keyboard event handler.
1118	*
1119	* @returns VBox status code.
1120	* @param pThis The PS2 keyboard instance data.
1121	* @param u32Usage USB HID usage code with key
1122	* press/release flag.
1123	*/
1124	static int ps2kPutEventWorker(PPS2K pThis, uint32_t u32Usage)
1125	{
1126	uint8_t u8HidCode;
1127	bool fKeyDown;
1128	bool fHaveEvent = true;
1129	int rc = VINF_SUCCESS;
1130
1131	/* Extract the usage code and ensure it's valid. */
1132	fKeyDown = !(u32Usage & 0x80000000);
1133	u8HidCode = u32Usage & 0xFF;
1134	AssertReturn(u8HidCode <= VBOX_USB_MAX_USAGE_CODE, VERR_INTERNAL_ERROR);
1135
1136	if (fKeyDown)
1137	{
1138	/* Due to host key repeat, we can get key events for keys which are
1139	* already depressed. We need to ignore those. */
1140	if (pThis->abDepressedKeys[u8HidCode])
1141	fHaveEvent = false;
1142	pThis->abDepressedKeys[u8HidCode] = 1;
1143	}
1144	else
1145	{
1146	/* NB: We allow key release events for keys which aren't depressed.
1147	* That is unlikely to happen and should not cause trouble.
1148	*/
1149	pThis->abDepressedKeys[u8HidCode] = 0;
1150	}
1151
1152	/* Unless this is a new key press/release, don't even bother. */
1153	if (fHaveEvent)
1154	{
1155	rc = PDMCritSectEnter(pThis->pCritSectR3, VERR_SEM_BUSY);
1156	AssertReleaseRC(rc);
1157
1158	rc = ps2kProcessKeyEvent(pThis, u8HidCode, fKeyDown);
1159
1160	PDMCritSectLeave(pThis->pCritSectR3);
1161	}
1162
1163	return rc;
1164	}
1165
1166	static DECLCALLBACK(int) ps2kPutEventWrapper(PPDMIKEYBOARDPORT pInterface, uint32_t u32UsageCode)
1167	{
1168	PPS2K pThis = RT_FROM_MEMBER(pInterface, PS2K, Keyboard.IPort);
1169	int rc;
1170
1171	LogRelFlowFunc(("key code %08X\n", u32UsageCode));
1172
1173	rc = PDMCritSectEnter(pThis->pCritSectR3, VERR_SEM_BUSY);
1174	AssertReleaseRC(rc);
1175
1176	/* The 'BAT fail' scancode is reused as a signal to release keys. No actual
1177	* key is allowed to use this scancode.
1178	*/
1179	if (RT_UNLIKELY(u32UsageCode == KRSP_BAT_FAIL))
1180	{
1181	ps2kReleaseKeys(pThis);
1182	}
1183	else
1184	{
1185	ps2kPutEventWorker(pThis, u32UsageCode);
1186	}
1187
1188	PDMCritSectLeave(pThis->pCritSectR3);
1189
1190	return VINF_SUCCESS;
1191	}
1192
1193
1194	/**
1195	* Attach command.
1196	*
1197	* This is called to let the device attach to a driver for a
1198	* specified LUN.
1199	*
1200	* This is like plugging in the keyboard after turning on the
1201	* system.
1202	*
1203	* @returns VBox status code.
1204	* @param pThis The PS/2 keyboard instance data.
1205	* @param pDevIns The device instance.
1206	* @param iLUN The logical unit which is being detached.
1207	* @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
1208	*/
1209	int PS2KAttach(PPS2K pThis, PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
1210	{
1211	int rc;
1212
1213	/* The LUN must be 0, i.e. keyboard. */
1214	Assert(iLUN == 0);
1215	AssertMsgReturn(fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG,
1216	("PS/2 keyboard does not support hotplugging\n"),
1217	VERR_INVALID_PARAMETER);
1218
1219	LogFlowFunc(("iLUN=%d\n", iLUN));
1220
1221	rc = PDMDevHlpDriverAttach(pDevIns, iLUN, &pThis->Keyboard.IBase, &pThis->Keyboard.pDrvBase, "Keyboard Port");
1222	if (RT_SUCCESS(rc))
1223	{
1224	pThis->Keyboard.pDrv = PDMIBASE_QUERY_INTERFACE(pThis->Keyboard.pDrvBase, PDMIKEYBOARDCONNECTOR);
1225	if (!pThis->Keyboard.pDrv)
1226	{
1227	AssertLogRelMsgFailed(("LUN #0 doesn't have a keyboard interface! rc=%Rrc\n", rc));
1228	rc = VERR_PDM_MISSING_INTERFACE;
1229	}
1230	}
1231	else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
1232	{
1233	Log(("%s/%d: warning: no driver attached to LUN #0!\n", pDevIns->pReg->szName, pDevIns->iInstance));
1234	rc = VINF_SUCCESS;
1235	}
1236	else
1237	AssertLogRelMsgFailed(("Failed to attach LUN #0! rc=%Rrc\n", rc));
1238
1239	return rc;
1240	}
1241
1242	void PS2KSaveState(PPS2K pThis, PSSMHANDLE pSSM)
1243	{
1244	uint32_t cPressed = 0;
1245	uint32_t cbTMSSize = 0;
1246
1247	LogFlowFunc(("Saving PS2K state\n"));
1248
1249	/* Save the basic keyboard state. */
1250	SSMR3PutU8(pSSM, pThis->u8CurrCmd);
1251	SSMR3PutU8(pSSM, pThis->u8LEDs);
1252	SSMR3PutU8(pSSM, pThis->u8Typematic);
1253	SSMR3PutU8(pSSM, pThis->u8TypematicKey);
1254	SSMR3PutU8(pSSM, pThis->u8Modifiers);
1255	SSMR3PutU8(pSSM, pThis->u8ScanSet);
1256	SSMR3PutU8(pSSM, pThis->enmTypematicState);
1257	SSMR3PutBool(pSSM, pThis->fNumLockOn);
1258	SSMR3PutBool(pSSM, pThis->fScanning);
1259
1260	/* Save the command and keystroke queues. */
1261	ps2kSaveQueue(pSSM, (GeneriQ *)&pThis->cmdQ);
1262	ps2kSaveQueue(pSSM, (GeneriQ *)&pThis->keyQ);
1263
1264	/* Save the command delay timer. Note that the typematic repeat
1265	* timer is not saved.
1266	*/
1267	TMR3TimerSave(pThis->CTX_SUFF(pKbdDelayTimer), pSSM);
1268
1269	/* Save any pressed keys. This is necessary to avoid "stuck"
1270	* keys after a restore. Needs two passes.
1271	*/
1272	for (unsigned i = 0; i < sizeof(pThis->abDepressedKeys); ++i)
1273	if (pThis->abDepressedKeys[i])
1274	++cPressed;
1275
1276	SSMR3PutU32(pSSM, cPressed);
1277
1278	for (unsigned uKey = 0; uKey < sizeof(pThis->abDepressedKeys); ++uKey)
1279	if (pThis->abDepressedKeys[uKey])
1280	SSMR3PutU8(pSSM, uKey);
1281
1282	/* Save the typematic settings for Scan Set 3. */
1283	SSMR3PutU32(pSSM, cbTMSSize);
1284	/* Currently not implemented. */
1285	}
1286
1287	int PS2KLoadState(PPS2K pThis, PSSMHANDLE pSSM, uint32_t uVersion)
1288	{
1289	uint8_t u8;
1290	uint32_t cPressed;
1291	uint32_t cbTMSSize;
1292	int rc;
1293
1294	NOREF(uVersion);
1295	LogFlowFunc(("Loading PS2K state version %u\n", uVersion));
1296
1297	/* Load the basic keyboard state. */
1298	SSMR3GetU8(pSSM, &pThis->u8CurrCmd);
1299	SSMR3GetU8(pSSM, &pThis->u8LEDs);
1300	SSMR3GetU8(pSSM, &pThis->u8Typematic);
1301	SSMR3GetU8(pSSM, &pThis->u8TypematicKey);
1302	SSMR3GetU8(pSSM, &pThis->u8Modifiers);
1303	SSMR3GetU8(pSSM, &pThis->u8ScanSet);
1304	SSMR3GetU8(pSSM, &u8);
1305	pThis->enmTypematicState = (tmatic_state_t)u8;
1306	SSMR3GetBool(pSSM, &pThis->fNumLockOn);
1307	SSMR3GetBool(pSSM, &pThis->fScanning);
1308
1309	/* Load the command and keystroke queues. */
1310	rc = ps2kLoadQueue(pSSM, (GeneriQ *)&pThis->cmdQ);
1311	AssertRCReturn(rc, rc);
1312	rc = ps2kLoadQueue(pSSM, (GeneriQ *)&pThis->keyQ);
1313	AssertRCReturn(rc, rc);
1314
1315	/* Load the command delay timer, just in case. */
1316	rc = TMR3TimerLoad(pThis->CTX_SUFF(pKbdDelayTimer), pSSM);
1317	AssertRCReturn(rc, rc);
1318
1319	/* Recalculate the typematic delay/rate. */
1320	ps2kSetupTypematic(pThis, pThis->u8Typematic);
1321
1322	/* Fake key up events for keys that were held down at the time the state was saved. */
1323	rc = SSMR3GetU32(pSSM, &cPressed);
1324	AssertRCReturn(rc, rc);
1325
1326	/* If any keys were down, load and then release them. */
1327	if (cPressed)
1328	{
1329	for (unsigned i = 0; i < cPressed; ++i)
1330	{
1331	rc = SSMR3GetU8(pSSM, &u8);
1332	AssertRCReturn(rc, rc);
1333	pThis->abDepressedKeys[u8] = 1;
1334	}
1335	}
1336
1337	/* Load typematic settings for Scan Set 3. */
1338	rc = SSMR3GetU32(pSSM, &cbTMSSize);
1339	AssertRCReturn(rc, rc);
1340
1341	while (cbTMSSize--)
1342	{
1343	rc = SSMR3GetU8(pSSM, &u8);
1344	AssertRCReturn(rc, rc);
1345	}
1346
1347	return rc;
1348	}
1349
1350	int PS2KLoadDone(PPS2K pThis, PSSMHANDLE pSSM)
1351	{
1352	RT_NOREF1(pSSM);
1353
1354	/* This must be done after the inital load because it may trigger
1355	* interrupts and change the interrupt controller state.
1356	*/
1357	ps2kReleaseKeys(pThis);
1358	ps2kNotifyLedsState(pThis, pThis->u8LEDs);
1359	return VINF_SUCCESS;
1360	}
1361
1362	void PS2KReset(PPS2K pThis)
1363	{
1364	LogFlowFunc(("Resetting PS2K\n"));
1365
1366	pThis->fScanning = true;
1367	pThis->u8ScanSet = 2;
1368	pThis->u8CurrCmd = 0;
1369	pThis->u8Modifiers = 0;
1370	pThis->u8TypematicKey = 0;
1371	pThis->enmTypematicState = KBD_TMS_IDLE;
1372
1373	/* Clear queues and any pressed keys. */
1374	memset(pThis->abDepressedKeys, 0, sizeof(pThis->abDepressedKeys));
1375	ps2kClearQueue((GeneriQ *)&pThis->cmdQ);
1376	ps2kSetDefaults(pThis); /* Also clears keystroke queue. */
1377
1378	/* Activate the PS/2 keyboard by default. */
1379	if (pThis->Keyboard.pDrv)
1380	pThis->Keyboard.pDrv->pfnSetActive(pThis->Keyboard.pDrv, true);
1381	}
1382
1383	void PS2KRelocate(PPS2K pThis, RTGCINTPTR offDelta, PPDMDEVINS pDevIns)
1384	{
1385	RT_NOREF1(pDevIns);
1386	LogFlowFunc(("Relocating PS2K\n"));
1387	pThis->pKbdDelayTimerRC = TMTimerRCPtr(pThis->pKbdDelayTimerR3);
1388	pThis->pKbdTypematicTimerRC = TMTimerRCPtr(pThis->pKbdTypematicTimerR3);
1389	NOREF(offDelta);
1390	}
1391
1392	int PS2KConstruct(PPS2K pThis, PPDMDEVINS pDevIns, void *pParent, int iInstance)
1393	{
1394	RT_NOREF2(pDevIns, iInstance);
1395	LogFlowFunc(("iInstance=%d\n", iInstance));
1396
1397	pThis->pParent = pParent;
1398
1399	/* Initialize the queues. */
1400	pThis->keyQ.cSize = KBD_KEY_QUEUE_SIZE;
1401	pThis->cmdQ.cSize = KBD_CMD_QUEUE_SIZE;
1402
1403	pThis->Keyboard.IBase.pfnQueryInterface = ps2kQueryInterface;
1404	pThis->Keyboard.IPort.pfnPutEventHid = ps2kPutEventWrapper;
1405
1406	/*
1407	* Initialize the critical section pointer(s).
1408	*/
1409	pThis->pCritSectR3 = pDevIns->pCritSectRoR3;
1410
1411	/*
1412	* Create the typematic delay/repeat timer. Does not use virtual time!
1413	*/
1414	PTMTIMER pTimer;
1415	int rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_REAL, ps2kTypematicTimer, pThis,
1416	TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "PS2K Typematic Timer", &pTimer);
1417	if (RT_FAILURE(rc))
1418	return rc;
1419
1420	pThis->pKbdTypematicTimerR3 = pTimer;
1421	pThis->pKbdTypematicTimerR0 = TMTimerR0Ptr(pTimer);
1422	pThis->pKbdTypematicTimerRC = TMTimerRCPtr(pTimer);
1423
1424	/*
1425	* Create the command delay timer.
1426	*/
1427	rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, ps2kDelayTimer, pThis,
1428	TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "PS2K Delay Timer", &pTimer);
1429	if (RT_FAILURE(rc))
1430	return rc;
1431
1432	pThis->pKbdDelayTimerR3 = pTimer;
1433	pThis->pKbdDelayTimerR0 = TMTimerR0Ptr(pTimer);
1434	pThis->pKbdDelayTimerRC = TMTimerRCPtr(pTimer);
1435
1436	/*
1437	* Register debugger info callbacks.
1438	*/
1439	PDMDevHlpDBGFInfoRegister(pDevIns, "ps2k", "Display PS/2 keyboard state.", ps2kInfoState);
1440
1441	return rc;
1442	}
1443
1444	#endif
1445
1446	/// @todo The following should live with the KBC implementation.
1447
1448	/* Table used by the keyboard controller to optionally translate the incoming
1449	* keyboard data. Note that the translation is designed for essentially taking
1450	* Scan Set 2 input and producing Scan Set 1 output, but can be turned on and
1451	* off regardless of what the keyboard is sending.
1452	*/
1453	static uint8_t aAT2PC[128] = {
1454	0xff,0x43,0x41,0x3f,0x3d,0x3b,0x3c,0x58,0x64,0x44,0x42,0x40,0x3e,0x0f,0x29,0x59,
1455	0x65,0x38,0x2a,0x70,0x1d,0x10,0x02,0x5a,0x66,0x71,0x2c,0x1f,0x1e,0x11,0x03,0x5b,
1456	0x67,0x2e,0x2d,0x20,0x12,0x05,0x04,0x5c,0x68,0x39,0x2f,0x21,0x14,0x13,0x06,0x5d,
1457	0x69,0x31,0x30,0x23,0x22,0x15,0x07,0x5e,0x6a,0x72,0x32,0x24,0x16,0x08,0x09,0x5f,
1458	0x6b,0x33,0x25,0x17,0x18,0x0b,0x0a,0x60,0x6c,0x34,0x35,0x26,0x27,0x19,0x0c,0x61,
1459	0x6d,0x73,0x28,0x74,0x1a,0x0d,0x62,0x6e,0x3a,0x36,0x1c,0x1b,0x75,0x2b,0x63,0x76,
1460	0x55,0x56,0x77,0x78,0x79,0x7a,0x0e,0x7b,0x7c,0x4f,0x7d,0x4b,0x47,0x7e,0x7f,0x6f,
1461	0x52,0x53,0x50,0x4c,0x4d,0x48,0x01,0x45,0x57,0x4e,0x51,0x4a,0x37,0x49,0x46,0x54
1462	};
1463
1464	/**
1465	* Convert an AT (Scan Set 2) scancode to PC (Scan Set 1).
1466	*
1467	* @param state Current state of the translator
1468	* (xlat_state_t).
1469	* @param scanIn Incoming scan code.
1470	* @param pScanOut Pointer to outgoing scan code. The
1471	* contents are only valid if returned
1472	* state is not XS_BREAK.
1473	*
1474	* @return xlat_state_t New state of the translator.
1475	*/
1476	int32_t XlateAT2PC(int32_t state, uint8_t scanIn, uint8_t *pScanOut)
1477	{
1478	uint8_t scan_in;
1479	uint8_t scan_out;
1480
1481	Assert(pScanOut);
1482	Assert(state == XS_IDLE \|\| state == XS_BREAK \|\| state == XS_HIBIT);
1483
1484	/* Preprocess the scan code for a 128-entry translation table. */
1485	if (scanIn == 0x83) /* Check for F7 key. */
1486	scan_in = 0x02;
1487	else if (scanIn == 0x84) /* Check for SysRq key. */
1488	scan_in = 0x7f;
1489	else
1490	scan_in = scanIn;
1491
1492	/* Values 0x80 and above are passed through, except for 0xF0
1493	* which indicates a key release.
1494	*/
1495	if (scan_in < 0x80)
1496	{
1497	scan_out = aAT2PC[scan_in];
1498	/* Turn into break code if required. */
1499	if (state == XS_BREAK \|\| state == XS_HIBIT)
1500	scan_out \|= 0x80;
1501
1502	state = XS_IDLE;
1503	}
1504	else
1505	{
1506	/* NB: F0 E0 10 will be translated to E0 E5 (high bit set on last byte)! */
1507	if (scan_in == 0xF0) /* Check for break code. */
1508	state = XS_BREAK;
1509	else if (state == XS_BREAK)
1510	state = XS_HIBIT; /* Remember the break bit. */
1511	scan_out = scan_in;
1512	}
1513	LogFlowFunc(("scan code %02X translated to %02X; new state is %d\n",
1514	scanIn, scan_out, state));
1515
1516	*pScanOut = scan_out;
1517	return state;
1518	}
1519
1520	#endif /* !VBOX_DEVICE_STRUCT_TESTCASE */

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

source: vbox/trunk/src/VBox/Devices/Input/PS2K.cpp@ 68080

Download in other formats: