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