VirtualBox

source: vbox/trunk/src/VBox/Devices/Input/DevPS2K.cpp@ 82204

Last change on this file since 82204 was 82200, checked in by vboxsync, 5 years ago

DevPS2: Critsect. bugref:9218
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 57.6 KB
Line 
1/* $Id: DevPS2K.cpp 82200 2019-11-25 20:55:43Z vboxsync $ */
2/** @file
3 * PS2K - PS/2 keyboard emulation.
4 */
5
6/*
7 * Copyright (C) 2007-2019 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 "DevPS2.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 Modifier key states. Sorted in USB HID code order.
89 * @{ */
90#define MOD_LCTRL 0x01
91#define MOD_LSHIFT 0x02
92#define MOD_LALT 0x04
93#define MOD_LGUI 0x08
94#define MOD_RCTRL 0x10
95#define MOD_RSHIFT 0x20
96#define MOD_RALT 0x40
97#define MOD_RGUI 0x80
98/** @} */
99
100/* Default typematic value. */
101#define KBD_DFL_RATE_DELAY 0x2B
102
103/* Input throttling delay in milliseconds. */
104#define KBD_THROTTLE_DELAY 1
105
106
107/*********************************************************************************************************************************
108* Structures and Typedefs *
109*********************************************************************************************************************************/
110/* Key type flags. */
111#define KF_E0 0x01 /* E0 prefix. */
112#define KF_NB 0x02 /* No break code. */
113#define KF_GK 0x04 /* Gray navigation key. */
114#define KF_PS 0x08 /* Print Screen key. */
115#define KF_PB 0x10 /* Pause/Break key. */
116#define KF_NL 0x20 /* Num Lock key. */
117#define KF_NS 0x40 /* NumPad '/' key. */
118
119/* Scan Set 3 typematic defaults. */
120#define T_U 0x00 /* Unknown value. */
121#define T_T 0x01 /* Key is typematic. */
122#define T_M 0x02 /* Key is make only. */
123#define T_B 0x04 /* Key is make/break. */
124
125/* Special key values. */
126#define NONE 0x93 /* No PS/2 scan code returned. */
127#define UNAS 0x94 /* No PS/2 scan assigned to key. */
128#define RSVD 0x95 /* Reserved, do not use. */
129#define UNKN 0x96 /* Translation unknown. */
130
131/* Key definition structure. */
132typedef struct {
133 uint8_t makeS1; /* Set 1 make code. */
134 uint8_t makeS2; /* Set 2 make code. */
135 uint8_t makeS3; /* Set 3 make code. */
136 uint8_t keyFlags; /* Key flags. */
137 uint8_t keyMatic; /* Set 3 typematic default. */
138} key_def;
139
140
141/*********************************************************************************************************************************
142* Global Variables *
143*********************************************************************************************************************************/
144#ifdef IN_RING3
145/* USB to PS/2 conversion table for regular keys (HID Usage Page 7). */
146static const key_def aPS2Keys[] = {
147 /* 00 */ {NONE, NONE, NONE, KF_NB, T_U }, /* Key N/A: No Event */
148 /* 01 */ {0xFF, 0x00, 0x00, KF_NB, T_U }, /* Key N/A: Overrun Error */
149 /* 02 */ {0xFC, 0xFC, 0xFC, KF_NB, T_U }, /* Key N/A: POST Fail */
150 /* 03 */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key N/A: ErrorUndefined */
151 /* 04 */ {0x1E, 0x1C, 0x1C, 0, T_T }, /* Key 31: a A */
152 /* 05 */ {0x30, 0x32, 0x32, 0, T_T }, /* Key 50: b B */
153 /* 06 */ {0x2E, 0x21, 0x21, 0, T_T }, /* Key 48: c C */
154 /* 07 */ {0x20, 0x23, 0x23, 0, T_T }, /* Key 33: d D */
155 /* 08 */ {0x12, 0x24, 0x24, 0, T_T }, /* Key 19: e E */
156 /* 09 */ {0x21, 0x2B, 0x2B, 0, T_T }, /* Key 34: f F */
157 /* 0A */ {0x22, 0x34, 0x34, 0, T_T }, /* Key 35: g G */
158 /* 0B */ {0x23, 0x33, 0x33, 0, T_T }, /* Key 36: h H */
159 /* 0C */ {0x17, 0x43, 0x43, 0, T_T }, /* Key 24: i I */
160 /* 0D */ {0x24, 0x3B, 0x3B, 0, T_T }, /* Key 37: j J */
161 /* 0E */ {0x25, 0x42, 0x42, 0, T_T }, /* Key 38: k K */
162 /* 0F */ {0x26, 0x4B, 0x4B, 0, T_T }, /* Key 39: l L */
163 /* 10 */ {0x32, 0x3A, 0x3A, 0, T_T }, /* Key 52: m M */
164 /* 11 */ {0x31, 0x31, 0x31, 0, T_T }, /* Key 51: n N */
165 /* 12 */ {0x18, 0x44, 0x44, 0, T_T }, /* Key 25: o O */
166 /* 13 */ {0x19, 0x4D, 0x4D, 0, T_T }, /* Key 26: p P */
167 /* 14 */ {0x10, 0x15, 0x15, 0, T_T }, /* Key 17: q Q */
168 /* 15 */ {0x13, 0x2D, 0x2D, 0, T_T }, /* Key 20: r R */
169 /* 16 */ {0x1F, 0x1B, 0x1B, 0, T_T }, /* Key 32: s S */
170 /* 17 */ {0x14, 0x2C, 0x2C, 0, T_T }, /* Key 21: t T */
171 /* 18 */ {0x16, 0x3C, 0x3C, 0, T_T }, /* Key 23: u U */
172 /* 19 */ {0x2F, 0x2A, 0x2A, 0, T_T }, /* Key 49: v V */
173 /* 1A */ {0x11, 0x1D, 0x1D, 0, T_T }, /* Key 18: w W */
174 /* 1B */ {0x2D, 0x22, 0x22, 0, T_T }, /* Key 47: x X */
175 /* 1C */ {0x15, 0x35, 0x35, 0, T_T }, /* Key 22: y Y */
176 /* 1D */ {0x2C, 0x1A, 0x1A, 0, T_T }, /* Key 46: z Z */
177 /* 1E */ {0x02, 0x16, 0x16, 0, T_T }, /* Key 2: 1 ! */
178 /* 1F */ {0x03, 0x1E, 0x1E, 0, T_T }, /* Key 3: 2 @ */
179 /* 20 */ {0x04, 0x26, 0x26, 0, T_T }, /* Key 4: 3 # */
180 /* 21 */ {0x05, 0x25, 0x25, 0, T_T }, /* Key 5: 4 $ */
181 /* 22 */ {0x06, 0x2E, 0x2E, 0, T_T }, /* Key 6: 5 % */
182 /* 23 */ {0x07, 0x36, 0x36, 0, T_T }, /* Key 7: 6 ^ */
183 /* 24 */ {0x08, 0x3D, 0x3D, 0, T_T }, /* Key 8: 7 & */
184 /* 25 */ {0x09, 0x3E, 0x3E, 0, T_T }, /* Key 9: 8 * */
185 /* 26 */ {0x0A, 0x46, 0x46, 0, T_T }, /* Key 10: 9 ( */
186 /* 27 */ {0x0B, 0x45, 0x45, 0, T_T }, /* Key 11: 0 ) */
187 /* 28 */ {0x1C, 0x5A, 0x5A, 0, T_T }, /* Key 43: Return */
188 /* 29 */ {0x01, 0x76, 0x08, 0, T_M }, /* Key 110: Escape */
189 /* 2A */ {0x0E, 0x66, 0x66, 0, T_T }, /* Key 15: Backspace */
190 /* 2B */ {0x0F, 0x0D, 0x0D, 0, T_T }, /* Key 16: Tab */
191 /* 2C */ {0x39, 0x29, 0x29, 0, T_T }, /* Key 61: Space */
192 /* 2D */ {0x0C, 0x4E, 0x4E, 0, T_T }, /* Key 12: - _ */
193 /* 2E */ {0x0D, 0x55, 0x55, 0, T_T }, /* Key 13: = + */
194 /* 2F */ {0x1A, 0x54, 0x54, 0, T_T }, /* Key 27: [ { */
195 /* 30 */ {0x1B, 0x5B, 0x5B, 0, T_T }, /* Key 28: ] } */
196 /* 31 */ {0x2B, 0x5D, 0x5C, 0, T_T }, /* Key 29: \ | */
197 /* 32 */ {0x2B, 0x5D, 0x5D, 0, T_T }, /* Key 42: Europe 1 (Note 2) */
198 /* 33 */ {0x27, 0x4C, 0x4C, 0, T_T }, /* Key 40: ; : */
199 /* 34 */ {0x28, 0x52, 0x52, 0, T_T }, /* Key 41: ' " */
200 /* 35 */ {0x29, 0x0E, 0x0E, 0, T_T }, /* Key 1: ` ~ */
201 /* 36 */ {0x33, 0x41, 0x41, 0, T_T }, /* Key 53: , < */
202 /* 37 */ {0x34, 0x49, 0x49, 0, T_T }, /* Key 54: . > */
203 /* 38 */ {0x35, 0x4A, 0x4A, 0, T_T }, /* Key 55: / ? */
204 /* 39 */ {0x3A, 0x58, 0x14, 0, T_B }, /* Key 30: Caps Lock */
205 /* 3A */ {0x3B, 0x05, 0x07, 0, T_M }, /* Key 112: F1 */
206 /* 3B */ {0x3C, 0x06, 0x0F, 0, T_M }, /* Key 113: F2 */
207 /* 3C */ {0x3D, 0x04, 0x17, 0, T_M }, /* Key 114: F3 */
208 /* 3D */ {0x3E, 0x0C, 0x1F, 0, T_M }, /* Key 115: F4 */
209 /* 3E */ {0x3F, 0x03, 0x27, 0, T_M }, /* Key 116: F5 */
210 /* 3F */ {0x40, 0x0B, 0x2F, 0, T_M }, /* Key 117: F6 */
211 /* 40 */ {0x41, 0x83, 0x37, 0, T_M }, /* Key 118: F7 */
212 /* 41 */ {0x42, 0x0A, 0x3F, 0, T_M }, /* Key 119: F8 */
213 /* 42 */ {0x43, 0x01, 0x47, 0, T_M }, /* Key 120: F9 */
214 /* 43 */ {0x44, 0x09, 0x4F, 0, T_M }, /* Key 121: F10 */
215 /* 44 */ {0x57, 0x78, 0x56, 0, T_M }, /* Key 122: F11 */
216 /* 45 */ {0x58, 0x07, 0x5E, 0, T_M }, /* Key 123: F12 */
217 /* 46 */ {0x37, 0x7C, 0x57, KF_PS, T_M }, /* Key 124: Print Screen (Note 1) */
218 /* 47 */ {0x46, 0x7E, 0x5F, 0, T_M }, /* Key 125: Scroll Lock */
219 /* 48 */ {RSVD, RSVD, RSVD, KF_PB, T_M }, /* Key 126: Break (Ctrl-Pause) */
220 /* 49 */ {0x52, 0x70, 0x67, KF_GK, T_M }, /* Key 75: Insert (Note 1) */
221 /* 4A */ {0x47, 0x6C, 0x6E, KF_GK, T_M }, /* Key 80: Home (Note 1) */
222 /* 4B */ {0x49, 0x7D, 0x6F, KF_GK, T_M }, /* Key 85: Page Up (Note 1) */
223 /* 4C */ {0x53, 0x71, 0x64, KF_GK, T_T }, /* Key 76: Delete (Note 1) */
224 /* 4D */ {0x4F, 0x69, 0x65, KF_GK, T_M }, /* Key 81: End (Note 1) */
225 /* 4E */ {0x51, 0x7A, 0x6D, KF_GK, T_M }, /* Key 86: Page Down (Note 1) */
226 /* 4F */ {0x4D, 0x74, 0x6A, KF_GK, T_T }, /* Key 89: Right Arrow (Note 1) */
227 /* 50 */ {0x4B, 0x6B, 0x61, KF_GK, T_T }, /* Key 79: Left Arrow (Note 1) */
228 /* 51 */ {0x50, 0x72, 0x60, KF_GK, T_T }, /* Key 84: Down Arrow (Note 1) */
229 /* 52 */ {0x48, 0x75, 0x63, KF_GK, T_T }, /* Key 83: Up Arrow (Note 1) */
230 /* 53 */ {0x45, 0x77, 0x76, KF_NL, T_M }, /* Key 90: Num Lock */
231 /* 54 */ {0x35, 0x4A, 0x77, KF_NS, T_M }, /* Key 95: Keypad / (Note 1) */
232 /* 55 */ {0x37, 0x7C, 0x7E, 0, T_M }, /* Key 100: Keypad * */
233 /* 56 */ {0x4A, 0x7B, 0x84, 0, T_M }, /* Key 105: Keypad - */
234 /* 57 */ {0x4E, 0x79, 0x7C, 0, T_T }, /* Key 106: Keypad + */
235 /* 58 */ {0x1C, 0x5A, 0x79, KF_E0, T_M }, /* Key 108: Keypad Enter */
236 /* 59 */ {0x4F, 0x69, 0x69, 0, T_M }, /* Key 93: Keypad 1 End */
237 /* 5A */ {0x50, 0x72, 0x72, 0, T_M }, /* Key 98: Keypad 2 Down */
238 /* 5B */ {0x51, 0x7A, 0x7A, 0, T_M }, /* Key 103: Keypad 3 PageDn */
239 /* 5C */ {0x4B, 0x6B, 0x6B, 0, T_M }, /* Key 92: Keypad 4 Left */
240 /* 5D */ {0x4C, 0x73, 0x73, 0, T_M }, /* Key 97: Keypad 5 */
241 /* 5E */ {0x4D, 0x74, 0x74, 0, T_M }, /* Key 102: Keypad 6 Right */
242 /* 5F */ {0x47, 0x6C, 0x6C, 0, T_M }, /* Key 91: Keypad 7 Home */
243 /* 60 */ {0x48, 0x75, 0x75, 0, T_M }, /* Key 96: Keypad 8 Up */
244 /* 61 */ {0x49, 0x7D, 0x7D, 0, T_M }, /* Key 101: Keypad 9 PageUp */
245 /* 62 */ {0x52, 0x70, 0x70, 0, T_M }, /* Key 99: Keypad 0 Insert */
246 /* 63 */ {0x53, 0x71, 0x71, 0, T_M }, /* Key 104: Keypad . Delete */
247 /* 64 */ {0x56, 0x61, 0x13, 0, T_T }, /* Key 45: Europe 2 (Note 2) */
248 /* 65 */ {0x5D, 0x2F, UNKN, KF_E0, T_U }, /* Key 129: App */
249 /* 66 */ {0x5E, 0x37, UNKN, KF_E0, T_U }, /* Key Unk: Keyboard Power */
250 /* 67 */ {0x59, 0x0F, UNKN, 0, T_U }, /* Key Unk: Keypad = */
251 /* 68 */ {0x64, 0x08, UNKN, 0, T_U }, /* Key Unk: F13 */
252 /* 69 */ {0x65, 0x10, UNKN, 0, T_U }, /* Key Unk: F14 */
253 /* 6A */ {0x66, 0x18, UNKN, 0, T_U }, /* Key Unk: F15 */
254 /* 6B */ {0x67, 0x20, UNKN, 0, T_U }, /* Key Unk: F16 */
255 /* 6C */ {0x68, 0x28, UNKN, 0, T_U }, /* Key Unk: F17 */
256 /* 6D */ {0x69, 0x30, UNKN, 0, T_U }, /* Key Unk: F18 */
257 /* 6E */ {0x6A, 0x38, UNKN, 0, T_U }, /* Key Unk: F19 */
258 /* 6F */ {0x6B, 0x40, UNKN, 0, T_U }, /* Key Unk: F20 */
259 /* 70 */ {0x6C, 0x48, UNKN, 0, T_U }, /* Key Unk: F21 */
260 /* 71 */ {0x6D, 0x50, UNKN, 0, T_U }, /* Key Unk: F22 */
261 /* 72 */ {0x6E, 0x57, UNKN, 0, T_U }, /* Key Unk: F23 */
262 /* 73 */ {0x76, 0x5F, UNKN, 0, T_U }, /* Key Unk: F24 */
263 /* 74 */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Execute */
264 /* 75 */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Help */
265 /* 76 */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Menu */
266 /* 77 */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Select */
267 /* 78 */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Stop */
268 /* 79 */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Again */
269 /* 7A */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Undo */
270 /* 7B */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Cut */
271 /* 7C */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Copy */
272 /* 7D */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Paste */
273 /* 7E */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Find */
274 /* 7F */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Mute */
275 /* 80 */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Volume Up */
276 /* 81 */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Volume Dn */
277 /* 82 */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Locking Caps Lock */
278 /* 83 */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Locking Num Lock */
279 /* 84 */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Locking Scroll Lock */
280 /* 85 */ {0x7E, 0x6D, UNKN, 0, T_U }, /* Key Unk: Keypad , (Brazilian Keypad .) */
281 /* 86 */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Equal Sign */
282 /* 87 */ {0x73, 0x51, UNKN, 0, T_U }, /* Key Unk: Keyboard Intl 1 (Ro) */
283 /* 88 */ {0x70, 0x13, UNKN, 0, T_U }, /* Key Unk: Keyboard Intl2 (K'kana/H'gana) */
284 /* 89 */ {0x7D, 0x6A, UNKN, 0, T_U }, /* Key Unk: Keyboard Intl 2 (Yen) */
285 /* 8A */ {0x79, 0x64, UNKN, 0, T_U }, /* Key Unk: Keyboard Intl 4 (Henkan) */
286 /* 8B */ {0x7B, 0x67, UNKN, 0, T_U }, /* Key Unk: Keyboard Intl 5 (Muhenkan) */
287 /* 8C */ {0x5C, 0x27, UNKN, 0, T_U }, /* Key Unk: Keyboard Intl 6 (PC9800 Pad ,) */
288 /* 8D */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Intl 7 */
289 /* 8E */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Intl 8 */
290 /* 8F */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Intl 9 */
291 /* 90 */ {0xF2, 0xF2, UNKN, KF_NB, T_U }, /* Key Unk: Keyboard Lang 1 (Hang'l/Engl) */
292 /* 91 */ {0xF1, 0xF1, UNKN, KF_NB, T_U }, /* Key Unk: Keyboard Lang 2 (Hanja) */
293 /* 92 */ {0x78, 0x63, UNKN, 0, T_U }, /* Key Unk: Keyboard Lang 3 (Katakana) */
294 /* 93 */ {0x77, 0x62, UNKN, 0, T_U }, /* Key Unk: Keyboard Lang 4 (Hiragana) */
295 /* 94 */ {0x76, 0x5F, UNKN, 0, T_U }, /* Key Unk: Keyboard Lang 5 (Zen/Han) */
296 /* 95 */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Lang 6 */
297 /* 96 */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Lang 7 */
298 /* 97 */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Lang 8 */
299 /* 98 */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Lang 9 */
300 /* 99 */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Alternate Erase */
301 /* 9A */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard SysReq/Attention (Note 3) */
302 /* 9B */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Cancel */
303 /* 9C */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Clear */
304 /* 9D */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Prior */
305 /* 9E */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Return */
306 /* 9F */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Separator */
307 /* A0 */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Out */
308 /* A1 */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Oper */
309 /* A2 */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard Clear/Again */
310 /* A3 */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard CrSel/Props */
311 /* A4 */ {UNAS, UNAS, UNAS, 0, T_U }, /* Key Unk: Keyboard ExSel */
312};
313
314/*
315 * Note 1: The behavior of these keys depends on the state of modifier keys
316 * at the time the key was pressed.
317 *
318 * Note 2: The key label depends on the national version of the keyboard.
319 *
320 * Note 3: Certain keys which have their own PS/2 scancodes do not exist on
321 * USB keyboards; the SysReq key is an example. The SysReq key scancode needs
322 * to be translated to the Print Screen HID usage code. The HID usage to PS/2
323 * scancode conversion then generates the correct sequence depending on the
324 * keyboard state.
325 */
326
327/* USB to PS/2 conversion table for modifier keys (HID Usage Page 7). */
328static const key_def aPS2ModKeys[] = {
329 /* E0 */ {0x1D, 0x14, 0x11, 0, T_B }, /* Key 58: Left Control */
330 /* E1 */ {0x2A, 0x12, 0x12, 0, T_B }, /* Key 44: Left Shift */
331 /* E2 */ {0x38, 0x11, 0x19, 0, T_B }, /* Key 60: Left Alt */
332 /* E3 */ {0x5B, 0x1F, UNKN, KF_E0, T_U }, /* Key 127: Left GUI */
333 /* E4 */ {0x1D, 0x14, 0x58, KF_E0, T_M }, /* Key 64: Right Control */
334 /* E5 */ {0x36, 0x59, 0x59, 0, T_B }, /* Key 57: Right Shift */
335 /* E6 */ {0x38, 0x11, 0x39, KF_E0, T_M }, /* Key 62: Right Alt */
336 /* E7 */ {0x5C, 0x27, UNKN, KF_E0, T_U }, /* Key 128: Right GUI */
337};
338
339/* Extended key definition for sparse mapping. */
340typedef struct {
341 uint16_t usageId;
342 key_def kdef;
343} ext_key_def;
344
345
346/* USB to PS/2 conversion table for consumer control keys (HID Usage Page 12). */
347/* This usage page is very sparse so we'll just search through it. */
348static const ext_key_def aPS2CCKeys[] = {
349 {0x00B5, {0x19, 0x4D, UNKN, KF_E0, T_U}}, /* Scan Next Track */
350 {0x00B6, {0x10, 0x15, UNKN, KF_E0, T_U}}, /* Scan Previous Track */
351 {0x00B7, {0x24, 0x3B, UNKN, KF_E0, T_U}}, /* Stop */
352 {0x00CD, {0x22, 0x34, UNKN, KF_E0, T_U}}, /* Play/Pause */
353 {0x00E2, {0x20, 0x23, UNKN, KF_E0, T_U}}, /* Mute */
354 {0x00E5, {UNAS, UNAS, UNAS, 0, T_U}}, /* Bass Boost */
355 {0x00E7, {UNAS, UNAS, UNAS, 0, T_U}}, /* Loudness */
356 {0x00E9, {0x30, 0x32, UNKN, KF_E0, T_U}}, /* Volume Up */
357 {0x00EA, {0x2E, 0x21, UNKN, KF_E0, T_U}}, /* Volume Down */
358 {0x0152, {UNAS, UNAS, UNAS, 0, T_U}}, /* Bass Up */
359 {0x0153, {UNAS, UNAS, UNAS, 0, T_U}}, /* Bass Down */
360 {0x0154, {UNAS, UNAS, UNAS, 0, T_U}}, /* Treble Up */
361 {0x0155, {UNAS, UNAS, UNAS, 0, T_U}}, /* Treble Down */
362 {0x0183, {0x6D, 0x50, UNKN, KF_E0, T_U}}, /* Media Select */
363 {0x018A, {0x6C, 0x48, UNKN, KF_E0, T_U}}, /* Mail */
364 {0x0192, {0x21, 0x2B, UNKN, KF_E0, T_U}}, /* Calculator */
365 {0x0194, {0x6B, 0x40, UNKN, KF_E0, T_U}}, /* My Computer */
366 {0x0221, {0x65, 0x10, UNKN, KF_E0, T_U}}, /* WWW Search */
367 {0x0223, {0x32, 0x3A, UNKN, KF_E0, T_U}}, /* WWW Home */
368 {0x0224, {0x6A, 0x38, UNKN, KF_E0, T_U}}, /* WWW Back */
369 {0x0225, {0x69, 0x30, UNKN, KF_E0, T_U}}, /* WWW Forward */
370 {0x0226, {0x68, 0x28, UNKN, KF_E0, T_U}}, /* WWW Stop */
371 {0x0227, {0x67, 0x20, UNKN, KF_E0, T_U}}, /* WWW Refresh */
372 {0x022A, {0x66, 0x18, UNKN, KF_E0, T_U}}, /* WWW Favorites */
373};
374
375#endif /* IN_RING3 */
376
377#ifdef IN_RING3
378
379/**
380 * Add a null-terminated byte sequence to a queue if there is enough room.
381 *
382 * @param pQ Pointer to the queue.
383 * @param pStr Pointer to the bytes to store.
384 * @param uReserve Number of bytes that must still remain
385 * available in queue.
386 * @return int VBox status/error code.
387 */
388static int ps2kR3InsertStrQueue(GeneriQ *pQ, const uint8_t *pStr, uint32_t uReserve)
389{
390 uint32_t cbStr;
391 unsigned i;
392
393 cbStr = (uint32_t)strlen((const char *)pStr);
394
395 /* Check if queue has enough room. */
396 if (pQ->cUsed + uReserve + cbStr >= pQ->cSize)
397 {
398 LogRelFlowFunc(("queue %p full (%u entries, want room for %u), cannot insert %u entries\n",
399 pQ, pQ->cUsed, uReserve, cbStr));
400 return VERR_BUFFER_OVERFLOW;
401 }
402
403 /* Insert byte sequence and update circular buffer write position. */
404 for (i = 0; i < cbStr; ++i) {
405 pQ->abQueue[pQ->wpos] = pStr[i];
406 if (++pQ->wpos == pQ->cSize)
407 pQ->wpos = 0; /* Roll over. */
408 }
409 pQ->cUsed += cbStr;
410 LogRelFlowFunc(("inserted %u bytes into queue %p\n", cbStr, pQ));
411 return VINF_SUCCESS;
412}
413
414/**
415 * Notify listener about LEDs state change.
416 *
417 * @param pThis The PS/2 keyboard instance data.
418 * @param u8State Bitfield which reflects LEDs state.
419 */
420static void ps2kR3NotifyLedsState(PPS2K pThis, uint8_t u8State)
421{
422
423 PDMKEYBLEDS enmLeds = PDMKEYBLEDS_NONE;
424
425 if (u8State & 0x01)
426 enmLeds = (PDMKEYBLEDS)(enmLeds | PDMKEYBLEDS_SCROLLLOCK);
427 if (u8State & 0x02)
428 enmLeds = (PDMKEYBLEDS)(enmLeds | PDMKEYBLEDS_NUMLOCK);
429 if (u8State & 0x04)
430 enmLeds = (PDMKEYBLEDS)(enmLeds | PDMKEYBLEDS_CAPSLOCK);
431
432 pThis->Keyboard.pDrv->pfnLedStatusChange(pThis->Keyboard.pDrv, enmLeds);
433
434}
435
436/**
437 * Query the number of items currently in a queue.
438 *
439 * @param pQ Pointer to the queue.
440 *
441 * @return uint32_t Number of items in queue.
442 */
443static uint32_t ps2R3kInQueue(GeneriQ *pQ)
444{
445 return pQ->cUsed;
446}
447
448#endif /* IN_RING3 */
449
450/** Clears the currently active typematic key, if any. */
451static void ps2kStopTypematicRepeat(PPDMDEVINS pDevIns, PPS2K pThis)
452{
453 if (pThis->u32TypematicKey)
454 {
455 LogFunc(("Typematic key %08X\n", pThis->u32TypematicKey));
456 pThis->enmTypematicState = KBD_TMS_IDLE;
457 pThis->u32TypematicKey = 0;
458 PDMDevHlpTimerStop(pDevIns, pThis->hKbdTypematicTimer);
459 }
460}
461
462/** Convert encoded typematic value to milliseconds. Note that the values are rated
463 * with +/- 20% accuracy, so there's no need for high precision.
464 */
465static void ps2kSetupTypematic(PPS2K pThis, uint8_t val)
466{
467 int A, B;
468 unsigned period;
469
470 pThis->u8TypematicCfg = val;
471 /* The delay is easy: (1 + value) * 250 ms */
472 pThis->uTypematicDelay = (1 + ((val >> 5) & 3)) * 250;
473 /* The rate is more complicated: (8 + A) * 2^B * 4.17 ms */
474 A = val & 7;
475 B = (val >> 3) & 3;
476 period = (8 + A) * (1 << B) * 417 / 100;
477 pThis->uTypematicRepeat = period;
478 Log(("Typematic delay %u ms, repeat period %u ms\n",
479 pThis->uTypematicDelay, pThis->uTypematicRepeat));
480}
481
482static void ps2kSetDefaults(PPDMDEVINS pDevIns, PPS2K pThis)
483{
484 LogFlowFunc(("Set keyboard defaults\n"));
485 PS2CmnClearQueue((GeneriQ *)&pThis->keyQ);
486 /* Set default Scan Set 3 typematic values. */
487 /* Set default typematic rate/delay. */
488 ps2kSetupTypematic(pThis, KBD_DFL_RATE_DELAY);
489 /* Clear last typematic key?? */
490 ps2kStopTypematicRepeat(pDevIns, pThis);
491}
492
493/**
494 * Receive and process a byte sent by the keyboard controller.
495 *
496 * @param pDevIns The device instance.
497 * @param pThis The PS/2 keyboard instance data.
498 * @param cmd The command (or data) byte.
499 */
500int PS2KByteToKbd(PPDMDEVINS pDevIns, PPS2K pThis, uint8_t cmd)
501{
502 bool fHandled = true;
503
504 LogFlowFunc(("new cmd=0x%02X, active cmd=0x%02X\n", cmd, pThis->u8CurrCmd));
505
506 if (pThis->u8CurrCmd == KCMD_RESET)
507 /* In reset mode, do not respond at all. */
508 return VINF_SUCCESS;
509
510 switch (cmd)
511 {
512 case KCMD_ECHO:
513 PS2CmnInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ECHO);
514 pThis->u8CurrCmd = 0;
515 break;
516 case KCMD_READ_ID:
517 PS2CmnInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
518 PS2CmnInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ID1);
519 PS2CmnInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ID2);
520 pThis->u8CurrCmd = 0;
521 break;
522 case KCMD_ENABLE:
523 pThis->fScanning = true;
524 PS2CmnClearQueue((GeneriQ *)&pThis->keyQ);
525 ps2kStopTypematicRepeat(pDevIns, pThis);
526 PS2CmnInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
527 pThis->u8CurrCmd = 0;
528 break;
529 case KCMD_DFLT_DISABLE:
530 pThis->fScanning = false;
531 ps2kSetDefaults(pDevIns, pThis); /* Also clears buffer/typematic state. */
532 PS2CmnInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
533 pThis->u8CurrCmd = 0;
534 break;
535 case KCMD_SET_DEFAULT:
536 ps2kSetDefaults(pDevIns, pThis);
537 PS2CmnInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
538 pThis->u8CurrCmd = 0;
539 break;
540 case KCMD_ALL_TYPEMATIC:
541 case KCMD_ALL_MK_BRK:
542 case KCMD_ALL_MAKE:
543 case KCMD_ALL_TMB:
544 /// @todo Set the key types here.
545 PS2CmnInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
546 pThis->u8CurrCmd = 0;
547 break;
548 case KCMD_RESEND:
549 pThis->u8CurrCmd = 0;
550 break;
551 case KCMD_RESET:
552 pThis->u8ScanSet = 2;
553 ps2kSetDefaults(pDevIns, pThis);
554 /// @todo reset more?
555 PS2CmnInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
556 pThis->u8CurrCmd = cmd;
557 /* Delay BAT completion; the test may take hundreds of ms. */
558 PDMDevHlpTimerSetMillies(pDevIns, pThis->hKbdDelayTimer, 2);
559 break;
560 /* The following commands need a parameter. */
561 case KCMD_LEDS:
562 case KCMD_SCANSET:
563 case KCMD_RATE_DELAY:
564 case KCMD_TYPE_MATIC:
565 case KCMD_TYPE_MK_BRK:
566 case KCMD_TYPE_MAKE:
567 PS2CmnInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
568 pThis->u8CurrCmd = cmd;
569 break;
570 default:
571 /* Sending a command instead of a parameter starts the new command. */
572 switch (pThis->u8CurrCmd)
573 {
574 case KCMD_LEDS:
575#ifndef IN_RING3
576 return VINF_IOM_R3_IOPORT_WRITE;
577#else
578 {
579 ps2kR3NotifyLedsState(pThis, cmd);
580 pThis->fNumLockOn = !!(cmd & 0x02); /* Sync internal Num Lock state. */
581 PS2CmnInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
582 pThis->u8LEDs = cmd;
583 pThis->u8CurrCmd = 0;
584 }
585#endif
586 break;
587 case KCMD_SCANSET:
588 PS2CmnInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
589 if (cmd == 0)
590 PS2CmnInsertQueue((GeneriQ *)&pThis->cmdQ, pThis->u8ScanSet);
591 else if (cmd < 4)
592 {
593 pThis->u8ScanSet = cmd;
594 LogRel(("PS2K: Selected scan set %d\n", cmd));
595 }
596 /* Other values are simply ignored. */
597 pThis->u8CurrCmd = 0;
598 break;
599 case KCMD_RATE_DELAY:
600 ps2kSetupTypematic(pThis, cmd);
601 PS2CmnInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_ACK);
602 pThis->u8CurrCmd = 0;
603 break;
604 default:
605 fHandled = false;
606 }
607 /* Fall through only to handle unrecognized commands. */
608 if (fHandled)
609 break;
610 RT_FALL_THRU();
611
612 case KCMD_INVALID_1:
613 case KCMD_INVALID_2:
614 PS2CmnInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_RESEND);
615 pThis->u8CurrCmd = 0;
616 break;
617 }
618 LogFlowFunc(("Active cmd now 0x%02X; updating interrupts\n", pThis->u8CurrCmd));
619// KBCUpdateInterrupts(pDevIns);
620 return VINF_SUCCESS;
621}
622
623/**
624 * Send a byte (keystroke or command response) to the keyboard controller.
625 *
626 * @returns VINF_SUCCESS or VINF_TRY_AGAIN.
627 * @param pDevIns The device instance.
628 * @param pThis The PS/2 keyboard instance data.
629 * @param pb Where to return the byte we've read.
630 * @remarks Caller must have entered the device critical section.
631 */
632int PS2KByteFromKbd(PPDMDEVINS pDevIns, PPS2K pThis, uint8_t *pb)
633{
634 int rc;
635
636 AssertPtr(pb);
637
638 /* Anything in the command queue has priority over data
639 * in the keystroke queue. Additionally, keystrokes are
640 * blocked if a command is currently in progress, even if
641 * the command queue is empty.
642 */
643 rc = PS2CmnRemoveQueue((GeneriQ *)&pThis->cmdQ, pb);
644 if (rc != VINF_SUCCESS && !pThis->u8CurrCmd && pThis->fScanning)
645 if (!pThis->fThrottleActive)
646 {
647 rc = PS2CmnRemoveQueue((GeneriQ *)&pThis->keyQ, pb);
648 if (pThis->fThrottleEnabled)
649 {
650 pThis->fThrottleActive = true;
651 PDMDevHlpTimerSetMillies(pDevIns, pThis->hThrottleTimer, KBD_THROTTLE_DELAY);
652 }
653 }
654
655 LogFlowFunc(("keyboard sends 0x%02x (%svalid data)\n", *pb, rc == VINF_SUCCESS ? "" : "not "));
656 return rc;
657}
658
659#ifdef IN_RING3
660
661static int ps2kR3ProcessKeyEvent(PPDMDEVINS pDevIns, PPS2K pThis, uint32_t u32HidCode, bool fKeyDown)
662{
663 key_def const *pKeyDef;
664 uint8_t abCodes[16];
665 char *pCodes;
666 size_t cbLeft;
667 uint8_t abScan[2];
668 uint8_t u8HidPage;
669 uint8_t u8HidCode;
670 uint16_t u16HidUsage;
671
672 u8HidPage = RT_LOBYTE(RT_HIWORD(u32HidCode));
673 u16HidUsage = RT_LOWORD(u32HidCode);
674 /* For the keyboard usage page (7) we use a 8-bit code. For other pages we use the full 16-bit ID. */
675 u8HidCode = (u8HidPage == USB_HID_KB_PAGE) ? RT_LOBYTE(u32HidCode) : 0;
676
677 LogFlowFunc(("key %s: page 0x%02x ID 0x%04x (set %d)\n", fKeyDown ? "down" : "up", u8HidPage, u16HidUsage, pThis->u8ScanSet));
678
679 /* Find the key definition in somewhat sparse storage. */
680 if (u8HidPage == USB_HID_KB_PAGE)
681 /* For the standard keyboard usage page, thre are just two arrays. */
682 pKeyDef = u8HidCode >= HID_MODIFIER_FIRST ? &aPS2ModKeys[u8HidCode - HID_MODIFIER_FIRST] : &aPS2Keys[u8HidCode];
683 else if (u8HidPage == USB_HID_CC_PAGE)
684 {
685 /* For the consumer control usage page, we need to search. */
686 unsigned i;
687
688 pKeyDef = &aPS2Keys[0]; /* Dummy no-event key. */
689 for (i = 0; i < RT_ELEMENTS(aPS2CCKeys); ++i)
690 {
691 if (aPS2CCKeys[i].usageId == u16HidUsage)
692 {
693 pKeyDef = &aPS2CCKeys[i].kdef;
694 break;
695 }
696 }
697 }
698 else
699 {
700 LogFlow(("Unsupported HID usage page, ignoring key.\n"));
701 return VINF_SUCCESS;
702 }
703
704 /* Some keys are not processed at all; early return. */
705 if (pKeyDef->makeS1 == NONE)
706 {
707 LogFlow(("Skipping key processing.\n"));
708 return VINF_SUCCESS;
709 }
710
711 /* Handle modifier keys (Ctrl/Alt/Shift/GUI). We need to keep track
712 * of their state in addition to sending the scan code.
713 */
714 if (u8HidCode >= HID_MODIFIER_FIRST)
715 {
716 unsigned mod_bit = 1 << (u8HidCode - HID_MODIFIER_FIRST);
717
718 Assert((u8HidPage == USB_HID_KB_PAGE));
719 Assert((u8HidCode <= HID_MODIFIER_LAST));
720 if (fKeyDown)
721 pThis->u8Modifiers |= mod_bit;
722 else
723 pThis->u8Modifiers &= ~mod_bit;
724 }
725
726 /* Toggle NumLock state. */
727 if ((pKeyDef->keyFlags & KF_NL) && fKeyDown)
728 pThis->fNumLockOn ^= true;
729
730 abCodes[0] = 0;
731 pCodes = (char *)abCodes;
732 cbLeft = sizeof(abCodes);
733
734 if (pThis->u8ScanSet == 1 || pThis->u8ScanSet == 2)
735 {
736 /* The basic scan set 1 and 2 logic is the same, only the scan codes differ.
737 * Since scan set 2 is used almost all the time, that case is handled first.
738 */
739 if (fKeyDown)
740 {
741 /* Process key down event. */
742 if (pKeyDef->keyFlags & KF_PB)
743 {
744 /* Pause/Break sends different data if either Ctrl is held. */
745 if (pThis->u8Modifiers & (MOD_LCTRL | MOD_RCTRL))
746 RTStrCatP(&pCodes, &cbLeft, pThis->u8ScanSet == 2 ?
747 "\xE0\x7E\xE0\xF0\x7E" : "\xE0\x46\xE0\xC6");
748 else
749 RTStrCatP(&pCodes, &cbLeft, pThis->u8ScanSet == 2 ?
750 "\xE1\x14\x77\xE1\xF0\x14\xF0\x77" : "\xE1\x1D\x45\xE1\x9D\xC5");
751 }
752 else if (pKeyDef->keyFlags & KF_PS)
753 {
754 /* Print Screen depends on all of Ctrl, Shift, *and* Alt! */
755 if (pThis->u8Modifiers & (MOD_LALT | MOD_RALT))
756 RTStrCatP(&pCodes, &cbLeft, pThis->u8ScanSet == 2 ?
757 "\x84" : "\x54");
758 else if (pThis->u8Modifiers & (MOD_LSHIFT | MOD_RSHIFT))
759 RTStrCatP(&pCodes, &cbLeft, pThis->u8ScanSet == 2 ?
760 "\xE0\x7C" : "\xE0\x37");
761 else
762 RTStrCatP(&pCodes, &cbLeft, pThis->u8ScanSet == 2 ?
763 "\xE0\x12\xE0\x7C" : "\xE0\x2A\xE0\x37");
764 }
765 else if (pKeyDef->keyFlags & (KF_GK | KF_NS))
766 {
767 /* The numeric pad keys fake Shift presses or releases
768 * depending on Num Lock and Shift key state. The '/'
769 * key behaves in a similar manner but does not depend on
770 * the Num Lock state.
771 */
772 if (!pThis->fNumLockOn || (pKeyDef->keyFlags & KF_NS))
773 {
774 if (pThis->u8Modifiers & MOD_LSHIFT)
775 RTStrCatP(&pCodes, &cbLeft, pThis->u8ScanSet == 2 ?
776 "\xE0\xF0\x12" : "\xE0\xAA");
777 if (pThis->u8Modifiers & MOD_RSHIFT)
778 RTStrCatP(&pCodes, &cbLeft, pThis->u8ScanSet == 2 ?
779 "\xE0\xF0\x59" : "\xE0\xB6");
780 }
781 else
782 {
783 Assert(pThis->fNumLockOn); /* Not for KF_NS! */
784 if ((pThis->u8Modifiers & (MOD_LSHIFT | MOD_RSHIFT)) == 0)
785 RTStrCatP(&pCodes, &cbLeft, pThis->u8ScanSet == 2 ?
786 "\xE0\x12" : "\xE0\x2A");
787 /* Else Shift cancels NumLock, so no prefix! */
788 }
789 }
790
791 /* Standard processing for regular keys only. */
792 abScan[0] = pThis->u8ScanSet == 2 ? pKeyDef->makeS2 : pKeyDef->makeS1;
793 abScan[1] = '\0';
794 if (!(pKeyDef->keyFlags & (KF_PB | KF_PS)))
795 {
796 if (pKeyDef->keyFlags & (KF_E0 | KF_GK | KF_NS))
797 RTStrCatP(&pCodes, &cbLeft, "\xE0");
798 RTStrCatP(&pCodes, &cbLeft, (const char *)abScan);
799 }
800
801 /* Feed the bytes to the queue if there is room. */
802 /// @todo Send overrun code if sequence won't fit?
803 ps2kR3InsertStrQueue((GeneriQ *)&pThis->keyQ, abCodes, 0);
804 }
805 else if (!(pKeyDef->keyFlags & (KF_NB | KF_PB)))
806 {
807 /* Process key up event except for keys which produce none. */
808
809 /* Handle Print Screen release. */
810 if (pKeyDef->keyFlags & KF_PS)
811 {
812 /* Undo faked Print Screen state as needed. */
813 if (pThis->u8Modifiers & (MOD_LALT | MOD_RALT))
814 RTStrCatP(&pCodes, &cbLeft, pThis->u8ScanSet == 2 ?
815 "\xF0\x84" : "\xD4");
816 else if (pThis->u8Modifiers & (MOD_LSHIFT | MOD_RSHIFT))
817 RTStrCatP(&pCodes, &cbLeft, pThis->u8ScanSet == 2 ?
818 "\xE0\xF0\x7C" : "\xE0\xB7");
819 else
820 RTStrCatP(&pCodes, &cbLeft, pThis->u8ScanSet == 2 ?
821 "\xE0\xF0\x7C\xE0\xF0\x12" : "\xE0\xB7\xE0\xAA");
822 }
823 else
824 {
825 /* Process base scan code for less unusual keys. */
826 abScan[0] = pThis->u8ScanSet == 2 ? pKeyDef->makeS2 : pKeyDef->makeS1 | 0x80;
827 abScan[1] = '\0';
828 if (pKeyDef->keyFlags & (KF_E0 | KF_GK | KF_NS))
829 RTStrCatP(&pCodes, &cbLeft, "\xE0");
830 if (pThis->u8ScanSet == 2)
831 RTStrCatP(&pCodes, &cbLeft, "\xF0");
832 RTStrCatP(&pCodes, &cbLeft, (const char *)abScan);
833
834 /* Restore shift state for gray keys. */
835 if (pKeyDef->keyFlags & (KF_GK | KF_NS))
836 {
837 if (!pThis->fNumLockOn || (pKeyDef->keyFlags & KF_NS))
838 {
839 if (pThis->u8Modifiers & MOD_LSHIFT)
840 RTStrCatP(&pCodes, &cbLeft, pThis->u8ScanSet == 2 ?
841 "\xE0\x12" : "\xE0\x2A");
842 if (pThis->u8Modifiers & MOD_RSHIFT)
843 RTStrCatP(&pCodes, &cbLeft, pThis->u8ScanSet == 2 ?
844 "\xE0\x59" : "\xE0\x36");
845 }
846 else
847 {
848 Assert(pThis->fNumLockOn); /* Not for KF_NS! */
849 if ((pThis->u8Modifiers & (MOD_LSHIFT | MOD_RSHIFT)) == 0)
850 RTStrCatP(&pCodes, &cbLeft, pThis->u8ScanSet == 2 ?
851 "\xE0\xF0\x12" : "\xE0\xAA");
852 }
853 }
854 }
855
856 /* Feed the bytes to the queue if there is room. */
857 /// @todo Send overrun code if sequence won't fit?
858 ps2kR3InsertStrQueue((GeneriQ *)&pThis->keyQ, abCodes, 0);
859 }
860 }
861 else
862 {
863 /* Handle Scan Set 3 - very straightforward. */
864 Assert(pThis->u8ScanSet == 3);
865 abScan[0] = pKeyDef->makeS3;
866 abScan[1] = '\0';
867 if (fKeyDown)
868 {
869 RTStrCatP(&pCodes, &cbLeft, (const char *)abScan);
870 }
871 else
872 {
873 /* Send a key release code unless it's a make only key. */
874 /// @todo Look up the current typematic setting, not the default!
875 if (pKeyDef->keyMatic != T_M)
876 {
877 RTStrCatP(&pCodes, &cbLeft, "\xF0");
878 RTStrCatP(&pCodes, &cbLeft, (const char *)abScan);
879 }
880 }
881 /* Feed the bytes to the queue if there is room. */
882 /// @todo Send overrun code if sequence won't fit?
883 ps2kR3InsertStrQueue((GeneriQ *)&pThis->keyQ, abCodes, 0);
884 }
885
886 /* Set up or cancel typematic key repeat. For keyboard usage page only. */
887 if (u8HidPage == USB_HID_KB_PAGE)
888 {
889 if (fKeyDown)
890 {
891 if (pThis->u32TypematicKey != u32HidCode)
892 {
893 pThis->enmTypematicState = KBD_TMS_DELAY;
894 pThis->u32TypematicKey = u32HidCode;
895 PDMDevHlpTimerSetMillies(pDevIns, pThis->hKbdTypematicTimer, pThis->uTypematicDelay);
896 Log(("Typematic delay %u ms, key %08X\n", pThis->uTypematicDelay, u32HidCode));
897 }
898 }
899 else
900 {
901 /* "Typematic operation stops when the last key pressed is released, even
902 * if other keys are still held down." (IBM PS/2 Tech Ref). The last key pressed
903 * is the one that's being repeated.
904 */
905 if (pThis->u32TypematicKey == u32HidCode)
906 {
907 /* This disables the typematic repeat. */
908 pThis->u32TypematicKey = 0;
909 pThis->enmTypematicState = KBD_TMS_IDLE;
910 /* For good measure, we cancel the timer, too. */
911 PDMDevHlpTimerStop(pDevIns, pThis->hKbdTypematicTimer);
912 Log(("Typematic action cleared for key %08X\n", u32HidCode));
913 }
914 }
915 }
916
917 /* Poke the KBC to update its state. */
918 KBCUpdateInterrupts(pDevIns);
919
920 return VINF_SUCCESS;
921}
922
923/**
924 * @callback_function_impl{FNTMTIMERDEV}
925 *
926 * Throttling timer to emulate the finite keyboard communication speed. A PS/2 keyboard is
927 * limited by the serial link speed and cannot send much more than 1,000 bytes per second.
928 * Some software (notably Borland Pascal and programs built with its run-time) relies on
929 * being able to read an incoming scan-code twice. Throttling the data rate enables such
930 * software to function, while human typists cannot tell any difference.
931 *
932 * Note: The throttling is currently only done for keyboard data, not command responses.
933 * The throttling could and perhaps should be done for any data (including command
934 * response) scoming from PS/2 devices, both keyboard and auxiliary. That is not currently
935 * done because it would needlessly slow things down.
936 */
937static DECLCALLBACK(void) ps2kR3ThrottleTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
938{
939 RT_NOREF(pDevIns, pTimer);
940 PPS2K pThis = (PS2K *)pvUser;
941 unsigned uHaveData;
942
943 /* Grab the lock to avoid races with event delivery or EMTs. */
944 int rc = PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_SEM_BUSY);
945 AssertReleaseRC(rc);
946
947 /* If data is available, poke the KBC. Once the data
948 * is actually read, the timer may be re-triggered.
949 */
950 pThis->fThrottleActive = false;
951 uHaveData = ps2R3kInQueue((GeneriQ *)&pThis->keyQ);
952 LogFlowFunc(("Have%s bytes\n", uHaveData ? "" : " no"));
953 if (uHaveData)
954 KBCUpdateInterrupts(pDevIns);
955
956 PDMDevHlpCritSectLeave(pDevIns, pDevIns->pCritSectRoR3);
957}
958
959/**
960 * @callback_function_impl{FNTMTIMERDEV,
961 * Timer handler for emulating typematic keys.}
962 *
963 * @note Note that only the last key held down repeats (if typematic).
964 */
965static DECLCALLBACK(void) ps2kR3TypematicTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
966{
967 RT_NOREF(pDevIns, pTimer);
968 PPS2K pThis = (PS2K *)pvUser;
969 LogFlowFunc(("Typematic state=%d, key %08X\n", pThis->enmTypematicState, pThis->u32TypematicKey));
970
971 /* If the current typematic key is zero, the repeat was canceled just when
972 * the timer was about to run. In that case, do nothing.
973 */
974 if (pThis->u32TypematicKey)
975 {
976 if (pThis->enmTypematicState == KBD_TMS_DELAY)
977 pThis->enmTypematicState = KBD_TMS_REPEAT;
978
979 if (pThis->enmTypematicState == KBD_TMS_REPEAT)
980 {
981 ps2kR3ProcessKeyEvent(pDevIns, pThis, pThis->u32TypematicKey, true /* Key down */ );
982 PDMDevHlpTimerSetMillies(pDevIns, pThis->hKbdTypematicTimer, pThis->uTypematicRepeat);
983 }
984 }
985}
986
987/**
988 * @callback_function_impl{FNTMTIMERDEV}
989 *
990 * The keyboard BAT is specified to take several hundred milliseconds. We need
991 * to delay sending the result to the host for at least a tiny little while.
992 */
993static DECLCALLBACK(void) ps2kR3DelayTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
994{
995 RT_NOREF(pDevIns, pTimer);
996 PPS2K pThis = (PS2K *)pvUser;
997
998 LogFlowFunc(("Delay timer: cmd %02X\n", pThis->u8CurrCmd));
999
1000 AssertMsg(pThis->u8CurrCmd == KCMD_RESET, ("u8CurrCmd=%02x\n", pThis->u8CurrCmd));
1001 PS2CmnInsertQueue((GeneriQ *)&pThis->cmdQ, KRSP_BAT_OK);
1002 pThis->fScanning = true; /* BAT completion enables scanning! */
1003 pThis->u8CurrCmd = 0;
1004
1005 /// @todo Might want a PS2KCompleteCommand() to push last response, clear command, and kick the KBC...
1006 /* Give the KBC a kick. */
1007 KBCUpdateInterrupts(pDevIns);
1008}
1009
1010/* Release any and all currently depressed keys. Used whenever the guest keyboard
1011 * is likely to be out of sync with the host, such as when loading a saved state
1012 * or resuming a suspended host.
1013 */
1014static void ps2kR3ReleaseKeys(PPDMDEVINS pDevIns, PPS2K pThis)
1015{
1016 LogFlowFunc(("Releasing keys...\n"));
1017
1018 for (unsigned uKey = 0; uKey < sizeof(pThis->abDepressedKeys); ++uKey)
1019 if (pThis->abDepressedKeys[uKey])
1020 {
1021 ps2kR3ProcessKeyEvent(pDevIns, pThis, RT_MAKE_U32(USB_HID_KB_PAGE, uKey), false /* key up */);
1022 pThis->abDepressedKeys[uKey] = 0;
1023 }
1024 LogFlowFunc(("Done releasing keys\n"));
1025}
1026
1027
1028/**
1029 * Debug device info handler. Prints basic keyboard state.
1030 *
1031 * @param pDevIns Device instance which registered the info.
1032 * @param pHlp Callback functions for doing output.
1033 * @param pszArgs Argument string. Optional and specific to the handler.
1034 */
1035static DECLCALLBACK(void) ps2kR3InfoState(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
1036{
1037 PPS2K pThis = KBDGetPS2KFromDevIns(pDevIns);
1038 NOREF(pszArgs);
1039
1040 pHlp->pfnPrintf(pHlp, "PS/2 Keyboard: scan set %d, scanning %s\n",
1041 pThis->u8ScanSet, pThis->fScanning ? "enabled" : "disabled");
1042 pHlp->pfnPrintf(pHlp, "Active command %02X\n", pThis->u8CurrCmd);
1043 pHlp->pfnPrintf(pHlp, "LED state %02X, Num Lock %s\n", pThis->u8LEDs,
1044 pThis->fNumLockOn ? "on" : "off");
1045 pHlp->pfnPrintf(pHlp, "Typematic delay %ums, repeat period %ums\n",
1046 pThis->uTypematicDelay, pThis->uTypematicRepeat);
1047 pHlp->pfnPrintf(pHlp, "Command queue: %d items (%d max)\n",
1048 pThis->cmdQ.cUsed, pThis->cmdQ.cSize);
1049 pHlp->pfnPrintf(pHlp, "Input queue : %d items (%d max)\n",
1050 pThis->keyQ.cUsed, pThis->keyQ.cSize);
1051 if (pThis->enmTypematicState != KBD_TMS_IDLE)
1052 pHlp->pfnPrintf(pHlp, "Active typematic key %08X (%s)\n", pThis->u32TypematicKey,
1053 pThis->enmTypematicState == KBD_TMS_DELAY ? "delay" : "repeat");
1054}
1055
1056/* -=-=-=-=-=- Keyboard: IBase -=-=-=-=-=- */
1057
1058/**
1059 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
1060 */
1061static DECLCALLBACK(void *) ps2kR3QueryInterface(PPDMIBASE pInterface, const char *pszIID)
1062{
1063 PPS2K pThis = RT_FROM_MEMBER(pInterface, PS2K, Keyboard.IBase);
1064 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->Keyboard.IBase);
1065 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIKEYBOARDPORT, &pThis->Keyboard.IPort);
1066 return NULL;
1067}
1068
1069
1070/* -=-=-=-=-=- Keyboard: IKeyboardPort -=-=-=-=-=- */
1071
1072/**
1073 * Keyboard event handler.
1074 *
1075 * @returns VBox status code.
1076 * @param pDevIns The device instance.
1077 * @param pThis The PS2 keyboard instance data.
1078 * @param u32Usage USB HID usage code with key press/release flag.
1079 */
1080static int ps2kR3PutEventWorker(PPDMDEVINS pDevIns, PPS2K pThis, uint32_t u32Usage)
1081{
1082 uint32_t u32HidCode;
1083 uint8_t u8KeyCode;
1084 uint8_t u8HidPage;
1085 bool fKeyDown;
1086 bool fHaveEvent = true;
1087 int rc = VINF_SUCCESS;
1088
1089 /* Extract the usage page and ID and ensure it's valid. */
1090 fKeyDown = !(u32Usage & 0x80000000);
1091 u32HidCode = u32Usage & 0xFFFFFF;
1092 u8HidPage = RT_LOBYTE(RT_HIWORD(u32Usage));
1093 u8KeyCode = RT_LOBYTE(u32Usage);
1094 if (u8HidPage == USB_HID_KB_PAGE)
1095 AssertReturn(u8KeyCode <= VBOX_USB_MAX_USAGE_CODE, VERR_INTERNAL_ERROR);
1096 else
1097 AssertReturn(u8HidPage == USB_HID_CC_PAGE, VERR_INTERNAL_ERROR);
1098
1099 if (fKeyDown)
1100 {
1101 /* Due to host key repeat, we can get key events for keys which are
1102 * already depressed. We need to ignore those. */
1103 if (pThis->abDepressedKeys[u8KeyCode])
1104 fHaveEvent = false;
1105 pThis->abDepressedKeys[u8KeyCode] = 1;
1106 }
1107 else
1108 {
1109 /* NB: We allow key release events for keys which aren't depressed.
1110 * That is unlikely to happen and should not cause trouble.
1111 */
1112 pThis->abDepressedKeys[u8KeyCode] = 0;
1113 }
1114
1115 /* Unless this is a new key press/release, don't even bother. */
1116 if (fHaveEvent)
1117 {
1118 Assert(PDMDevHlpCritSectIsOwner(pDevIns, pDevIns->pCritSectRoR3));
1119 rc = ps2kR3ProcessKeyEvent(pDevIns, pThis, u32HidCode, fKeyDown);
1120 }
1121
1122 return rc;
1123}
1124
1125
1126/**
1127 * @interface_method_impl{PDMIKEYBOARDPORT,pfnPutEventHid}
1128 */
1129static DECLCALLBACK(int) ps2kR3KeyboardPort_PutEventHid(PPDMIKEYBOARDPORT pInterface, uint32_t u32UsageCode)
1130{
1131 PPS2K pThis = RT_FROM_MEMBER(pInterface, PS2K, Keyboard.IPort);
1132 PPDMDEVINS pDevIns = pThis->pDevIns;
1133 int rc;
1134
1135 LogRelFlowFunc(("key code %08X\n", u32UsageCode));
1136
1137 rc = PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_SEM_BUSY);
1138 AssertReleaseRC(rc);
1139
1140 /* The 'BAT fail' scancode is reused as a signal to release keys. No actual
1141 * key is allowed to use this scancode.
1142 */
1143 if (RT_LIKELY(u32UsageCode != KRSP_BAT_FAIL))
1144 ps2kR3PutEventWorker(pDevIns, pThis, u32UsageCode);
1145 else
1146 ps2kR3ReleaseKeys(pDevIns, pThis);
1147
1148 PDMDevHlpCritSectLeave(pDevIns, pDevIns->pCritSectRoR3);
1149
1150 return VINF_SUCCESS;
1151}
1152
1153
1154/* -=-=-=-=-=- Device management -=-=-=-=-=- */
1155
1156/**
1157 * Attach command.
1158 *
1159 * This is called to let the device attach to a driver for a
1160 * specified LUN.
1161 *
1162 * This is like plugging in the keyboard after turning on the
1163 * system.
1164 *
1165 * @returns VBox status code.
1166 * @param pThis The PS/2 keyboard instance data.
1167 * @param pDevIns The device instance.
1168 * @param iLUN The logical unit which is being detached.
1169 * @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
1170 */
1171int PS2KR3Attach(PPS2K pThis, PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
1172{
1173 int rc;
1174
1175 /* The LUN must be 0, i.e. keyboard. */
1176 Assert(iLUN == 0);
1177 AssertMsgReturn(fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG,
1178 ("PS/2 keyboard does not support hotplugging\n"),
1179 VERR_INVALID_PARAMETER);
1180
1181 LogFlowFunc(("iLUN=%d\n", iLUN));
1182
1183 rc = PDMDevHlpDriverAttach(pDevIns, iLUN, &pThis->Keyboard.IBase, &pThis->Keyboard.pDrvBase, "Keyboard Port");
1184 if (RT_SUCCESS(rc))
1185 {
1186 pThis->Keyboard.pDrv = PDMIBASE_QUERY_INTERFACE(pThis->Keyboard.pDrvBase, PDMIKEYBOARDCONNECTOR);
1187 if (!pThis->Keyboard.pDrv)
1188 {
1189 AssertLogRelMsgFailed(("LUN #0 doesn't have a keyboard interface! rc=%Rrc\n", rc));
1190 rc = VERR_PDM_MISSING_INTERFACE;
1191 }
1192 }
1193 else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
1194 {
1195 Log(("%s/%d: warning: no driver attached to LUN #0!\n", pDevIns->pReg->szName, pDevIns->iInstance));
1196 rc = VINF_SUCCESS;
1197 }
1198 else
1199 AssertLogRelMsgFailed(("Failed to attach LUN #0! rc=%Rrc\n", rc));
1200
1201 return rc;
1202}
1203
1204void PS2KR3SaveState(PPDMDEVINS pDevIns, PPS2K pThis, PSSMHANDLE pSSM)
1205{
1206 PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
1207 uint32_t cPressed = 0;
1208 uint32_t cbTMSSize = 0;
1209
1210 LogFlowFunc(("Saving PS2K state\n"));
1211
1212 /* Save the basic keyboard state. */
1213 pHlp->pfnSSMPutU8(pSSM, pThis->u8CurrCmd);
1214 pHlp->pfnSSMPutU8(pSSM, pThis->u8LEDs);
1215 pHlp->pfnSSMPutU8(pSSM, pThis->u8TypematicCfg);
1216 pHlp->pfnSSMPutU8(pSSM, (uint8_t)pThis->u32TypematicKey);
1217 pHlp->pfnSSMPutU8(pSSM, pThis->u8Modifiers);
1218 pHlp->pfnSSMPutU8(pSSM, pThis->u8ScanSet);
1219 pHlp->pfnSSMPutU8(pSSM, pThis->enmTypematicState);
1220 pHlp->pfnSSMPutBool(pSSM, pThis->fNumLockOn);
1221 pHlp->pfnSSMPutBool(pSSM, pThis->fScanning);
1222
1223 /* Save the command and keystroke queues. */
1224 PS2CmnR3SaveQueue(pHlp, pSSM, (GeneriQ *)&pThis->cmdQ);
1225 PS2CmnR3SaveQueue(pHlp, pSSM, (GeneriQ *)&pThis->keyQ);
1226
1227 /* Save the command delay timer. Note that the typematic repeat
1228 * timer is *not* saved.
1229 */
1230 PDMDevHlpTimerSave(pDevIns, pThis->hKbdDelayTimer, pSSM);
1231
1232 /* Save any pressed keys. This is necessary to avoid "stuck"
1233 * keys after a restore. Needs two passes.
1234 */
1235 for (unsigned i = 0; i < sizeof(pThis->abDepressedKeys); ++i)
1236 if (pThis->abDepressedKeys[i])
1237 ++cPressed;
1238
1239 pHlp->pfnSSMPutU32(pSSM, cPressed);
1240
1241 for (unsigned uKey = 0; uKey < sizeof(pThis->abDepressedKeys); ++uKey)
1242 if (pThis->abDepressedKeys[uKey])
1243 pHlp->pfnSSMPutU8(pSSM, uKey);
1244
1245 /* Save the typematic settings for Scan Set 3. */
1246 pHlp->pfnSSMPutU32(pSSM, cbTMSSize);
1247 /* Currently not implemented. */
1248}
1249
1250int PS2KR3LoadState(PPDMDEVINS pDevIns, PPS2K pThis, PSSMHANDLE pSSM, uint32_t uVersion)
1251{
1252 PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
1253 uint8_t u8;
1254 uint32_t cPressed;
1255 uint32_t cbTMSSize;
1256 int rc;
1257
1258 NOREF(uVersion);
1259 LogFlowFunc(("Loading PS2K state version %u\n", uVersion));
1260
1261 /* Load the basic keyboard state. */
1262 pHlp->pfnSSMGetU8(pSSM, &pThis->u8CurrCmd);
1263 pHlp->pfnSSMGetU8(pSSM, &pThis->u8LEDs);
1264 pHlp->pfnSSMGetU8(pSSM, &pThis->u8TypematicCfg);
1265 pHlp->pfnSSMGetU8(pSSM, &u8);
1266 /* Reconstruct the 32-bit code from the 8-bit value in saved state. */
1267 pThis->u32TypematicKey = u8 ? RT_MAKE_U32(USB_HID_KB_PAGE, u8) : 0;
1268 pHlp->pfnSSMGetU8(pSSM, &pThis->u8Modifiers);
1269 pHlp->pfnSSMGetU8(pSSM, &pThis->u8ScanSet);
1270 pHlp->pfnSSMGetU8(pSSM, &u8);
1271 pThis->enmTypematicState = (tmatic_state_t)u8;
1272 pHlp->pfnSSMGetBool(pSSM, &pThis->fNumLockOn);
1273 pHlp->pfnSSMGetBool(pSSM, &pThis->fScanning);
1274
1275 /* Load the command and keystroke queues. */
1276 rc = PS2CmnR3LoadQueue(pHlp, pSSM, (GeneriQ *)&pThis->cmdQ);
1277 AssertRCReturn(rc, rc);
1278 rc = PS2CmnR3LoadQueue(pHlp, pSSM, (GeneriQ *)&pThis->keyQ);
1279 AssertRCReturn(rc, rc);
1280
1281 /* Load the command delay timer, just in case. */
1282 rc = PDMDevHlpTimerLoad(pDevIns, pThis->hKbdDelayTimer, pSSM);
1283 AssertRCReturn(rc, rc);
1284
1285 /* Recalculate the typematic delay/rate. */
1286 ps2kSetupTypematic(pThis, pThis->u8TypematicCfg);
1287
1288 /* Fake key up events for keys that were held down at the time the state was saved. */
1289 rc = pHlp->pfnSSMGetU32(pSSM, &cPressed);
1290 AssertRCReturn(rc, rc);
1291
1292 /* If any keys were down, load and then release them. */
1293 if (cPressed)
1294 {
1295 for (unsigned i = 0; i < cPressed; ++i)
1296 {
1297 rc = pHlp->pfnSSMGetU8(pSSM, &u8);
1298 AssertRCReturn(rc, rc);
1299 pThis->abDepressedKeys[u8] = 1;
1300 }
1301 }
1302
1303 /* Load typematic settings for Scan Set 3. */
1304 rc = pHlp->pfnSSMGetU32(pSSM, &cbTMSSize);
1305 AssertRCReturn(rc, rc);
1306
1307 while (cbTMSSize--)
1308 {
1309 rc = pHlp->pfnSSMGetU8(pSSM, &u8);
1310 AssertRCReturn(rc, rc);
1311 }
1312
1313 return rc;
1314}
1315
1316int PS2KR3LoadDone(PPDMDEVINS pDevIns, PPS2K pThis)
1317{
1318 /* This *must* be done after the inital load because it may trigger
1319 * interrupts and change the interrupt controller state.
1320 */
1321 ps2kR3ReleaseKeys(pDevIns, pThis);
1322 ps2kR3NotifyLedsState(pThis, pThis->u8LEDs);
1323 return VINF_SUCCESS;
1324}
1325
1326void PS2KR3Reset(PPDMDEVINS pDevIns, PPS2K pThis)
1327{
1328 LogFlowFunc(("Resetting PS2K\n"));
1329
1330 pThis->fScanning = true;
1331 pThis->fThrottleActive = false;
1332 pThis->u8ScanSet = 2;
1333 pThis->u8CurrCmd = 0;
1334 pThis->u8Modifiers = 0;
1335 pThis->u32TypematicKey = 0;
1336 pThis->enmTypematicState = KBD_TMS_IDLE;
1337
1338 /* Clear queues and any pressed keys. */
1339 memset(pThis->abDepressedKeys, 0, sizeof(pThis->abDepressedKeys));
1340 PS2CmnClearQueue((GeneriQ *)&pThis->cmdQ);
1341 ps2kSetDefaults(pDevIns, pThis); /* Also clears keystroke queue. */
1342
1343 /* Activate the PS/2 keyboard by default. */
1344 if (pThis->Keyboard.pDrv)
1345 pThis->Keyboard.pDrv->pfnSetActive(pThis->Keyboard.pDrv, true);
1346}
1347
1348int PS2KR3Construct(PPS2K pThis, PPDMDEVINS pDevIns, PKBDSTATE pParent, unsigned iInstance, PCFGMNODE pCfg)
1349{
1350 PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
1351 RT_NOREF(pDevIns, iInstance);
1352 LogFlowFunc(("iInstance=%u\n", iInstance));
1353
1354 pThis->pParent = pParent;
1355 pThis->pDevIns = pDevIns;
1356
1357 bool fThrottleEnabled;
1358 int rc = pHlp->pfnCFGMQueryBoolDef(pCfg, "KbdThrottleEnabled", &fThrottleEnabled, true);
1359 if (RT_FAILURE(rc))
1360 return PDMDEV_SET_ERROR(pDevIns, rc, N_("Failed to query \"KbdThrottleEnabled\" from the config"));
1361 Log(("KbdThrottleEnabled=%RTbool\n", fThrottleEnabled));
1362 pThis->fThrottleEnabled = fThrottleEnabled;
1363
1364 /* Initialize the queues. */
1365 pThis->keyQ.cSize = KBD_KEY_QUEUE_SIZE;
1366 pThis->cmdQ.cSize = KBD_CMD_QUEUE_SIZE;
1367
1368 pThis->Keyboard.IBase.pfnQueryInterface = ps2kR3QueryInterface;
1369 pThis->Keyboard.IPort.pfnPutEventHid = ps2kR3KeyboardPort_PutEventHid;
1370
1371 /*
1372 * Create the input rate throttling timer.
1373 */
1374 rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, ps2kR3ThrottleTimer, pThis,
1375 TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "PS2K Throttle Timer", &pThis->hThrottleTimer);
1376 AssertRCReturn(rc, rc);
1377
1378 /*
1379 * Create the typematic delay/repeat timer.
1380 */
1381 rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, ps2kR3TypematicTimer, pThis,
1382 TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "PS2K Typematic Timer", &pThis->hKbdTypematicTimer);
1383 AssertRCReturn(rc, rc);
1384
1385 /*
1386 * Create the command delay timer.
1387 */
1388 rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, ps2kR3DelayTimer, pThis,
1389 TMTIMER_FLAGS_DEFAULT_CRIT_SECT, "PS2K Delay Timer", &pThis->hKbdDelayTimer);
1390 AssertRCReturn(rc, rc);
1391
1392 /*
1393 * Register debugger info callbacks.
1394 */
1395 PDMDevHlpDBGFInfoRegister(pDevIns, "ps2k", "Display PS/2 keyboard state.", ps2kR3InfoState);
1396
1397 return rc;
1398}
1399
1400#endif /* IN _RING3 */
1401
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette