PS2K.cpp@ 72056

Last change on this file since 72056 was 71358, checked in by vboxsync, 7 years ago
PS2K: Forgot to relocate the new timer.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 61.7 KB

Line
1	/* $Id: PS2K.cpp 71358 2018-03-15 15:51:10Z 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	* Save a queue state.
516	*
517	* @param pSSM SSM handle to write the state to.
518	* @param pQ Pointer to the queue.
519	*/
520	static void ps2kSaveQueue(PSSMHANDLE pSSM, GeneriQ *pQ)
521	{
522	uint32_t cItems = pQ->cUsed;
523	int i;
524
525	/* Only save the number of items. Note that the read/write
526	* positions aren't saved as they will be rebuilt on load.
527	*/
528	SSMR3PutU32(pSSM, cItems);
529
530	LogFlow(("Storing %d items from queue %p\n", cItems, pQ));
531
532	/* Save queue data - only the bytes actually used (typically zero). */
533	for (i = pQ->rpos; cItems-- > 0; i = (i + 1) % pQ->cSize)
534	SSMR3PutU8(pSSM, pQ->abQueue[i]);
535	}
536
537	/**
538	* Load a queue state.
539	*
540	* @param pSSM SSM handle to read the state from.
541	* @param pQ Pointer to the queue.
542	*
543	* @return int VBox status/error code.
544	*/
545	static int ps2kLoadQueue(PSSMHANDLE pSSM, GeneriQ *pQ)
546	{
547	/* On load, always put the read pointer at zero. */
548	int rc = SSMR3GetU32(pSSM, &pQ->cUsed);
549	AssertRCReturn(rc, rc);
550	LogFlow(("Loading %u items to queue %p\n", pQ->cUsed, pQ));
551	AssertMsgReturn(pQ->cUsed <= pQ->cSize, ("Saved size=%u, actual=%u\n", pQ->cUsed, pQ->cSize),
552	VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
553
554	/* Recalculate queue positions and load data in one go. */
555	pQ->rpos = 0;
556	pQ->wpos = pQ->cUsed;
557	rc = SSMR3GetMem(pSSM, pQ->abQueue, pQ->cUsed);
558
559	return rc;
560	}
561
562	/**
563	* Notify listener about LEDs state change.
564	*
565	* @param pThis The PS/2 keyboard instance data.
566	* @param u8State Bitfield which reflects LEDs state.
567	*/
568	static void ps2kNotifyLedsState(PPS2K pThis, uint8_t u8State)
569	{
570
571	PDMKEYBLEDS enmLeds = PDMKEYBLEDS_NONE;
572
573	if (u8State & 0x01)
574	enmLeds = (PDMKEYBLEDS)(enmLeds \| PDMKEYBLEDS_SCROLLLOCK);
575	if (u8State & 0x02)
576	enmLeds = (PDMKEYBLEDS)(enmLeds \| PDMKEYBLEDS_NUMLOCK);
577	if (u8State & 0x04)
578	enmLeds = (PDMKEYBLEDS)(enmLeds \| PDMKEYBLEDS_CAPSLOCK);
579
580	pThis->Keyboard.pDrv->pfnLedStatusChange(pThis->Keyboard.pDrv, enmLeds);
581
582	}
583
584	/**
585	* Query the number of items currently in a queue.
586	*
587	* @param pQ Pointer to the queue.
588	*
589	* @return uint32_t Number of items in queue.
590	*/
591	static uint32_t ps2kInQueue(GeneriQ *pQ)
592	{
593	return pQ->cUsed;
594	}
595
596	#endif /* IN_RING3 */
597
598	/**
599	* Retrieve a byte from a queue.
600	*
601	* @param pQ Pointer to the queue.
602	* @param pVal Pointer to storage for the byte.
603	*
604	* @return int VINF_TRY_AGAIN if queue is empty,
605	* VINF_SUCCESS if a byte was read.
606	*/
607	static int ps2kRemoveQueue(GeneriQ pQ, uint8_t pVal)
608	{
609	int rc = VINF_TRY_AGAIN;
610
611	Assert(pVal);
612	if (pQ->cUsed)
613	{
614	*pVal = pQ->abQueue[pQ->rpos];
615	if (++pQ->rpos == pQ->cSize)
616	pQ->rpos = 0; /* Roll over. */
617	--pQ->cUsed;
618	rc = VINF_SUCCESS;
619	LogFlowFunc(("removed 0x%02X from queue %p\n", *pVal, pQ));
620	} else
621	LogFlowFunc(("queue %p empty\n", pQ));
622	return rc;
623	}
624
625	/* Convert encoded typematic value to milliseconds. Note that the values are rated
626	* with +/- 20% accuracy, so there's no need for high precision.
627	*/
628	static void ps2kSetupTypematic(PPS2K pThis, uint8_t val)
629	{
630	int A, B;
631	unsigned period;
632
633	pThis->u8Typematic = val;
634	/* The delay is easy: (1 + value) * 250 ms */
635	pThis->uTypematicDelay = (1 + ((val >> 5) & 3)) * 250;
636	/* The rate is more complicated: (8 + A) * 2^B * 4.17 ms */
637	A = val & 7;
638	B = (val >> 3) & 3;
639	period = (8 + A) * (1 << B) * 417 / 100;
640	pThis->uTypematicRepeat = period;
641	Log(("Typematic delay %u ms, repeat period %u ms\n",
642	pThis->uTypematicDelay, pThis->uTypematicRepeat));
643	}
644
645	static void ps2kSetDefaults(PPS2K pThis)
646	{
647	LogFlowFunc(("Set keyboard defaults\n"));
648	ps2kClearQueue((GeneriQ *)&pThis->keyQ);
649	/* Set default Scan Set 3 typematic values. */
650	/* Set default typematic rate/delay. */
651	ps2kSetupTypematic(pThis, KBD_DFL_RATE_DELAY);
652	/* Clear last typematic key?? */
653	}
654
655	/**
656	* Receive and process a byte sent by the keyboard controller.
657	*
658	* @param pThis The PS/2 keyboard instance data.
659	* @param cmd The command (or data) byte.
660	*/
661	int PS2KByteToKbd(PPS2K pThis, uint8_t cmd)
662	{
663	bool fHandled = true;
664
665	LogFlowFunc(("new cmd=0x%02X, active cmd=0x%02X\n", cmd, pThis->u8CurrCmd));
666
667	if (pThis->u8CurrCmd == KCMD_RESET)
668	/* In reset mode, do not respond at all. */
669	return VINF_SUCCESS;
670
671	switch (cmd)
672	{
673	case KCMD_ECHO:
674	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ECHO);
675	pThis->u8CurrCmd = 0;
676	break;
677	case KCMD_READ_ID:
678	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
679	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ID1);
680	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ID2);
681	pThis->u8CurrCmd = 0;
682	break;
683	case KCMD_ENABLE:
684	pThis->fScanning = true;
685	ps2kClearQueue((GeneriQ *)&pThis->keyQ);
686	/* Clear last typematic key?? */
687	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
688	pThis->u8CurrCmd = 0;
689	break;
690	case KCMD_DFLT_DISABLE:
691	pThis->fScanning = false;
692	ps2kSetDefaults(pThis);
693	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
694	pThis->u8CurrCmd = 0;
695	break;
696	case KCMD_SET_DEFAULT:
697	ps2kSetDefaults(pThis);
698	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
699	pThis->u8CurrCmd = 0;
700	break;
701	case KCMD_ALL_TYPEMATIC:
702	case KCMD_ALL_MK_BRK:
703	case KCMD_ALL_MAKE:
704	case KCMD_ALL_TMB:
705	/// @todo Set the key types here.
706	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
707	pThis->u8CurrCmd = 0;
708	break;
709	case KCMD_RESEND:
710	pThis->u8CurrCmd = 0;
711	break;
712	case KCMD_RESET:
713	pThis->u8ScanSet = 2;
714	ps2kSetDefaults(pThis);
715	/// @todo reset more?
716	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
717	pThis->u8CurrCmd = cmd;
718	/* Delay BAT completion; the test may take hundreds of ms. */
719	TMTimerSetMillies(pThis->CTX_SUFF(pKbdDelayTimer), 2);
720	break;
721	/* The following commands need a parameter. */
722	case KCMD_LEDS:
723	case KCMD_SCANSET:
724	case KCMD_RATE_DELAY:
725	case KCMD_TYPE_MATIC:
726	case KCMD_TYPE_MK_BRK:
727	case KCMD_TYPE_MAKE:
728	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
729	pThis->u8CurrCmd = cmd;
730	break;
731	default:
732	/* Sending a command instead of a parameter starts the new command. */
733	switch (pThis->u8CurrCmd)
734	{
735	case KCMD_LEDS:
736	#ifndef IN_RING3
737	return VINF_IOM_R3_IOPORT_WRITE;
738	#else
739	{
740	ps2kNotifyLedsState(pThis, cmd);
741	pThis->fNumLockOn = !!(cmd & 0x02); /* Sync internal Num Lock state. */
742	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
743	pThis->u8LEDs = cmd;
744	pThis->u8CurrCmd = 0;
745	}
746	#endif
747	break;
748	case KCMD_SCANSET:
749	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
750	if (cmd == 0)
751	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, pThis->u8ScanSet);
752	else if (cmd < 4)
753	{
754	pThis->u8ScanSet = cmd;
755	LogRel(("PS2K: Selected scan set %d\n", cmd));
756	}
757	/* Other values are simply ignored. */
758	pThis->u8CurrCmd = 0;
759	break;
760	case KCMD_RATE_DELAY:
761	ps2kSetupTypematic(pThis, cmd);
762	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
763	pThis->u8CurrCmd = 0;
764	break;
765	default:
766	fHandled = false;
767	}
768	/* Fall through only to handle unrecognized commands. */
769	if (fHandled)
770	break;
771	RT_FALL_THRU();
772
773	case KCMD_INVALID_1:
774	case KCMD_INVALID_2:
775	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_RESEND);
776	pThis->u8CurrCmd = 0;
777	break;
778	}
779	LogFlowFunc(("Active cmd now 0x%02X; updating interrupts\n", pThis->u8CurrCmd));
780	// KBCUpdateInterrupts(pThis->pParent);
781	return VINF_SUCCESS;
782	}
783
784	/**
785	* Send a byte (keystroke or command response) to the keyboard controller.
786	*
787	* @returns VINF_SUCCESS or VINF_TRY_AGAIN.
788	* @param pThis The PS/2 keyboard instance data.
789	* @param pb Where to return the byte we've read.
790	* @remarks Caller must have entered the device critical section.
791	*/
792	int PS2KByteFromKbd(PPS2K pThis, uint8_t *pb)
793	{
794	int rc;
795
796	AssertPtr(pb);
797
798	/* Anything in the command queue has priority over data
799	* in the keystroke queue. Additionally, keystrokes are
800	* blocked if a command is currently in progress, even if
801	* the command queue is empty.
802	*/
803	rc = ps2kRemoveQueue((GeneriQ *)&pThis->cmdQ, pb);
804	if (rc != VINF_SUCCESS && !pThis->u8CurrCmd && pThis->fScanning)
805	if (!pThis->fThrottleActive)
806	{
807	rc = ps2kRemoveQueue((GeneriQ *)&pThis->keyQ, pb);
808	if (pThis->fThrottleEnabled) {
809	pThis->fThrottleActive = true;
810	TMTimerSetMillies(pThis->CTX_SUFF(pThrottleTimer), KBD_THROTTLE_DELAY);
811	}
812	}
813
814	LogFlowFunc(("keyboard sends 0x%02x (%svalid data)\n", *pb, rc == VINF_SUCCESS ? "" : "not "));
815	return rc;
816	}
817
818	#ifdef IN_RING3
819
820	static int ps2kProcessKeyEvent(PPS2K pThis, uint8_t u8HidCode, bool fKeyDown)
821	{
822	unsigned int i = 0;
823	key_def const *pKeyDef;
824	uint8_t abCodes[16];
825	uint8_t u8MakeCode;
826
827	LogFlowFunc(("key %s: 0x%02x (set %d)\n", fKeyDown ? "down" : "up", u8HidCode, pThis->u8ScanSet));
828
829	/* Find the key definition in somewhat sparse storage. */
830	pKeyDef = u8HidCode >= HID_MODIFIER_FIRST ? &aPS2ModKeys[u8HidCode - HID_MODIFIER_FIRST] : &aPS2Keys[u8HidCode];
831
832	/* Some keys are not processed at all; early return. */
833	if (pKeyDef->makeS1 == NONE)
834	{
835	LogFlow(("Skipping key processing.\n"));
836	return VINF_SUCCESS;
837	}
838
839	/* Handle modifier keys (Ctrl/Alt/Shift/GUI). We need to keep track
840	* of their state in addition to sending the scan code.
841	*/
842	if (u8HidCode >= HID_MODIFIER_FIRST)
843	{
844	unsigned mod_bit = 1 << (u8HidCode - HID_MODIFIER_FIRST);
845
846	Assert((u8HidCode <= HID_MODIFIER_LAST));
847	if (fKeyDown)
848	pThis->u8Modifiers \|= mod_bit;
849	else
850	pThis->u8Modifiers &= ~mod_bit;
851	}
852
853	/* Toggle NumLock state. */
854	if ((pKeyDef->keyFlags & KF_NL) && fKeyDown)
855	pThis->fNumLockOn ^= true;
856
857	if (pThis->u8ScanSet == 1 \|\| pThis->u8ScanSet == 2)
858	{
859	/* The basic scan set 1 and 2 logic is the same, only the scan codes differ.
860	* Since scan set 2 is used almost all the time, that case is handled first.
861	*/
862	abCodes[0] = 0;
863	if (fKeyDown)
864	{
865	/* Process key down event. */
866	if (pKeyDef->keyFlags & KF_PB)
867	{
868	/* Pause/Break sends different data if either Ctrl is held. */
869	if (pThis->u8Modifiers & (MOD_LCTRL \| MOD_RCTRL))
870	strcpy((char *)abCodes, pThis->u8ScanSet == 2 ?
871	"\xE0\x7E\xE0\xF0\x7E" : "\xE0\x46\xE0\xC6");
872	else
873	strcpy((char *)abCodes, pThis->u8ScanSet == 2 ?
874	"\xE1\x14\x77\xE1\xF0\x14\xF0\x77" : "\xE1\x1D\x45\xE1\x9D\xC5");
875	}
876	else if (pKeyDef->keyFlags & KF_PS)
877	{
878	/* Print Screen depends on all of Ctrl, Shift, and Alt! */
879	if (pThis->u8Modifiers & (MOD_LALT \| MOD_RALT))
880	strcpy((char *)abCodes, pThis->u8ScanSet == 2 ?
881	"\x84" : "\x54");
882	else if (pThis->u8Modifiers & (MOD_LSHIFT \| MOD_RSHIFT))
883	strcpy((char *)abCodes, pThis->u8ScanSet == 2 ?
884	"\xE0\x7C" : "\xE0\x37");
885	else
886	strcpy((char *)abCodes, pThis->u8ScanSet == 2 ?
887	"\xE0\x12\xE0\x7C" : "\xE0\x2A\xE0\x37");
888	}
889	else if (pKeyDef->keyFlags & (KF_GK \| KF_NS))
890	{
891	/* The numeric pad keys fake Shift presses or releases
892	* depending on Num Lock and Shift key state. The '/'
893	* key behaves in a similar manner but does not depend on
894	* the Num Lock state.
895	*/
896	if (!pThis->fNumLockOn \|\| (pKeyDef->keyFlags & KF_NS))
897	{
898	if (pThis->u8Modifiers & MOD_LSHIFT)
899	strcat((char *)abCodes, pThis->u8ScanSet == 2 ?
900	"\xE0\xF0\x12" : "\xE0\xAA");
901	if (pThis->u8Modifiers & MOD_RSHIFT)
902	strcat((char *)abCodes, pThis->u8ScanSet == 2 ?
903	"\xE0\xF0\x59" : "\xE0\xB6");
904	}
905	else
906	{
907	Assert(pThis->fNumLockOn); /* Not for KF_NS! */
908	if ((pThis->u8Modifiers & (MOD_LSHIFT \| MOD_RSHIFT)) == 0)
909	strcpy((char *)abCodes, pThis->u8ScanSet == 2 ?
910	"\xE0\x12" : "\xE0\x2A");
911	/* Else Shift cancels NumLock, so no prefix! */
912	}
913	}
914	/* Feed the bytes to the queue if there is room. */
915	/// @todo check empty space!
916	while (abCodes[i])
917	ps2kInsertQueue((GeneriQ *)&pThis->keyQ, abCodes[i++]);
918	Assert(i < sizeof(abCodes));
919
920	/* Standard processing for regular keys only. */
921	u8MakeCode = pThis->u8ScanSet == 2 ? pKeyDef->makeS2 : pKeyDef->makeS1;
922	if (!(pKeyDef->keyFlags & (KF_PB \| KF_PS)))
923	{
924	if (pKeyDef->keyFlags & (KF_E0 \| KF_GK \| KF_NS))
925	ps2kInsertQueue((GeneriQ *)&pThis->keyQ, 0xE0);
926	ps2kInsertQueue((GeneriQ *)&pThis->keyQ, u8MakeCode);
927	}
928	}
929	else if (!(pKeyDef->keyFlags & (KF_NB \| KF_PB)))
930	{
931	/* Process key up event except for keys which produce none. */
932
933	/* Handle Print Screen release. */
934	if (pKeyDef->keyFlags & KF_PS)
935	{
936	/* Undo faked Print Screen state as needed. */
937	if (pThis->u8Modifiers & (MOD_LALT \| MOD_RALT))
938	strcpy((char *)abCodes, pThis->u8ScanSet == 2 ?
939	"\xF0\x84" : "\xD4");
940	else if (pThis->u8Modifiers & (MOD_LSHIFT \| MOD_RSHIFT))
941	strcpy((char *)abCodes, pThis->u8ScanSet == 2 ?
942	"\xE0\xF0\x7C" : "\xE0\xB7");
943	else
944	strcpy((char *)abCodes, pThis->u8ScanSet == 2 ?
945	"\xE0\xF0\x7C\xE0\xF0\x12" : "\xE0\xB7\xE0\xAA");
946	}
947	else
948	{
949	/* Process base scan code for less unusual keys. */
950	if (pKeyDef->keyFlags & (KF_E0 \| KF_GK \| KF_NS))
951	ps2kInsertQueue((GeneriQ *)&pThis->keyQ, 0xE0);
952	if (pThis->u8ScanSet == 2) {
953	ps2kInsertQueue((GeneriQ *)&pThis->keyQ, 0xF0);
954	ps2kInsertQueue((GeneriQ *)&pThis->keyQ, pKeyDef->makeS2);
955	} else {
956	Assert(pThis->u8ScanSet == 1);
957	ps2kInsertQueue((GeneriQ *)&pThis->keyQ, pKeyDef->makeS1 \| 0x80);
958	}
959
960	/* Restore shift state for gray keys. */
961	if (pKeyDef->keyFlags & (KF_GK \| KF_NS))
962	{
963	if (!pThis->fNumLockOn \|\| (pKeyDef->keyFlags & KF_NS))
964	{
965	if (pThis->u8Modifiers & MOD_LSHIFT)
966	strcat((char *)abCodes, pThis->u8ScanSet == 2 ?
967	"\xE0\x12" : "\xE0\x2A");
968	if (pThis->u8Modifiers & MOD_RSHIFT)
969	strcat((char *)abCodes, pThis->u8ScanSet == 2 ?
970	"\xE0\x59" : "\xE0\x36");
971	}
972	else
973	{
974	Assert(pThis->fNumLockOn); /* Not for KF_NS! */
975	if ((pThis->u8Modifiers & (MOD_LSHIFT \| MOD_RSHIFT)) == 0)
976	strcpy((char *)abCodes, pThis->u8ScanSet == 2 ?
977	"\xE0\xF0\x12" : "\xE0\xAA");
978	}
979	}
980	}
981
982	/* Feed any additional bytes to the queue if there is room. */
983	/// @todo check empty space!
984	while (abCodes[i])
985	ps2kInsertQueue((GeneriQ *)&pThis->keyQ, abCodes[i++]);
986	Assert(i < sizeof(abCodes));
987	}
988	}
989	else
990	{
991	/* Handle Scan Set 3 - very straightforward. */
992	Assert(pThis->u8ScanSet == 3);
993	if (fKeyDown)
994	{
995	ps2kInsertQueue((GeneriQ *)&pThis->keyQ, pKeyDef->makeS3);
996	}
997	else
998	{
999	/* Send a key release code unless it's a make only key. */
1000	/// @todo Look up the current typematic setting, not the default!
1001	if (pKeyDef->keyMatic != T_M)
1002	{
1003	ps2kInsertQueue((GeneriQ *)&pThis->keyQ, 0xF0);
1004	ps2kInsertQueue((GeneriQ *)&pThis->keyQ, pKeyDef->makeS3);
1005	}
1006	}
1007	}
1008
1009	/* Set up or cancel typematic key repeat. */
1010	if (fKeyDown)
1011	{
1012	if (pThis->u8TypematicKey != u8HidCode)
1013	{
1014	pThis->enmTypematicState = KBD_TMS_DELAY;
1015	pThis->u8TypematicKey = u8HidCode;
1016	TMTimerSetMillies(pThis->CTX_SUFF(pKbdTypematicTimer), pThis->uTypematicDelay);
1017	Log(("Typematic delay %u ms, key %02X\n", pThis->uTypematicDelay, u8HidCode));
1018	}
1019	}
1020	else
1021	{
1022	pThis->u8TypematicKey = 0;
1023	pThis->enmTypematicState = KBD_TMS_IDLE;
1024	/// @todo Cancel timer right away?
1025	/// @todo Cancel timer before pushing key up code!?
1026	}
1027
1028	/* Poke the KBC to update its state. */
1029	KBCUpdateInterrupts(pThis->pParent);
1030
1031	return VINF_SUCCESS;
1032	}
1033
1034	/* Throttling timer to emulate the finite keyboard communication speed. A PS/2 keyboard is
1035	* limited by the serial link speed and cannot send much more than 1,000 bytes per second.
1036	* Some software (notably Borland Pascal and programs built with its run-time) relies on
1037	* being able to read an incoming scan-code twice. Throttling the data rate enables such
1038	* software to function, while human typists cannot tell any difference.
1039	*
1040	* Note: The throttling is currently only done for keyboard data, not command responses.
1041	* The throttling could and perhaps should be done for any data (including command
1042	* response) scoming from PS/2 devices, both keyboard and auxiliary. That is not currently
1043	* done because it would needlessly slow things down.
1044	*/
1045	static DECLCALLBACK(void) ps2kThrottleTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
1046	{
1047	RT_NOREF2(pDevIns, pTimer);
1048	PPS2K pThis = (PS2K *)pvUser;
1049	unsigned uHaveData;
1050
1051	/* Grab the lock to avoid races with event delivery or EMTs. */
1052	int rc = PDMCritSectEnter(pThis->pCritSectR3, VERR_SEM_BUSY);
1053	AssertReleaseRC(rc);
1054
1055	/* If data is available, poke the KBC. Once the data
1056	* is actually read, the timer may be re-triggered.
1057	*/
1058	pThis->fThrottleActive = false;
1059	uHaveData = ps2kInQueue((GeneriQ *)&pThis->keyQ);
1060	LogFlowFunc(("Have%s bytes\n", uHaveData ? "" : " no"));
1061	if (uHaveData)
1062	KBCUpdateInterrupts(pThis->pParent);
1063
1064	PDMCritSectLeave(pThis->pCritSectR3);
1065	}
1066
1067	/* Timer handler for emulating typematic keys. Note that only the last key
1068	* held down repeats (if typematic).
1069	*/
1070	static DECLCALLBACK(void) ps2kTypematicTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
1071	{
1072	RT_NOREF2(pDevIns, pTimer);
1073	PPS2K pThis = (PS2K *)pvUser;
1074	LogFlowFunc(("Typematic state=%d, key %02X\n", pThis->enmTypematicState, pThis->u8TypematicKey));
1075
1076	/* If the current typematic key is zero, the repeat was canceled just when
1077	* the timer was about to run. In that case, do nothing.
1078	*/
1079	if (pThis->u8TypematicKey)
1080	{
1081	if (pThis->enmTypematicState == KBD_TMS_DELAY)
1082	pThis->enmTypematicState = KBD_TMS_REPEAT;
1083
1084	if (pThis->enmTypematicState == KBD_TMS_REPEAT)
1085	{
1086	ps2kProcessKeyEvent(pThis, pThis->u8TypematicKey, true /* Key down */ );
1087	TMTimerSetMillies(pThis->CTX_SUFF(pKbdTypematicTimer), pThis->uTypematicRepeat);
1088	}
1089	}
1090	}
1091
1092	/* The keyboard BAT is specified to take several hundred milliseconds. We need
1093	* to delay sending the result to the host for at least a tiny little while.
1094	*/
1095	static DECLCALLBACK(void) ps2kDelayTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
1096	{
1097	RT_NOREF2(pDevIns, pTimer);
1098	PPS2K pThis = (PS2K *)pvUser;
1099
1100	LogFlowFunc(("Delay timer: cmd %02X\n", pThis->u8CurrCmd));
1101
1102	AssertMsg(pThis->u8CurrCmd == KCMD_RESET, ("u8CurrCmd=%02x\n", pThis->u8CurrCmd));
1103	ps2kInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_BAT_OK);
1104	pThis->fScanning = true; /* BAT completion enables scanning! */
1105	pThis->u8CurrCmd = 0;
1106
1107	/// @todo Might want a PS2KCompleteCommand() to push last response, clear command, and kick the KBC...
1108	/* Give the KBC a kick. */
1109	KBCUpdateInterrupts(pThis->pParent);
1110	}
1111
1112	/* Release any and all currently depressed keys. Used whenever the guest keyboard
1113	* is likely to be out of sync with the host, such as when loading a saved state
1114	* or resuming a suspended host.
1115	*/
1116	static void ps2kReleaseKeys(PPS2K pThis)
1117	{
1118	LogFlowFunc(("Releasing keys...\n"));
1119
1120	for (unsigned uKey = 0; uKey < sizeof(pThis->abDepressedKeys); ++uKey)
1121	if (pThis->abDepressedKeys[uKey])
1122	{
1123	ps2kProcessKeyEvent(pThis, uKey, false /* key up */);
1124	pThis->abDepressedKeys[uKey] = 0;
1125	}
1126	LogFlowFunc(("Done releasing keys\n"));
1127	}
1128
1129
1130	/**
1131	* Debug device info handler. Prints basic keyboard state.
1132	*
1133	* @param pDevIns Device instance which registered the info.
1134	* @param pHlp Callback functions for doing output.
1135	* @param pszArgs Argument string. Optional and specific to the handler.
1136	*/
1137	static DECLCALLBACK(void) ps2kInfoState(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
1138	{
1139	PPS2K pThis = KBDGetPS2KFromDevIns(pDevIns);
1140	NOREF(pszArgs);
1141
1142	pHlp->pfnPrintf(pHlp, "PS/2 Keyboard: scan set %d, scanning %s\n",
1143	pThis->u8ScanSet, pThis->fScanning ? "enabled" : "disabled");
1144	pHlp->pfnPrintf(pHlp, "Active command %02X\n", pThis->u8CurrCmd);
1145	pHlp->pfnPrintf(pHlp, "LED state %02X, Num Lock %s\n", pThis->u8LEDs,
1146	pThis->fNumLockOn ? "on" : "off");
1147	pHlp->pfnPrintf(pHlp, "Typematic delay %ums, repeat period %ums\n",
1148	pThis->uTypematicDelay, pThis->uTypematicRepeat);
1149	pHlp->pfnPrintf(pHlp, "Command queue: %d items (%d max)\n",
1150	pThis->cmdQ.cUsed, pThis->cmdQ.cSize);
1151	pHlp->pfnPrintf(pHlp, "Input queue : %d items (%d max)\n",
1152	pThis->keyQ.cUsed, pThis->keyQ.cSize);
1153	if (pThis->enmTypematicState != KBD_TMS_IDLE)
1154	pHlp->pfnPrintf(pHlp, "Active typematic key %02X (%s)\n", pThis->u8Typematic,
1155	pThis->enmTypematicState == KBD_TMS_DELAY ? "delay" : "repeat");
1156	}
1157
1158	/* -=-=-=-=-=- Keyboard: IBase -=-=-=-=-=- */
1159
1160	/**
1161	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
1162	*/
1163	static DECLCALLBACK(void ) ps2kQueryInterface(PPDMIBASE pInterface, const char pszIID)
1164	{
1165	PPS2K pThis = RT_FROM_MEMBER(pInterface, PS2K, Keyboard.IBase);
1166	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->Keyboard.IBase);
1167	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIKEYBOARDPORT, &pThis->Keyboard.IPort);
1168	return NULL;
1169	}
1170
1171
1172	/* -=-=-=-=-=- Keyboard: IKeyboardPort -=-=-=-=-=- */
1173
1174	/**
1175	* Keyboard event handler.
1176	*
1177	* @returns VBox status code.
1178	* @param pThis The PS2 keyboard instance data.
1179	* @param u32Usage USB HID usage code with key
1180	* press/release flag.
1181	*/
1182	static int ps2kPutEventWorker(PPS2K pThis, uint32_t u32Usage)
1183	{
1184	uint8_t u8HidCode;
1185	bool fKeyDown;
1186	bool fHaveEvent = true;
1187	int rc = VINF_SUCCESS;
1188
1189	/* Extract the usage code and ensure it's valid. */
1190	fKeyDown = !(u32Usage & 0x80000000);
1191	u8HidCode = u32Usage & 0xFF;
1192	AssertReturn(u8HidCode <= VBOX_USB_MAX_USAGE_CODE, VERR_INTERNAL_ERROR);
1193
1194	if (fKeyDown)
1195	{
1196	/* Due to host key repeat, we can get key events for keys which are
1197	* already depressed. We need to ignore those. */
1198	if (pThis->abDepressedKeys[u8HidCode])
1199	fHaveEvent = false;
1200	pThis->abDepressedKeys[u8HidCode] = 1;
1201	}
1202	else
1203	{
1204	/* NB: We allow key release events for keys which aren't depressed.
1205	* That is unlikely to happen and should not cause trouble.
1206	*/
1207	pThis->abDepressedKeys[u8HidCode] = 0;
1208	}
1209
1210	/* Unless this is a new key press/release, don't even bother. */
1211	if (fHaveEvent)
1212	{
1213	rc = PDMCritSectEnter(pThis->pCritSectR3, VERR_SEM_BUSY);
1214	AssertReleaseRC(rc);
1215
1216	rc = ps2kProcessKeyEvent(pThis, u8HidCode, fKeyDown);
1217
1218	PDMCritSectLeave(pThis->pCritSectR3);
1219	}
1220
1221	return rc;
1222	}
1223
1224	static DECLCALLBACK(int) ps2kPutEventWrapper(PPDMIKEYBOARDPORT pInterface, uint32_t u32UsageCode)
1225	{
1226	PPS2K pThis = RT_FROM_MEMBER(pInterface, PS2K, Keyboard.IPort);
1227	int rc;
1228
1229	LogRelFlowFunc(("key code %08X\n", u32UsageCode));
1230
1231	rc = PDMCritSectEnter(pThis->pCritSectR3, VERR_SEM_BUSY);
1232	AssertReleaseRC(rc);
1233
1234	/* The 'BAT fail' scancode is reused as a signal to release keys. No actual
1235	* key is allowed to use this scancode.
1236	*/
1237	if (RT_UNLIKELY(u32UsageCode == KRSP_BAT_FAIL))
1238	{
1239	ps2kReleaseKeys(pThis);
1240	}
1241	else
1242	{
1243	ps2kPutEventWorker(pThis, u32UsageCode);
1244	}
1245
1246	PDMCritSectLeave(pThis->pCritSectR3);
1247
1248	return VINF_SUCCESS;
1249	}
1250
1251
1252	/**
1253	* Attach command.
1254	*
1255	* This is called to let the device attach to a driver for a
1256	* specified LUN.
1257	*
1258	* This is like plugging in the keyboard after turning on the
1259	* system.
1260	*
1261	* @returns VBox status code.
1262	* @param pThis The PS/2 keyboard instance data.
1263	* @param pDevIns The device instance.
1264	* @param iLUN The logical unit which is being detached.
1265	* @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
1266	*/
1267	int PS2KAttach(PPS2K pThis, PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
1268	{
1269	int rc;
1270
1271	/* The LUN must be 0, i.e. keyboard. */
1272	Assert(iLUN == 0);
1273	AssertMsgReturn(fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG,
1274	("PS/2 keyboard does not support hotplugging\n"),
1275	VERR_INVALID_PARAMETER);
1276
1277	LogFlowFunc(("iLUN=%d\n", iLUN));
1278
1279	rc = PDMDevHlpDriverAttach(pDevIns, iLUN, &pThis->Keyboard.IBase, &pThis->Keyboard.pDrvBase, "Keyboard Port");
1280	if (RT_SUCCESS(rc))
1281	{
1282	pThis->Keyboard.pDrv = PDMIBASE_QUERY_INTERFACE(pThis->Keyboard.pDrvBase, PDMIKEYBOARDCONNECTOR);
1283	if (!pThis->Keyboard.pDrv)
1284	{
1285	AssertLogRelMsgFailed(("LUN #0 doesn't have a keyboard interface! rc=%Rrc\n", rc));
1286	rc = VERR_PDM_MISSING_INTERFACE;
1287	}
1288	}
1289	else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
1290	{
1291	Log(("%s/%d: warning: no driver attached to LUN #0!\n", pDevIns->pReg->szName, pDevIns->iInstance));
1292	rc = VINF_SUCCESS;
1293	}
1294	else
1295	AssertLogRelMsgFailed(("Failed to attach LUN #0! rc=%Rrc\n", rc));
1296
1297	return rc;
1298	}
1299
1300	void PS2KSaveState(PPS2K pThis, PSSMHANDLE pSSM)
1301	{
1302	uint32_t cPressed = 0;
1303	uint32_t cbTMSSize = 0;
1304
1305	LogFlowFunc(("Saving PS2K state\n"));
1306
1307	/* Save the basic keyboard state. */
1308	SSMR3PutU8(pSSM, pThis->u8CurrCmd);
1309	SSMR3PutU8(pSSM, pThis->u8LEDs);
1310	SSMR3PutU8(pSSM, pThis->u8Typematic);
1311	SSMR3PutU8(pSSM, pThis->u8TypematicKey);
1312	SSMR3PutU8(pSSM, pThis->u8Modifiers);
1313	SSMR3PutU8(pSSM, pThis->u8ScanSet);
1314	SSMR3PutU8(pSSM, pThis->enmTypematicState);
1315	SSMR3PutBool(pSSM, pThis->fNumLockOn);
1316	SSMR3PutBool(pSSM, pThis->fScanning);
1317
1318	/* Save the command and keystroke queues. */
1319	ps2kSaveQueue(pSSM, (GeneriQ *)&pThis->cmdQ);
1320	ps2kSaveQueue(pSSM, (GeneriQ *)&pThis->keyQ);
1321
1322	/* Save the command delay timer. Note that the typematic repeat
1323	* timer is not saved.
1324	*/
1325	TMR3TimerSave(pThis->CTX_SUFF(pKbdDelayTimer), pSSM);
1326
1327	/* Save any pressed keys. This is necessary to avoid "stuck"
1328	* keys after a restore. Needs two passes.
1329	*/
1330	for (unsigned i = 0; i < sizeof(pThis->abDepressedKeys); ++i)
1331	if (pThis->abDepressedKeys[i])
1332	++cPressed;
1333
1334	SSMR3PutU32(pSSM, cPressed);
1335
1336	for (unsigned uKey = 0; uKey < sizeof(pThis->abDepressedKeys); ++uKey)
1337	if (pThis->abDepressedKeys[uKey])
1338	SSMR3PutU8(pSSM, uKey);
1339
1340	/* Save the typematic settings for Scan Set 3. */
1341	SSMR3PutU32(pSSM, cbTMSSize);
1342	/* Currently not implemented. */
1343	}
1344
1345	int PS2KLoadState(PPS2K pThis, PSSMHANDLE pSSM, uint32_t uVersion)
1346	{
1347	uint8_t u8;
1348	uint32_t cPressed;
1349	uint32_t cbTMSSize;
1350	int rc;
1351
1352	NOREF(uVersion);
1353	LogFlowFunc(("Loading PS2K state version %u\n", uVersion));
1354
1355	/* Load the basic keyboard state. */
1356	SSMR3GetU8(pSSM, &pThis->u8CurrCmd);
1357	SSMR3GetU8(pSSM, &pThis->u8LEDs);
1358	SSMR3GetU8(pSSM, &pThis->u8Typematic);
1359	SSMR3GetU8(pSSM, &pThis->u8TypematicKey);
1360	SSMR3GetU8(pSSM, &pThis->u8Modifiers);
1361	SSMR3GetU8(pSSM, &pThis->u8ScanSet);
1362	SSMR3GetU8(pSSM, &u8);
1363	pThis->enmTypematicState = (tmatic_state_t)u8;
1364	SSMR3GetBool(pSSM, &pThis->fNumLockOn);
1365	SSMR3GetBool(pSSM, &pThis->fScanning);
1366
1367	/* Load the command and keystroke queues. */
1368	rc = ps2kLoadQueue(pSSM, (GeneriQ *)&pThis->cmdQ);
1369	AssertRCReturn(rc, rc);
1370	rc = ps2kLoadQueue(pSSM, (GeneriQ *)&pThis->keyQ);
1371	AssertRCReturn(rc, rc);
1372
1373	/* Load the command delay timer, just in case. */
1374	rc = TMR3TimerLoad(pThis->CTX_SUFF(pKbdDelayTimer), pSSM);
1375	AssertRCReturn(rc, rc);
1376
1377	/* Recalculate the typematic delay/rate. */
1378	ps2kSetupTypematic(pThis, pThis->u8Typematic);
1379
1380	/* Fake key up events for keys that were held down at the time the state was saved. */
1381	rc = SSMR3GetU32(pSSM, &cPressed);
1382	AssertRCReturn(rc, rc);
1383
1384	/* If any keys were down, load and then release them. */
1385	if (cPressed)
1386	{
1387	for (unsigned i = 0; i < cPressed; ++i)
1388	{
1389	rc = SSMR3GetU8(pSSM, &u8);
1390	AssertRCReturn(rc, rc);
1391	pThis->abDepressedKeys[u8] = 1;
1392	}
1393	}
1394
1395	/* Load typematic settings for Scan Set 3. */
1396	rc = SSMR3GetU32(pSSM, &cbTMSSize);
1397	AssertRCReturn(rc, rc);
1398
1399	while (cbTMSSize--)
1400	{
1401	rc = SSMR3GetU8(pSSM, &u8);
1402	AssertRCReturn(rc, rc);
1403	}
1404
1405	return rc;
1406	}
1407
1408	int PS2KLoadDone(PPS2K pThis, PSSMHANDLE pSSM)
1409	{
1410	RT_NOREF1(pSSM);
1411
1412	/* This must be done after the inital load because it may trigger
1413	* interrupts and change the interrupt controller state.
1414	*/
1415	ps2kReleaseKeys(pThis);
1416	ps2kNotifyLedsState(pThis, pThis->u8LEDs);
1417	return VINF_SUCCESS;
1418	}
1419
1420	void PS2KReset(PPS2K pThis)
1421	{
1422	LogFlowFunc(("Resetting PS2K\n"));
1423
1424	pThis->fScanning = true;
1425	pThis->fThrottleActive = false;
1426	pThis->u8ScanSet = 2;
1427	pThis->u8CurrCmd = 0;
1428	pThis->u8Modifiers = 0;
1429	pThis->u8TypematicKey = 0;
1430	pThis->enmTypematicState = KBD_TMS_IDLE;
1431
1432	/* Clear queues and any pressed keys. */
1433	memset(pThis->abDepressedKeys, 0, sizeof(pThis->abDepressedKeys));
1434	ps2kClearQueue((GeneriQ *)&pThis->cmdQ);
1435	ps2kSetDefaults(pThis); /* Also clears keystroke queue. */
1436
1437	/* Activate the PS/2 keyboard by default. */
1438	if (pThis->Keyboard.pDrv)
1439	pThis->Keyboard.pDrv->pfnSetActive(pThis->Keyboard.pDrv, true);
1440	}
1441
1442	void PS2KRelocate(PPS2K pThis, RTGCINTPTR offDelta, PPDMDEVINS pDevIns)
1443	{
1444	RT_NOREF1(pDevIns);
1445	LogFlowFunc(("Relocating PS2K\n"));
1446	pThis->pKbdDelayTimerRC = TMTimerRCPtr(pThis->pKbdDelayTimerR3);
1447	pThis->pKbdTypematicTimerRC = TMTimerRCPtr(pThis->pKbdTypematicTimerR3);
1448	pThis->pThrottleTimerRC = TMTimerRCPtr(pThis->pThrottleTimerR3);
1449	NOREF(offDelta);
1450	}
1451
1452	int PS2KConstruct(PPS2K pThis, PPDMDEVINS pDevIns, void *pParent, int iInstance, PCFGMNODE pCfg)
1453	{
1454	RT_NOREF2(pDevIns, iInstance);
1455	LogFlowFunc(("iInstance=%d\n", iInstance));
1456
1457	pThis->pParent = pParent;
1458
1459	bool fThrottleEnabled;
1460	int rc = CFGMR3QueryBoolDef(pCfg, "KbdThrottleEnabled", &fThrottleEnabled, true);
1461	if (RT_FAILURE(rc))
1462	return PDMDEV_SET_ERROR(pDevIns, rc, N_("Failed to query \"KbdThrottleEnabled\" from the config"));
1463	Log(("KbdThrottleEnabled=%u\n", fThrottleEnabled));
1464	pThis->fThrottleEnabled = fThrottleEnabled;
1465
1466	/* Initialize the queues. */
1467	pThis->keyQ.cSize = KBD_KEY_QUEUE_SIZE;
1468	pThis->cmdQ.cSize = KBD_CMD_QUEUE_SIZE;
1469
1470	pThis->Keyboard.IBase.pfnQueryInterface = ps2kQueryInterface;
1471	pThis->Keyboard.IPort.pfnPutEventHid = ps2kPutEventWrapper;
1472
1473	/*
1474	* Initialize the critical section pointer(s).
1475	*/
1476	pThis->pCritSectR3 = pDevIns->pCritSectRoR3;
1477
1478	/*
1479	* Create the input rate throttling timer. Does not use virtual time!
1480	*/
1481	PTMTIMER pTimer;
1482	rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_REAL, ps2kThrottleTimer, pThis,
1483	TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "PS2K Throttle Timer", &pTimer);
1484	if (RT_FAILURE(rc))
1485	return rc;
1486
1487	pThis->pThrottleTimerR3 = pTimer;
1488	pThis->pThrottleTimerR0 = TMTimerR0Ptr(pTimer);
1489	pThis->pThrottleTimerRC = TMTimerRCPtr(pTimer);
1490
1491	/*
1492	* Create the typematic delay/repeat timer. Does not use virtual time!
1493	*/
1494	rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_REAL, ps2kTypematicTimer, pThis,
1495	TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "PS2K Typematic Timer", &pTimer);
1496	if (RT_FAILURE(rc))
1497	return rc;
1498
1499	pThis->pKbdTypematicTimerR3 = pTimer;
1500	pThis->pKbdTypematicTimerR0 = TMTimerR0Ptr(pTimer);
1501	pThis->pKbdTypematicTimerRC = TMTimerRCPtr(pTimer);
1502
1503	/*
1504	* Create the command delay timer.
1505	*/
1506	rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, ps2kDelayTimer, pThis,
1507	TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "PS2K Delay Timer", &pTimer);
1508	if (RT_FAILURE(rc))
1509	return rc;
1510
1511	pThis->pKbdDelayTimerR3 = pTimer;
1512	pThis->pKbdDelayTimerR0 = TMTimerR0Ptr(pTimer);
1513	pThis->pKbdDelayTimerRC = TMTimerRCPtr(pTimer);
1514
1515	/*
1516	* Register debugger info callbacks.
1517	*/
1518	PDMDevHlpDBGFInfoRegister(pDevIns, "ps2k", "Display PS/2 keyboard state.", ps2kInfoState);
1519
1520	return rc;
1521	}
1522
1523	#endif
1524
1525	/// @todo The following should live with the KBC implementation.
1526
1527	/* Table used by the keyboard controller to optionally translate the incoming
1528	* keyboard data. Note that the translation is designed for essentially taking
1529	* Scan Set 2 input and producing Scan Set 1 output, but can be turned on and
1530	* off regardless of what the keyboard is sending.
1531	*/
1532	static uint8_t aAT2PC[128] = {
1533	0xff,0x43,0x41,0x3f,0x3d,0x3b,0x3c,0x58,0x64,0x44,0x42,0x40,0x3e,0x0f,0x29,0x59,
1534	0x65,0x38,0x2a,0x70,0x1d,0x10,0x02,0x5a,0x66,0x71,0x2c,0x1f,0x1e,0x11,0x03,0x5b,
1535	0x67,0x2e,0x2d,0x20,0x12,0x05,0x04,0x5c,0x68,0x39,0x2f,0x21,0x14,0x13,0x06,0x5d,
1536	0x69,0x31,0x30,0x23,0x22,0x15,0x07,0x5e,0x6a,0x72,0x32,0x24,0x16,0x08,0x09,0x5f,
1537	0x6b,0x33,0x25,0x17,0x18,0x0b,0x0a,0x60,0x6c,0x34,0x35,0x26,0x27,0x19,0x0c,0x61,
1538	0x6d,0x73,0x28,0x74,0x1a,0x0d,0x62,0x6e,0x3a,0x36,0x1c,0x1b,0x75,0x2b,0x63,0x76,
1539	0x55,0x56,0x77,0x78,0x79,0x7a,0x0e,0x7b,0x7c,0x4f,0x7d,0x4b,0x47,0x7e,0x7f,0x6f,
1540	0x52,0x53,0x50,0x4c,0x4d,0x48,0x01,0x45,0x57,0x4e,0x51,0x4a,0x37,0x49,0x46,0x54
1541	};
1542
1543	/**
1544	* Convert an AT (Scan Set 2) scancode to PC (Scan Set 1).
1545	*
1546	* @param state Current state of the translator
1547	* (xlat_state_t).
1548	* @param scanIn Incoming scan code.
1549	* @param pScanOut Pointer to outgoing scan code. The
1550	* contents are only valid if returned
1551	* state is not XS_BREAK.
1552	*
1553	* @return xlat_state_t New state of the translator.
1554	*/
1555	int32_t XlateAT2PC(int32_t state, uint8_t scanIn, uint8_t *pScanOut)
1556	{
1557	uint8_t scan_in;
1558	uint8_t scan_out;
1559
1560	Assert(pScanOut);
1561	Assert(state == XS_IDLE \|\| state == XS_BREAK \|\| state == XS_HIBIT);
1562
1563	/* Preprocess the scan code for a 128-entry translation table. */
1564	if (scanIn == 0x83) /* Check for F7 key. */
1565	scan_in = 0x02;
1566	else if (scanIn == 0x84) /* Check for SysRq key. */
1567	scan_in = 0x7f;
1568	else
1569	scan_in = scanIn;
1570
1571	/* Values 0x80 and above are passed through, except for 0xF0
1572	* which indicates a key release.
1573	*/
1574	if (scan_in < 0x80)
1575	{
1576	scan_out = aAT2PC[scan_in];
1577	/* Turn into break code if required. */
1578	if (state == XS_BREAK \|\| state == XS_HIBIT)
1579	scan_out \|= 0x80;
1580
1581	state = XS_IDLE;
1582	}
1583	else
1584	{
1585	/* NB: F0 E0 10 will be translated to E0 E5 (high bit set on last byte)! */
1586	if (scan_in == 0xF0) /* Check for break code. */
1587	state = XS_BREAK;
1588	else if (state == XS_BREAK)
1589	state = XS_HIBIT; /* Remember the break bit. */
1590	scan_out = scan_in;
1591	}
1592	LogFlowFunc(("scan code %02X translated to %02X; new state is %d\n",
1593	scanIn, scan_out, state));
1594
1595	*pScanOut = scan_out;
1596	return state;
1597	}
1598
1599	#endif /* !VBOX_DEVICE_STRUCT_TESTCASE */

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

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

Download in other formats: