VirtualBox

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

Last change on this file since 44023 was 44023, checked in by vboxsync, 12 years ago

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