VirtualBox

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

Last change on this file since 80862 was 76553, checked in by vboxsync, 6 years ago

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