VirtualBox

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

Last change on this file since 89938 was 89938, checked in by vboxsync, 3 years ago

Warnings.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 61.3 KB
Line 
1/* $Id: DevPS2K.cpp 89938 2021-06-29 06:57:51Z vboxsync $ */
2/** @file
3 * PS2K - PS/2 keyboard emulation.
4 */
5
6/*
7 * Copyright (C) 2007-2020 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/* USB to PS/2 conversion table for Generic Desktop Control keys (HID Usage Page 1). */
376/* This usage page is tiny. */
377static const ext_key_def aPS2DCKeys[] = {
378 {0x81, {0x5E, 0x37, UNKN, KF_E0, T_U}}, /* System Power */
379 {0x82, {0x5F, 0x3F, UNKN, KF_E0, T_U}}, /* System Sleep */
380 {0x83, {0x63, 0x5E, UNKN, KF_E0, T_U}}, /* System Wake */
381};
382
383/* We somehow need to keep track of depressed keys. To keep the array size
384 * under control, and because the number of defined keys isn't massive, we'd
385 * like to use an 8-bit index into the array.
386 * For the main USB HID usage page 7 (keyboard), we deal with 8-bit HID codes
387 * in the range from 0 to 0xE7, and use the HID codes directly.
388 * There's a convenient gap in the 0xA5-0xDF range. We use that to stuff the
389 * USB HID usage page 12 (consumer control) into the gap starting at 0xC0;
390 * the consumer control codes are from 0xB5 to 0x22A, but very sparse, with
391 * only 24 codes defined. We use the aPS2CCKeys array to generate our own
392 * code in the 0xC0-0xD7 range.
393 * For the tiny USB HID usage page 1 (generic desktop system) we use a similar
394 * approach, translating these to codes 0xB0 to 0xB2.
395 */
396
397#define PS2K_PAGE_DC_START 0xb0
398#define PS2K_PAGE_DC_END (PS2K_PAGE_DC_START + RT_ELEMENTS(aPS2DCKeys))
399#define PS2K_PAGE_CC_START 0xc0
400#define PS2K_PAGE_CC_END (PS2K_PAGE_CC_START + RT_ELEMENTS(aPS2CCKeys))
401
402AssertCompile(RT_ELEMENTS(aPS2CCKeys) <= 0x20); /* Must fit between 0xC0-0xDF. */
403AssertCompile(RT_ELEMENTS(aPS2DCKeys) <= 0x10); /* Must fit between 0xB0-0xBF. */
404
405#endif /* IN_RING3 */
406
407#ifdef IN_RING3
408
409/**
410 * Add a null-terminated byte sequence to a queue if there is enough room.
411 *
412 * @param pQueue Pointer to the queue.
413 * @param pStr Pointer to the bytes to store.
414 * @param cbReserve Number of bytes that must still remain available in
415 * queue.
416 * @return VBox status/error code.
417 */
418static int ps2kR3InsertStrQueue(KbdKeyQ *pQueue, const uint8_t *pStr, uint32_t cbReserve)
419{
420 /* Check if queue has enough room. */
421 size_t const cbStr = (uint32_t)strlen((const char *)pStr);
422 uint32_t cUsed = RT_MIN(pQueue->Hdr.cUsed, RT_ELEMENTS(pQueue->abQueue));
423 if (cUsed + cbReserve + cbStr >= RT_ELEMENTS(pQueue->abQueue))
424 {
425 LogRelFlowFunc(("queue %p (KbdKeyQ) full (%u entries, want room for %u), cannot insert %zu entries\n",
426 pQueue, cUsed, cbReserve, cbStr));
427 return VERR_BUFFER_OVERFLOW;
428 }
429
430 /* Insert byte sequence and update circular buffer write position. */
431 uint32_t wpos = pQueue->Hdr.wpos % RT_ELEMENTS(pQueue->abQueue);
432 for (size_t i = 0; i < cbStr; i++)
433 {
434 pQueue->abQueue[wpos] = pStr[i];
435 wpos += 1;
436 if (wpos < RT_ELEMENTS(pQueue->abQueue))
437 { /* likely */ }
438 else
439 wpos = 0; /* Roll over. */
440 }
441
442 pQueue->Hdr.wpos = wpos;
443 pQueue->Hdr.cUsed = cUsed + (uint32_t)cbStr;
444
445 LogRelFlowFunc(("inserted %u bytes into queue %p (KbdKeyQ)\n", cbStr, pQueue));
446 return VINF_SUCCESS;
447}
448
449/**
450 * Notify listener about LEDs state change.
451 *
452 * @param pThisCC The PS/2 keyboard instance data for ring-3.
453 * @param u8State Bitfield which reflects LEDs state.
454 */
455static void ps2kR3NotifyLedsState(PPS2KR3 pThisCC, uint8_t u8State)
456{
457 PDMKEYBLEDS enmLeds = PDMKEYBLEDS_NONE;
458
459 if (u8State & 0x01)
460 enmLeds = (PDMKEYBLEDS)(enmLeds | PDMKEYBLEDS_SCROLLLOCK);
461 if (u8State & 0x02)
462 enmLeds = (PDMKEYBLEDS)(enmLeds | PDMKEYBLEDS_NUMLOCK);
463 if (u8State & 0x04)
464 enmLeds = (PDMKEYBLEDS)(enmLeds | PDMKEYBLEDS_CAPSLOCK);
465
466 if (pThisCC->Keyboard.pDrv)
467 pThisCC->Keyboard.pDrv->pfnLedStatusChange(pThisCC->Keyboard.pDrv, enmLeds);
468}
469
470#endif /* IN_RING3 */
471
472/** Clears the currently active typematic key, if any. */
473static void ps2kStopTypematicRepeat(PPDMDEVINS pDevIns, PPS2K pThis)
474{
475 if (pThis->u32TypematicKey)
476 {
477 LogFunc(("Typematic key %08X\n", pThis->u32TypematicKey));
478 pThis->enmTypematicState = KBD_TMS_IDLE;
479 pThis->u32TypematicKey = 0;
480 PDMDevHlpTimerStop(pDevIns, pThis->hKbdTypematicTimer);
481 }
482}
483
484/** Convert encoded typematic value to milliseconds. Note that the values are rated
485 * with +/- 20% accuracy, so there's no need for high precision.
486 */
487static void ps2kSetupTypematic(PPS2K pThis, uint8_t val)
488{
489 int A, B;
490 unsigned period;
491
492 pThis->u8TypematicCfg = val;
493 /* The delay is easy: (1 + value) * 250 ms */
494 pThis->uTypematicDelay = (1 + ((val >> 5) & 3)) * 250;
495 /* The rate is more complicated: (8 + A) * 2^B * 4.17 ms */
496 A = val & 7;
497 B = (val >> 3) & 3;
498 period = (8 + A) * (1 << B) * 417 / 100;
499 pThis->uTypematicRepeat = period;
500 Log(("Typematic delay %u ms, repeat period %u ms\n",
501 pThis->uTypematicDelay, pThis->uTypematicRepeat));
502}
503
504static void ps2kSetDefaults(PPDMDEVINS pDevIns, PPS2K pThis)
505{
506 LogFlowFunc(("Set keyboard defaults\n"));
507 PS2Q_CLEAR(&pThis->keyQ);
508 /* Set default Scan Set 3 typematic values. */
509 /* Set default typematic rate/delay. */
510 ps2kSetupTypematic(pThis, KBD_DFL_RATE_DELAY);
511 /* Clear last typematic key?? */
512 ps2kStopTypematicRepeat(pDevIns, pThis);
513}
514
515/**
516 * The keyboard controller disabled the keyboard serial line.
517 *
518 * @param pThis The keyboard device shared instance data.
519 */
520void PS2KLineDisable(PPS2K pThis)
521{
522 LogFlowFunc(("Disabling keyboard serial line\n"));
523
524 pThis->fLineDisabled = true;
525}
526
527/**
528 * The keyboard controller enabled the keyboard serial line.
529 *
530 * @param pThis The keyboard device shared instance data.
531 */
532void PS2KLineEnable(PPS2K pThis)
533{
534 LogFlowFunc(("Enabling keyboard serial line\n"));
535
536 pThis->fLineDisabled = false;
537
538 /* If there was anything in the input queue,
539 * consider it lost and throw it away.
540 */
541 PS2Q_CLEAR(&pThis->keyQ);
542}
543
544/**
545 * Receive and process a byte sent by the keyboard controller.
546 *
547 * @param pDevIns The device instance.
548 * @param pThis The shared PS/2 keyboard instance data.
549 * @param cmd The command (or data) byte.
550 */
551int PS2KByteToKbd(PPDMDEVINS pDevIns, PPS2K pThis, uint8_t cmd)
552{
553 bool fHandled = true;
554
555 LogFlowFunc(("new cmd=0x%02X, active cmd=0x%02X\n", cmd, pThis->u8CurrCmd));
556
557 if (pThis->u8CurrCmd == KCMD_RESET)
558 /* In reset mode, do not respond at all. */
559 return VINF_SUCCESS;
560
561 switch (cmd)
562 {
563 case KCMD_ECHO:
564 PS2Q_INSERT(&pThis->cmdQ, KRSP_ECHO);
565 pThis->u8CurrCmd = 0;
566 break;
567 case KCMD_READ_ID:
568 PS2Q_INSERT(&pThis->cmdQ, KRSP_ACK);
569 PS2Q_INSERT(&pThis->cmdQ, KRSP_ID1);
570 PS2Q_INSERT(&pThis->cmdQ, KRSP_ID2);
571 pThis->u8CurrCmd = 0;
572 break;
573 case KCMD_ENABLE:
574 pThis->fScanning = true;
575 PS2Q_CLEAR(&pThis->keyQ);
576 ps2kStopTypematicRepeat(pDevIns, pThis);
577 PS2Q_INSERT(&pThis->cmdQ, KRSP_ACK);
578 pThis->u8CurrCmd = 0;
579 break;
580 case KCMD_DFLT_DISABLE:
581 pThis->fScanning = false;
582 ps2kSetDefaults(pDevIns, pThis); /* Also clears buffer/typematic state. */
583 PS2Q_INSERT(&pThis->cmdQ, KRSP_ACK);
584 pThis->u8CurrCmd = 0;
585 break;
586 case KCMD_SET_DEFAULT:
587 ps2kSetDefaults(pDevIns, pThis);
588 PS2Q_INSERT(&pThis->cmdQ, KRSP_ACK);
589 pThis->u8CurrCmd = 0;
590 break;
591 case KCMD_ALL_TYPEMATIC:
592 case KCMD_ALL_MK_BRK:
593 case KCMD_ALL_MAKE:
594 case KCMD_ALL_TMB:
595 /// @todo Set the key types here.
596 PS2Q_INSERT(&pThis->cmdQ, KRSP_ACK);
597 pThis->u8CurrCmd = 0;
598 break;
599 case KCMD_RESEND:
600 pThis->u8CurrCmd = 0;
601 break;
602 case KCMD_RESET:
603 pThis->u8ScanSet = 2;
604 ps2kSetDefaults(pDevIns, pThis);
605 /// @todo reset more?
606 PS2Q_INSERT(&pThis->cmdQ, KRSP_ACK);
607 pThis->u8CurrCmd = cmd;
608 /* Delay BAT completion; the test may take hundreds of ms. */
609 PDMDevHlpTimerSetMillies(pDevIns, pThis->hKbdDelayTimer, 2);
610 break;
611 /* The following commands need a parameter. */
612 case KCMD_LEDS:
613 case KCMD_SCANSET:
614 case KCMD_RATE_DELAY:
615 case KCMD_TYPE_MATIC:
616 case KCMD_TYPE_MK_BRK:
617 case KCMD_TYPE_MAKE:
618 PS2Q_INSERT(&pThis->cmdQ, KRSP_ACK);
619 pThis->u8CurrCmd = cmd;
620 break;
621 default:
622 /* Sending a command instead of a parameter starts the new command. */
623 switch (pThis->u8CurrCmd)
624 {
625 case KCMD_LEDS:
626#ifndef IN_RING3
627 return VINF_IOM_R3_IOPORT_WRITE;
628#else
629 {
630 PPS2KR3 pThisCC = &PDMDEVINS_2_DATA_CC(pDevIns, PKBDSTATER3)->Kbd;
631 ps2kR3NotifyLedsState(pThisCC, cmd);
632 pThis->fNumLockOn = !!(cmd & 0x02); /* Sync internal Num Lock state. */
633 PS2Q_INSERT(&pThis->cmdQ, KRSP_ACK);
634 pThis->u8LEDs = cmd;
635 pThis->u8CurrCmd = 0;
636 }
637#endif
638 break;
639 case KCMD_SCANSET:
640 PS2Q_INSERT(&pThis->cmdQ, KRSP_ACK);
641 if (cmd == 0)
642 PS2Q_INSERT(&pThis->cmdQ, pThis->u8ScanSet);
643 else if (cmd < 4)
644 {
645 pThis->u8ScanSet = cmd;
646 LogRel(("PS2K: Selected scan set %d\n", cmd));
647 }
648 /* Other values are simply ignored. */
649 pThis->u8CurrCmd = 0;
650 break;
651 case KCMD_RATE_DELAY:
652 ps2kSetupTypematic(pThis, cmd);
653 PS2Q_INSERT(&pThis->cmdQ, KRSP_ACK);
654 pThis->u8CurrCmd = 0;
655 break;
656 default:
657 fHandled = false;
658 }
659 /* Fall through only to handle unrecognized commands. */
660 if (fHandled)
661 break;
662 RT_FALL_THRU();
663
664 case KCMD_INVALID_1:
665 case KCMD_INVALID_2:
666 PS2Q_INSERT(&pThis->cmdQ, KRSP_RESEND);
667 pThis->u8CurrCmd = 0;
668 break;
669 }
670 LogFlowFunc(("Active cmd now 0x%02X; updating interrupts\n", pThis->u8CurrCmd));
671// KBCUpdateInterrupts(pDevIns);
672 return VINF_SUCCESS;
673}
674
675/**
676 * Send a byte (keystroke or command response) to the keyboard controller.
677 *
678 * @returns VINF_SUCCESS or VINF_TRY_AGAIN.
679 * @param pDevIns The device instance.
680 * @param pThis The shared PS/2 keyboard instance data.
681 * @param pb Where to return the byte we've read.
682 * @remarks Caller must have entered the device critical section.
683 */
684int PS2KByteFromKbd(PPDMDEVINS pDevIns, PPS2K pThis, uint8_t *pb)
685{
686 int rc;
687
688 AssertPtr(pb);
689
690 /* Anything in the command queue has priority over data
691 * in the keystroke queue. Additionally, keystrokes are
692 * blocked if a command is currently in progress, even if
693 * the command queue is empty.
694 */
695 rc = PS2Q_REMOVE(&pThis->cmdQ, pb);
696 if (rc != VINF_SUCCESS && !pThis->u8CurrCmd && pThis->fScanning)
697 if (!pThis->fThrottleActive)
698 {
699 rc = PS2Q_REMOVE(&pThis->keyQ, pb);
700 if (pThis->fThrottleEnabled)
701 {
702 pThis->fThrottleActive = true;
703 PDMDevHlpTimerSetMillies(pDevIns, pThis->hThrottleTimer, KBD_THROTTLE_DELAY);
704 }
705 }
706
707 LogFlowFunc(("keyboard sends 0x%02x (%svalid data)\n", *pb, rc == VINF_SUCCESS ? "" : "not "));
708 return rc;
709}
710
711#ifdef IN_RING3
712
713static int ps2kR3HidToInternalCode(uint32_t u32HidCode, key_def const **ppKeyDef)
714{
715 uint8_t u8HidPage;
716 uint16_t u16HidUsage;
717 int iKeyIndex = -1;
718 key_def const *pKeyDef = &aPS2Keys[0]; /* Dummy no-event key. */;
719
720 u8HidPage = RT_LOBYTE(RT_HIWORD(u32HidCode));
721 u16HidUsage = RT_LOWORD(u32HidCode);
722
723 if (u8HidPage == USB_HID_KB_PAGE)
724 {
725 if (u16HidUsage <= VBOX_USB_MAX_USAGE_CODE)
726 {
727 iKeyIndex = u16HidUsage; /* Direct mapping. */
728 pKeyDef = iKeyIndex >= HID_MODIFIER_FIRST ? &aPS2ModKeys[iKeyIndex - HID_MODIFIER_FIRST] : &aPS2Keys[iKeyIndex];
729 }
730 else
731 AssertMsgFailed(("u16HidUsage out of range! (%04X)\n", u16HidUsage));
732 }
733 else if (u8HidPage == USB_HID_CC_PAGE)
734 {
735 for (unsigned i = 0; i < RT_ELEMENTS(aPS2CCKeys); ++i)
736 if (aPS2CCKeys[i].usageId == u16HidUsage)
737 {
738 pKeyDef = &aPS2CCKeys[i].kdef;
739 iKeyIndex = PS2K_PAGE_CC_START + i;
740 break;
741 }
742 AssertMsg(iKeyIndex > -1, ("Unsupported code in USB_HID_CC_PAGE! (%04X)\n", u16HidUsage));
743 }
744 else if (u8HidPage == USB_HID_DC_PAGE)
745 {
746 for (unsigned i = 0; i < RT_ELEMENTS(aPS2DCKeys); ++i)
747 if (aPS2CCKeys[i].usageId == u16HidUsage)
748 {
749 pKeyDef = &aPS2DCKeys[i].kdef;
750 iKeyIndex = PS2K_PAGE_DC_START + i;
751 break;
752 }
753 AssertMsg(iKeyIndex > -1, ("Unsupported code in USB_HID_DC_PAGE! (%04X)\n", u16HidUsage));
754 }
755 else
756 {
757 AssertMsgFailed(("Unsupported u8HidPage! (%02X)\n", u8HidPage));
758 }
759
760 if (ppKeyDef)
761 *ppKeyDef = pKeyDef;
762
763 return iKeyIndex;
764}
765
766static uint32_t ps2kR3InternalCodeToHid(unsigned uKeyCode)
767{
768 uint16_t u16HidUsage;
769 uint32_t u32HidCode = 0;
770
771 if ((uKeyCode >= PS2K_PAGE_DC_START) && (uKeyCode <= PS2K_PAGE_DC_END))
772 {
773 u16HidUsage = aPS2DCKeys[uKeyCode - PS2K_PAGE_DC_START].usageId;
774 u32HidCode = RT_MAKE_U32(u16HidUsage, USB_HID_DC_PAGE);
775 }
776 else if ((uKeyCode >= PS2K_PAGE_CC_START) && (uKeyCode <= PS2K_PAGE_CC_END))
777 {
778 u16HidUsage = aPS2CCKeys[uKeyCode - PS2K_PAGE_CC_START].usageId;
779 u32HidCode = RT_MAKE_U32(u16HidUsage, USB_HID_CC_PAGE);
780 }
781 else /* Must be the keyboard usage page. */
782 {
783 if (uKeyCode <= VBOX_USB_MAX_USAGE_CODE)
784 u32HidCode = RT_MAKE_U32(uKeyCode, USB_HID_KB_PAGE);
785 else
786 AssertMsgFailed(("uKeyCode out of range! (%u)\n", uKeyCode));
787 }
788
789 return u32HidCode;
790}
791
792static int ps2kR3ProcessKeyEvent(PPDMDEVINS pDevIns, PPS2K pThis, uint32_t u32HidCode, bool fKeyDown)
793{
794 key_def const *pKeyDef;
795 uint8_t abCodes[16];
796 char *pCodes;
797 size_t cbLeft;
798 uint8_t abScan[2];
799 uint8_t u8HidPage;
800 uint16_t u16HidUsage;
801
802 u8HidPage = RT_LOBYTE(RT_HIWORD(u32HidCode));
803 u16HidUsage = RT_LOWORD(u32HidCode);
804
805 LogFlowFunc(("key %s: page 0x%02x ID 0x%04x (set %d)\n", fKeyDown ? "down" : "up", u8HidPage, u16HidUsage, pThis->u8ScanSet));
806
807 ps2kR3HidToInternalCode(u32HidCode, &pKeyDef);
808
809 /* Some keys are not processed at all; early return. */
810 if (pKeyDef->makeS1 == NONE)
811 {
812 LogFlow(("Skipping key processing.\n"));
813 return VINF_SUCCESS;
814 }
815
816 /* Handle modifier keys (Ctrl/Alt/Shift/GUI). We need to keep track
817 * of their state in addition to sending the scan code.
818 */
819 if ((u8HidPage == USB_HID_KB_PAGE) && (u16HidUsage >= HID_MODIFIER_FIRST))
820 {
821 unsigned mod_bit = 1 << (u16HidUsage - HID_MODIFIER_FIRST);
822
823 Assert((u16HidUsage <= HID_MODIFIER_LAST));
824 if (fKeyDown)
825 pThis->u8Modifiers |= mod_bit;
826 else
827 pThis->u8Modifiers &= ~mod_bit;
828 }
829
830 /* Toggle NumLock state. */
831 if ((pKeyDef->keyFlags & KF_NL) && fKeyDown)
832 pThis->fNumLockOn ^= true;
833
834 abCodes[0] = 0;
835 pCodes = (char *)abCodes;
836 cbLeft = sizeof(abCodes);
837
838 if (pThis->u8ScanSet == 1 || pThis->u8ScanSet == 2)
839 {
840 /* The basic scan set 1 and 2 logic is the same, only the scan codes differ.
841 * Since scan set 2 is used almost all the time, that case is handled first.
842 */
843 if (fKeyDown)
844 {
845 /* Process key down event. */
846 if (pKeyDef->keyFlags & KF_PB)
847 {
848 /* Pause/Break sends different data if either Ctrl is held. */
849 if (pThis->u8Modifiers & (MOD_LCTRL | MOD_RCTRL))
850 RTStrCatP(&pCodes, &cbLeft, pThis->u8ScanSet == 2 ?
851 "\xE0\x7E\xE0\xF0\x7E" : "\xE0\x46\xE0\xC6");
852 else
853 RTStrCatP(&pCodes, &cbLeft, pThis->u8ScanSet == 2 ?
854 "\xE1\x14\x77\xE1\xF0\x14\xF0\x77" : "\xE1\x1D\x45\xE1\x9D\xC5");
855 }
856 else if (pKeyDef->keyFlags & KF_PS)
857 {
858 /* Print Screen depends on all of Ctrl, Shift, *and* Alt! */
859 if (pThis->u8Modifiers & (MOD_LALT | MOD_RALT))
860 RTStrCatP(&pCodes, &cbLeft, pThis->u8ScanSet == 2 ?
861 "\x84" : "\x54");
862 else if (pThis->u8Modifiers & (MOD_LSHIFT | MOD_RSHIFT))
863 RTStrCatP(&pCodes, &cbLeft, pThis->u8ScanSet == 2 ?
864 "\xE0\x7C" : "\xE0\x37");
865 else
866 RTStrCatP(&pCodes, &cbLeft, pThis->u8ScanSet == 2 ?
867 "\xE0\x12\xE0\x7C" : "\xE0\x2A\xE0\x37");
868 }
869 else if (pKeyDef->keyFlags & (KF_GK | KF_NS))
870 {
871 /* The numeric pad keys fake Shift presses or releases
872 * depending on Num Lock and Shift key state. The '/'
873 * key behaves in a similar manner but does not depend on
874 * the Num Lock state.
875 */
876 if (!pThis->fNumLockOn || (pKeyDef->keyFlags & KF_NS))
877 {
878 if (pThis->u8Modifiers & MOD_LSHIFT)
879 RTStrCatP(&pCodes, &cbLeft, pThis->u8ScanSet == 2 ?
880 "\xE0\xF0\x12" : "\xE0\xAA");
881 if (pThis->u8Modifiers & MOD_RSHIFT)
882 RTStrCatP(&pCodes, &cbLeft, pThis->u8ScanSet == 2 ?
883 "\xE0\xF0\x59" : "\xE0\xB6");
884 }
885 else
886 {
887 Assert(pThis->fNumLockOn); /* Not for KF_NS! */
888 if ((pThis->u8Modifiers & (MOD_LSHIFT | MOD_RSHIFT)) == 0)
889 RTStrCatP(&pCodes, &cbLeft, pThis->u8ScanSet == 2 ?
890 "\xE0\x12" : "\xE0\x2A");
891 /* Else Shift cancels NumLock, so no prefix! */
892 }
893 }
894
895 /* Standard processing for regular keys only. */
896 abScan[0] = pThis->u8ScanSet == 2 ? pKeyDef->makeS2 : pKeyDef->makeS1;
897 abScan[1] = '\0';
898 if (!(pKeyDef->keyFlags & (KF_PB | KF_PS)))
899 {
900 if (pKeyDef->keyFlags & (KF_E0 | KF_GK | KF_NS))
901 RTStrCatP(&pCodes, &cbLeft, "\xE0");
902 RTStrCatP(&pCodes, &cbLeft, (const char *)abScan);
903 }
904
905 /* Feed the bytes to the queue if there is room. */
906 /// @todo Send overrun code if sequence won't fit?
907 ps2kR3InsertStrQueue(&pThis->keyQ, abCodes, 0);
908 }
909 else if (!(pKeyDef->keyFlags & (KF_NB | KF_PB)))
910 {
911 /* Process key up event except for keys which produce none. */
912
913 /* Handle Print Screen release. */
914 if (pKeyDef->keyFlags & KF_PS)
915 {
916 /* Undo faked Print Screen state as needed. */
917 if (pThis->u8Modifiers & (MOD_LALT | MOD_RALT))
918 RTStrCatP(&pCodes, &cbLeft, pThis->u8ScanSet == 2 ?
919 "\xF0\x84" : "\xD4");
920 else if (pThis->u8Modifiers & (MOD_LSHIFT | MOD_RSHIFT))
921 RTStrCatP(&pCodes, &cbLeft, pThis->u8ScanSet == 2 ?
922 "\xE0\xF0\x7C" : "\xE0\xB7");
923 else
924 RTStrCatP(&pCodes, &cbLeft, pThis->u8ScanSet == 2 ?
925 "\xE0\xF0\x7C\xE0\xF0\x12" : "\xE0\xB7\xE0\xAA");
926 }
927 else
928 {
929 /* Process base scan code for less unusual keys. */
930 abScan[0] = pThis->u8ScanSet == 2 ? pKeyDef->makeS2 : pKeyDef->makeS1 | 0x80;
931 abScan[1] = '\0';
932 if (pKeyDef->keyFlags & (KF_E0 | KF_GK | KF_NS))
933 RTStrCatP(&pCodes, &cbLeft, "\xE0");
934 if (pThis->u8ScanSet == 2)
935 RTStrCatP(&pCodes, &cbLeft, "\xF0");
936 RTStrCatP(&pCodes, &cbLeft, (const char *)abScan);
937
938 /* Restore shift state for gray keys. */
939 if (pKeyDef->keyFlags & (KF_GK | KF_NS))
940 {
941 if (!pThis->fNumLockOn || (pKeyDef->keyFlags & KF_NS))
942 {
943 if (pThis->u8Modifiers & MOD_LSHIFT)
944 RTStrCatP(&pCodes, &cbLeft, pThis->u8ScanSet == 2 ?
945 "\xE0\x12" : "\xE0\x2A");
946 if (pThis->u8Modifiers & MOD_RSHIFT)
947 RTStrCatP(&pCodes, &cbLeft, pThis->u8ScanSet == 2 ?
948 "\xE0\x59" : "\xE0\x36");
949 }
950 else
951 {
952 Assert(pThis->fNumLockOn); /* Not for KF_NS! */
953 if ((pThis->u8Modifiers & (MOD_LSHIFT | MOD_RSHIFT)) == 0)
954 RTStrCatP(&pCodes, &cbLeft, pThis->u8ScanSet == 2 ?
955 "\xE0\xF0\x12" : "\xE0\xAA");
956 }
957 }
958 }
959
960 /* Feed the bytes to the queue if there is room. */
961 /// @todo Send overrun code if sequence won't fit?
962 ps2kR3InsertStrQueue(&pThis->keyQ, abCodes, 0);
963 }
964 }
965 else
966 {
967 /* Handle Scan Set 3 - very straightforward. */
968 Assert(pThis->u8ScanSet == 3);
969 abScan[0] = pKeyDef->makeS3;
970 abScan[1] = '\0';
971 if (fKeyDown)
972 {
973 RTStrCatP(&pCodes, &cbLeft, (const char *)abScan);
974 }
975 else
976 {
977 /* Send a key release code unless it's a make only key. */
978 /// @todo Look up the current typematic setting, not the default!
979 if (pKeyDef->keyMatic != T_M)
980 {
981 RTStrCatP(&pCodes, &cbLeft, "\xF0");
982 RTStrCatP(&pCodes, &cbLeft, (const char *)abScan);
983 }
984 }
985 /* Feed the bytes to the queue if there is room. */
986 /// @todo Send overrun code if sequence won't fit?
987 ps2kR3InsertStrQueue(&pThis->keyQ, abCodes, 0);
988 }
989
990 /* Set up or cancel typematic key repeat. For keyboard usage page only. */
991 if (u8HidPage == USB_HID_KB_PAGE)
992 {
993 if (fKeyDown)
994 {
995 if (pThis->u32TypematicKey != u32HidCode)
996 {
997 pThis->enmTypematicState = KBD_TMS_DELAY;
998 pThis->u32TypematicKey = u32HidCode;
999 PDMDevHlpTimerSetMillies(pDevIns, pThis->hKbdTypematicTimer, pThis->uTypematicDelay);
1000 Log(("Typematic delay %u ms, key %08X\n", pThis->uTypematicDelay, u32HidCode));
1001 }
1002 }
1003 else
1004 {
1005 /* "Typematic operation stops when the last key pressed is released, even
1006 * if other keys are still held down." (IBM PS/2 Tech Ref). The last key pressed
1007 * is the one that's being repeated.
1008 */
1009 if (pThis->u32TypematicKey == u32HidCode)
1010 {
1011 /* This disables the typematic repeat. */
1012 pThis->u32TypematicKey = 0;
1013 pThis->enmTypematicState = KBD_TMS_IDLE;
1014 /* For good measure, we cancel the timer, too. */
1015 PDMDevHlpTimerStop(pDevIns, pThis->hKbdTypematicTimer);
1016 Log(("Typematic action cleared for key %08X\n", u32HidCode));
1017 }
1018 }
1019 }
1020
1021 /* Poke the KBC to update its state. */
1022 KBCUpdateInterrupts(pDevIns);
1023
1024 return VINF_SUCCESS;
1025}
1026
1027/**
1028 * @callback_method_impl{FNTMTIMERDEV}
1029 *
1030 * Throttling timer to emulate the finite keyboard communication speed. A PS/2 keyboard is
1031 * limited by the serial link speed and cannot send much more than 1,000 bytes per second.
1032 * Some software (notably Borland Pascal and programs built with its run-time) relies on
1033 * being able to read an incoming scan-code twice. Throttling the data rate enables such
1034 * software to function, while human typists cannot tell any difference.
1035 *
1036 * Note: The throttling is currently only done for keyboard data, not command responses.
1037 * The throttling could and perhaps should be done for any data (including command
1038 * responses) coming from PS/2 devices, both keyboard and auxiliary. That is not currently
1039 * done because it would needlessly slow things down.
1040 */
1041static DECLCALLBACK(void) ps2kR3ThrottleTimer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
1042{
1043 PPS2K pThis = (PS2K *)pvUser;
1044 unsigned uHaveData;
1045 RT_NOREF(hTimer);
1046
1047 /* Grab the lock to avoid races with event delivery or EMTs. */
1048 int rc = PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_SEM_BUSY);
1049 AssertReleaseRC(rc);
1050
1051 /* If data is available, poke the KBC. Once the data
1052 * is actually read, the timer may be re-triggered.
1053 */
1054 pThis->fThrottleActive = false;
1055 uHaveData = PS2Q_COUNT(&pThis->keyQ);
1056 LogFlowFunc(("Have%s bytes\n", uHaveData ? "" : " no"));
1057 if (uHaveData)
1058 KBCUpdateInterrupts(pDevIns);
1059
1060 PDMDevHlpCritSectLeave(pDevIns, pDevIns->pCritSectRoR3);
1061}
1062
1063/**
1064 * @callback_method_impl{FNTMTIMERDEV,
1065 * Timer handler for emulating typematic keys.}
1066 *
1067 * @note Note that only the last key held down repeats (if typematic).
1068 */
1069static DECLCALLBACK(void) ps2kR3TypematicTimer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
1070{
1071 PPS2K pThis = (PS2K *)pvUser;
1072 Assert(hTimer == pThis->hKbdTypematicTimer);
1073 LogFlowFunc(("Typematic state=%d, key %08X\n", pThis->enmTypematicState, pThis->u32TypematicKey));
1074
1075 /* If the current typematic key is zero, the repeat was canceled just when
1076 * the timer was about to run. In that case, do nothing.
1077 */
1078 if (pThis->u32TypematicKey)
1079 {
1080 if (pThis->enmTypematicState == KBD_TMS_DELAY)
1081 pThis->enmTypematicState = KBD_TMS_REPEAT;
1082
1083 if (pThis->enmTypematicState == KBD_TMS_REPEAT)
1084 {
1085 ps2kR3ProcessKeyEvent(pDevIns, pThis, pThis->u32TypematicKey, true /* Key down */ );
1086 PDMDevHlpTimerSetMillies(pDevIns, hTimer, pThis->uTypematicRepeat);
1087 }
1088 }
1089}
1090
1091/**
1092 * @callback_method_impl{FNTMTIMERDEV}
1093 *
1094 * The keyboard BAT is specified to take several hundred milliseconds. We need
1095 * to delay sending the result to the host for at least a tiny little while.
1096 */
1097static DECLCALLBACK(void) ps2kR3DelayTimer(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
1098{
1099 PPS2K pThis = (PS2K *)pvUser;
1100 RT_NOREF(hTimer);
1101
1102 LogFlowFunc(("Delay timer: cmd %02X\n", pThis->u8CurrCmd));
1103
1104 AssertMsg(pThis->u8CurrCmd == KCMD_RESET, ("u8CurrCmd=%02x\n", pThis->u8CurrCmd));
1105 PS2Q_INSERT(&pThis->cmdQ, KRSP_BAT_OK);
1106 pThis->fScanning = true; /* BAT completion enables scanning! */
1107 pThis->u8CurrCmd = 0;
1108
1109 /// @todo Might want a PS2KCompleteCommand() to push last response, clear command, and kick the KBC...
1110 /* Give the KBC a kick. */
1111 KBCUpdateInterrupts(pDevIns);
1112}
1113
1114/* Release any and all currently depressed keys. Used whenever the guest keyboard
1115 * is likely to be out of sync with the host, such as when loading a saved state
1116 * or resuming a suspended host.
1117 */
1118static void ps2kR3ReleaseKeys(PPDMDEVINS pDevIns, PPS2K pThis)
1119{
1120 LogFlowFunc(("Releasing keys...\n"));
1121
1122 for (unsigned uKey = 0; uKey < RT_ELEMENTS(pThis->abDepressedKeys); ++uKey)
1123 if (pThis->abDepressedKeys[uKey])
1124 {
1125 ps2kR3ProcessKeyEvent(pDevIns, pThis, ps2kR3InternalCodeToHid(uKey), false /* key up */);
1126 pThis->abDepressedKeys[uKey] = 0;
1127 }
1128 LogFlowFunc(("Done releasing keys\n"));
1129}
1130
1131
1132/**
1133 * Debug device info handler. Prints basic keyboard state.
1134 *
1135 * @param pDevIns Device instance which registered the info.
1136 * @param pHlp Callback functions for doing output.
1137 * @param pszArgs Argument string. Optional and specific to the handler.
1138 */
1139static DECLCALLBACK(void) ps2kR3InfoState(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
1140{
1141 PKBDSTATE pParent = PDMDEVINS_2_DATA(pDevIns, PKBDSTATE);
1142 PPS2K pThis = &pParent->Kbd;
1143 NOREF(pszArgs);
1144
1145 pHlp->pfnPrintf(pHlp, "PS/2 Keyboard: scan set %d, scanning %s, serial line %s\n",
1146 pThis->u8ScanSet, pThis->fScanning ? "enabled" : "disabled",
1147 pThis->fLineDisabled ? "disabled" : "enabled");
1148 pHlp->pfnPrintf(pHlp, "Active command %02X\n", pThis->u8CurrCmd);
1149 pHlp->pfnPrintf(pHlp, "LED state %02X, Num Lock %s\n", pThis->u8LEDs,
1150 pThis->fNumLockOn ? "on" : "off");
1151 pHlp->pfnPrintf(pHlp, "Typematic delay %ums, repeat period %ums\n",
1152 pThis->uTypematicDelay, pThis->uTypematicRepeat);
1153 pHlp->pfnPrintf(pHlp, "Command queue: %d items (%d max)\n",
1154 PS2Q_COUNT(&pThis->cmdQ), PS2Q_SIZE(&pThis->cmdQ));
1155 pHlp->pfnPrintf(pHlp, "Input queue : %d items (%d max)\n",
1156 PS2Q_COUNT(&pThis->keyQ), PS2Q_SIZE(&pThis->keyQ));
1157 if (pThis->enmTypematicState != KBD_TMS_IDLE)
1158 pHlp->pfnPrintf(pHlp, "Active typematic key %08X (%s)\n", pThis->u32TypematicKey,
1159 pThis->enmTypematicState == KBD_TMS_DELAY ? "delay" : "repeat");
1160}
1161
1162
1163/* -=-=-=-=-=- Keyboard: IKeyboardPort -=-=-=-=-=- */
1164
1165/**
1166 * Keyboard event handler.
1167 *
1168 * @returns VBox status code.
1169 * @param pDevIns The device instance.
1170 * @param pThis The PS2 keyboard instance data.
1171 * @param idUsage USB HID usage code with key press/release flag.
1172 */
1173static int ps2kR3PutEventWorker(PPDMDEVINS pDevIns, PPS2K pThis, uint32_t idUsage)
1174{
1175 uint32_t u32HidCode;
1176 bool fKeyDown;
1177 bool fHaveEvent = true;
1178 int iKeyCode;
1179 int rc = VINF_SUCCESS;
1180
1181 /* Extract the usage page and ID and ensure it's valid. */
1182 fKeyDown = !(idUsage & PDMIKBDPORT_KEY_UP);
1183 u32HidCode = idUsage & 0xFFFFFF;
1184
1185 iKeyCode = ps2kR3HidToInternalCode(u32HidCode, NULL);
1186 AssertReturn(iKeyCode > 0 && iKeyCode <= VBOX_USB_MAX_USAGE_CODE, VERR_INTERNAL_ERROR);
1187
1188 if (fKeyDown)
1189 {
1190 /* Due to host key repeat, we can get key events for keys which are
1191 * already depressed. We need to ignore those. */
1192 if (pThis->abDepressedKeys[iKeyCode])
1193 fHaveEvent = false;
1194 pThis->abDepressedKeys[iKeyCode] = 1;
1195 }
1196 else
1197 {
1198 /* NB: We allow key release events for keys which aren't depressed.
1199 * That is unlikely to happen and should not cause trouble.
1200 */
1201 pThis->abDepressedKeys[iKeyCode] = 0;
1202 }
1203
1204 /* Unless this is a new key press/release, don't even bother. */
1205 if (fHaveEvent)
1206 {
1207 Assert(PDMDevHlpCritSectIsOwner(pDevIns, pDevIns->pCritSectRoR3));
1208 rc = ps2kR3ProcessKeyEvent(pDevIns, pThis, u32HidCode, fKeyDown);
1209 }
1210
1211 return rc;
1212}
1213
1214
1215/**
1216 * @interface_method_impl{PDMIKEYBOARDPORT,pfnPutEventHid}
1217 */
1218static DECLCALLBACK(int) ps2kR3KeyboardPort_PutEventHid(PPDMIKEYBOARDPORT pInterface, uint32_t idUsage)
1219{
1220 PPS2KR3 pThisCC = RT_FROM_MEMBER(pInterface, PS2KR3, Keyboard.IPort);
1221 PPDMDEVINS pDevIns = pThisCC->pDevIns;
1222 PPS2K pThis = &PDMDEVINS_2_DATA(pDevIns, PKBDSTATE)->Kbd;
1223 int rc;
1224
1225 LogRelFlowFunc(("key code %08X\n", idUsage));
1226
1227 rc = PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_SEM_BUSY);
1228 AssertReleaseRC(rc);
1229
1230 /* The 'BAT fail' scancode is reused as a signal to release keys. No actual
1231 * key is allowed to use this scancode.
1232 */
1233 if (RT_LIKELY(!(idUsage & PDMIKBDPORT_RELEASE_KEYS)))
1234 ps2kR3PutEventWorker(pDevIns, pThis, idUsage);
1235 else
1236 ps2kR3ReleaseKeys(pDevIns, pThis);
1237
1238 PDMDevHlpCritSectLeave(pDevIns, pDevIns->pCritSectRoR3);
1239
1240 return VINF_SUCCESS;
1241}
1242
1243
1244/* -=-=-=-=-=- Keyboard: IBase -=-=-=-=-=- */
1245
1246/**
1247 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
1248 */
1249static DECLCALLBACK(void *) ps2kR3QueryInterface(PPDMIBASE pInterface, const char *pszIID)
1250{
1251 PPS2KR3 pThisCC = RT_FROM_MEMBER(pInterface, PS2KR3, Keyboard.IBase);
1252 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThisCC->Keyboard.IBase);
1253 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIKEYBOARDPORT, &pThisCC->Keyboard.IPort);
1254 return NULL;
1255}
1256
1257
1258/* -=-=-=-=-=- Device management -=-=-=-=-=- */
1259
1260/**
1261 * Attach command.
1262 *
1263 * This is called to let the device attach to a driver for a
1264 * specified LUN.
1265 *
1266 * This is like plugging in the keyboard after turning on the
1267 * system.
1268 *
1269 * @returns VBox status code.
1270 * @param pDevIns The device instance.
1271 * @param pThisCC The PS/2 keyboard instance data for ring-3.
1272 * @param iLUN The logical unit which is being detached.
1273 * @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
1274 */
1275int PS2KR3Attach(PPDMDEVINS pDevIns, PPS2KR3 pThisCC, unsigned iLUN, uint32_t fFlags)
1276{
1277 int rc;
1278
1279 /* The LUN must be 0, i.e. keyboard. */
1280 Assert(iLUN == 0);
1281 AssertMsgReturn(fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG,
1282 ("PS/2 keyboard does not support hotplugging\n"),
1283 VERR_INVALID_PARAMETER);
1284
1285 LogFlowFunc(("iLUN=%d\n", iLUN));
1286
1287 rc = PDMDevHlpDriverAttach(pDevIns, iLUN, &pThisCC->Keyboard.IBase, &pThisCC->Keyboard.pDrvBase, "Keyboard Port");
1288 if (RT_SUCCESS(rc))
1289 {
1290 pThisCC->Keyboard.pDrv = PDMIBASE_QUERY_INTERFACE(pThisCC->Keyboard.pDrvBase, PDMIKEYBOARDCONNECTOR);
1291 if (!pThisCC->Keyboard.pDrv)
1292 {
1293 AssertLogRelMsgFailed(("LUN #0 doesn't have a keyboard interface! rc=%Rrc\n", rc));
1294 rc = VERR_PDM_MISSING_INTERFACE;
1295 }
1296 }
1297 else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
1298 {
1299 Log(("%s/%d: warning: no driver attached to LUN #0!\n", pDevIns->pReg->szName, pDevIns->iInstance));
1300 rc = VINF_SUCCESS;
1301 }
1302 else
1303 AssertLogRelMsgFailed(("Failed to attach LUN #0! rc=%Rrc\n", rc));
1304
1305 return rc;
1306}
1307
1308void PS2KR3SaveState(PPDMDEVINS pDevIns, PPS2K pThis, PSSMHANDLE pSSM)
1309{
1310 PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
1311 uint32_t cPressed = 0;
1312 uint32_t cbTMSSize = 0;
1313
1314 LogFlowFunc(("Saving PS2K state\n"));
1315
1316 /* Save the basic keyboard state. */
1317 pHlp->pfnSSMPutU8(pSSM, pThis->u8CurrCmd);
1318 pHlp->pfnSSMPutU8(pSSM, pThis->u8LEDs);
1319 pHlp->pfnSSMPutU8(pSSM, pThis->u8TypematicCfg);
1320 pHlp->pfnSSMPutU8(pSSM, (uint8_t)pThis->u32TypematicKey);
1321 pHlp->pfnSSMPutU8(pSSM, pThis->u8Modifiers);
1322 pHlp->pfnSSMPutU8(pSSM, pThis->u8ScanSet);
1323 pHlp->pfnSSMPutU8(pSSM, pThis->enmTypematicState);
1324 pHlp->pfnSSMPutBool(pSSM, pThis->fNumLockOn);
1325 pHlp->pfnSSMPutBool(pSSM, pThis->fScanning);
1326
1327 /* Save the command and keystroke queues. */
1328 PS2Q_SAVE(pHlp, pSSM, &pThis->cmdQ);
1329 PS2Q_SAVE(pHlp, pSSM, &pThis->keyQ);
1330
1331 /* Save the command delay timer. Note that the typematic repeat
1332 * timer is *not* saved.
1333 */
1334 PDMDevHlpTimerSave(pDevIns, pThis->hKbdDelayTimer, pSSM);
1335
1336 /* Save any pressed keys. This is necessary to avoid "stuck"
1337 * keys after a restore. Needs two passes.
1338 */
1339 for (unsigned i = 0; i < sizeof(pThis->abDepressedKeys); ++i)
1340 if (pThis->abDepressedKeys[i])
1341 ++cPressed;
1342
1343 pHlp->pfnSSMPutU32(pSSM, cPressed);
1344
1345 for (unsigned uKey = 0; uKey < sizeof(pThis->abDepressedKeys); ++uKey)
1346 if (pThis->abDepressedKeys[uKey])
1347 pHlp->pfnSSMPutU8(pSSM, uKey);
1348
1349 /* Save the typematic settings for Scan Set 3. */
1350 pHlp->pfnSSMPutU32(pSSM, cbTMSSize);
1351 /* Currently not implemented. */
1352}
1353
1354int PS2KR3LoadState(PPDMDEVINS pDevIns, PPS2K pThis, PSSMHANDLE pSSM, uint32_t uVersion)
1355{
1356 PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
1357 uint8_t u8;
1358 uint32_t cPressed;
1359 uint32_t cbTMSSize;
1360 int rc;
1361
1362 NOREF(uVersion);
1363 LogFlowFunc(("Loading PS2K state version %u\n", uVersion));
1364
1365 /* Load the basic keyboard state. */
1366 pHlp->pfnSSMGetU8(pSSM, &pThis->u8CurrCmd);
1367 pHlp->pfnSSMGetU8(pSSM, &pThis->u8LEDs);
1368 pHlp->pfnSSMGetU8(pSSM, &pThis->u8TypematicCfg);
1369 pHlp->pfnSSMGetU8(pSSM, &u8);
1370 /* Reconstruct the 32-bit code from the 8-bit value in saved state. */
1371 pThis->u32TypematicKey = u8 ? ps2kR3InternalCodeToHid(u8) : 0;
1372 pHlp->pfnSSMGetU8(pSSM, &pThis->u8Modifiers);
1373 pHlp->pfnSSMGetU8(pSSM, &pThis->u8ScanSet);
1374 pHlp->pfnSSMGetU8(pSSM, &u8);
1375 pThis->enmTypematicState = (tmatic_state_t)u8;
1376 pHlp->pfnSSMGetBool(pSSM, &pThis->fNumLockOn);
1377 pHlp->pfnSSMGetBool(pSSM, &pThis->fScanning);
1378
1379 /* Load the command and keystroke queues. */
1380 rc = PS2Q_LOAD(pHlp, pSSM, &pThis->cmdQ);
1381 AssertRCReturn(rc, rc);
1382 rc = PS2Q_LOAD(pHlp, pSSM, &pThis->keyQ);
1383 AssertRCReturn(rc, rc);
1384
1385 /* Load the command delay timer, just in case. */
1386 rc = PDMDevHlpTimerLoad(pDevIns, pThis->hKbdDelayTimer, pSSM);
1387 AssertRCReturn(rc, rc);
1388
1389 /* Recalculate the typematic delay/rate. */
1390 ps2kSetupTypematic(pThis, pThis->u8TypematicCfg);
1391
1392 /* Fake key up events for keys that were held down at the time the state was saved. */
1393 rc = pHlp->pfnSSMGetU32(pSSM, &cPressed);
1394 AssertRCReturn(rc, rc);
1395
1396 /* If any keys were down, load and then release them. */
1397 if (cPressed)
1398 {
1399 for (unsigned i = 0; i < cPressed; ++i)
1400 {
1401 rc = pHlp->pfnSSMGetU8(pSSM, &u8);
1402 AssertRCReturn(rc, rc);
1403 pThis->abDepressedKeys[u8] = 1;
1404 }
1405 }
1406
1407 /* Load typematic settings for Scan Set 3. */
1408 rc = pHlp->pfnSSMGetU32(pSSM, &cbTMSSize);
1409 AssertRCReturn(rc, rc);
1410
1411 while (cbTMSSize--)
1412 {
1413 rc = pHlp->pfnSSMGetU8(pSSM, &u8);
1414 AssertRCReturn(rc, rc);
1415 }
1416
1417 return rc;
1418}
1419
1420int PS2KR3LoadDone(PPDMDEVINS pDevIns, PPS2K pThis, PPS2KR3 pThisCC)
1421{
1422 /* This *must* be done after the inital load because it may trigger
1423 * interrupts and change the interrupt controller state.
1424 */
1425 ps2kR3ReleaseKeys(pDevIns, pThis);
1426 ps2kR3NotifyLedsState(pThisCC, pThis->u8LEDs);
1427 return VINF_SUCCESS;
1428}
1429
1430void PS2KR3Reset(PPDMDEVINS pDevIns, PPS2K pThis, PPS2KR3 pThisCC)
1431{
1432 LogFlowFunc(("Resetting PS2K\n"));
1433
1434 pThis->fScanning = true;
1435 pThis->fThrottleActive = false;
1436 pThis->u8ScanSet = 2;
1437 pThis->u8CurrCmd = 0;
1438 pThis->u8Modifiers = 0;
1439 pThis->u32TypematicKey = 0;
1440 pThis->enmTypematicState = KBD_TMS_IDLE;
1441
1442 /* Clear queues and any pressed keys. */
1443 memset(pThis->abDepressedKeys, 0, sizeof(pThis->abDepressedKeys));
1444 PS2Q_CLEAR(&pThis->cmdQ);
1445 ps2kSetDefaults(pDevIns, pThis); /* Also clears keystroke queue. */
1446
1447 /* Activate the PS/2 keyboard by default. */
1448 if (pThisCC->Keyboard.pDrv)
1449 pThisCC->Keyboard.pDrv->pfnSetActive(pThisCC->Keyboard.pDrv, true /*fActive*/);
1450}
1451
1452int PS2KR3Construct(PPDMDEVINS pDevIns, PPS2K pThis, PPS2KR3 pThisCC, PCFGMNODE pCfg)
1453{
1454 LogFlowFunc(("\n"));
1455 PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
1456
1457 /*
1458 * Read configuration.
1459 */
1460 bool fThrottleEnabled;
1461 int rc = pHlp->pfnCFGMQueryBoolDef(pCfg, "KbdThrottleEnabled", &fThrottleEnabled, true);
1462 if (RT_FAILURE(rc))
1463 return PDMDEV_SET_ERROR(pDevIns, rc, N_("Failed to query \"KbdThrottleEnabled\" from the config"));
1464 Log(("KbdThrottleEnabled=%RTbool\n", fThrottleEnabled));
1465 pThis->fThrottleEnabled = fThrottleEnabled;
1466
1467 /*
1468 * Initialize state.
1469 */
1470 pThisCC->pDevIns = pDevIns;
1471 pThisCC->Keyboard.IBase.pfnQueryInterface = ps2kR3QueryInterface;
1472 pThisCC->Keyboard.IPort.pfnPutEventHid = ps2kR3KeyboardPort_PutEventHid;
1473
1474 pThis->cmdQ.Hdr.pszDesc = "Kbd Cmd";
1475 pThis->keyQ.Hdr.pszDesc = "Kbd Key";
1476
1477 /*
1478 * Create the input rate throttling timer.
1479 */
1480 rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, ps2kR3ThrottleTimer, pThis,
1481 TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_RING0,
1482 "PS2K Throttle", &pThis->hThrottleTimer);
1483 AssertRCReturn(rc, rc);
1484
1485 /*
1486 * Create the typematic delay/repeat timer.
1487 */
1488 rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, ps2kR3TypematicTimer, pThis,
1489 TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_RING0,
1490 "PS2K Typematic", &pThis->hKbdTypematicTimer);
1491 AssertRCReturn(rc, rc);
1492
1493 /*
1494 * Create the command delay timer.
1495 */
1496 rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, ps2kR3DelayTimer, pThis,
1497 TMTIMER_FLAGS_DEFAULT_CRIT_SECT | TMTIMER_FLAGS_RING0,
1498 "PS2K Delay", &pThis->hKbdDelayTimer);
1499 AssertRCReturn(rc, rc);
1500
1501 /*
1502 * Register debugger info callbacks.
1503 */
1504 PDMDevHlpDBGFInfoRegister(pDevIns, "ps2k", "Display PS/2 keyboard state.", ps2kR3InfoState);
1505
1506 return rc;
1507}
1508
1509#endif /* IN _RING3 */
1510
Note: See TracBrowser for help on using the repository browser.

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