PS2K.cpp@ 72372

Last change on this file since 72372 was 72115, checked in by vboxsync, 7 years ago
SCM
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 63.1 KB

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

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

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

Download in other formats: