Changeset 50962 in vbox for trunk/src/VBox
- Timestamp:
- Apr 3, 2014 1:58:47 PM (11 years ago)
- svn:sync-xref-src-repo-rev:
- 93119
- Location:
- trunk/src/VBox
- Files:
-
- 4 edited
-
Devices/Input/DrvKeyboardQueue.cpp (modified) (8 diffs)
-
Devices/Input/PS2K.cpp (modified) (7 diffs)
-
Devices/Input/UsbKbd.cpp (modified) (8 diffs)
-
Main/src-client/KeyboardImpl.cpp (modified) (1 diff)
Legend:
- Unmodified
- Added
- Removed
-
trunk/src/VBox/Devices/Input/DrvKeyboardQueue.cpp
r49451 r50962 32 32 * Structures and Typedefs * 33 33 *******************************************************************************/ 34 35 /** Scancode translator state. */ 36 typedef enum { 37 SS_IDLE, /**< Starting state. */ 38 SS_EXT, /**< E0 byte was received. */ 39 SS_EXT1 /**< E1 byte was received. */ 40 } scan_state_t; 41 34 42 /** 35 43 * Keyboard queue driver instance data. … … 52 60 /** The queue handle. */ 53 61 PPDMQUEUE pQueue; 62 /** State of the scancode translation. */ 63 scan_state_t XlatState; 54 64 /** Discard input when this flag is set. */ 55 65 bool fInactive; … … 67 77 PDMQUEUEITEMCORE Core; 68 78 /** The keycode. */ 69 uint 8_t u8KeyCode;79 uint32_t u32UsageCode; 70 80 } DRVKBDQUEUEITEM, *PDRVKBDQUEUEITEM; 71 81 82 83 /******************************************************************************* 84 * Global Variables * 85 *******************************************************************************/ 86 87 /** Lookup table for converting PC/XT scan codes to USB HID usage codes. */ 88 static const uint8_t aScancode2Hid[] = 89 { 90 0x00, 0x29, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, /* 00-07 */ 91 0x24, 0x25, 0x26, 0x27, 0x2d, 0x2e, 0x2a, 0x2b, /* 08-1F */ 92 0x14, 0x1a, 0x08, 0x15, 0x17, 0x1c, 0x18, 0x0c, /* 10-17 */ 93 0x12, 0x13, 0x2f, 0x30, 0x28, 0xe0, 0x04, 0x16, /* 18-1F */ 94 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x0f, 0x33, /* 20-27 */ 95 0x34, 0x35, 0xe1, 0x31, 0x1d, 0x1b, 0x06, 0x19, /* 28-2F */ 96 0x05, 0x11, 0x10, 0x36, 0x37, 0x38, 0xe5, 0x55, /* 30-37 */ 97 0xe2, 0x2c, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, /* 38-3F */ 98 0x3f, 0x40, 0x41, 0x42, 0x43, 0x53, 0x47, 0x5f, /* 40-47 */ 99 0x60, 0x61, 0x56, 0x5c, 0x5d, 0x5e, 0x57, 0x59, /* 48-4F */ 100 0x5a, 0x5b, 0x62, 0x63, 0x46, 0x00, 0x64, 0x44, /* 50-57 */ 101 0x45, 0x67, 0x00, 0x00, 0x8c, 0x00, 0x00, 0x00, /* 58-5F */ 102 0x00, 0x00, 0x00, 0x00, 0x68, 0x69, 0x6a, 0x6b, /* 60-67 */ 103 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x00, /* 68-6F */ 104 0x88, 0x91, 0x90, 0x87, 0x00, 0x00, 0x00, 0x00, /* 70-77 */ 105 0x00, 0x8a, 0x00, 0x8b, 0x00, 0x89, 0x85, 0x00 /* 78-7F */ 106 }; 107 108 /** Lookup table for extended scancodes (arrow keys etc.). */ 109 static const uint8_t aExtScan2Hid[] = 110 { 111 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 00-07 */ 112 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 08-1F */ 113 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 10-17 */ 114 0x00, 0x00, 0x00, 0x00, 0x58, 0xe4, 0x00, 0x00, /* 18-1F */ 115 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 20-27 */ 116 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 28-2F */ 117 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0x00, 0x46, /* 30-37 */ 118 /* Sun-specific keys. Most of the XT codes are made up */ 119 0xe6, 0x00, 0x00, 0x75, 0x76, 0x77, 0xA3, 0x78, /* 38-3F */ 120 0x80, 0x81, 0x82, 0x79, 0x00, 0x00, 0x48, 0x4a, /* 40-47 */ 121 0x52, 0x4b, 0x00, 0x50, 0x00, 0x4f, 0x00, 0x4d, /* 48-4F */ 122 0x51, 0x4e, 0x49, 0x4c, 0x00, 0x00, 0x00, 0x00, /* 50-57 */ 123 0x00, 0x00, 0x00, 0xe3, 0xe7, 0x65, 0x66, 0x00, /* 58-5F */ 124 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 60-67 */ 125 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 68-6F */ 126 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 70-77 */ 127 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 /* 78-7F */ 128 }; 129 130 /** 131 * Convert a PC scan code to a USB HID usage byte. 132 * 133 * @param state Current state of the translator (scan_state_t). 134 * @param scanCode Incoming scan code. 135 * @param pUsage Pointer to usage; high bit set for key up events. The 136 * contents are only valid if returned state is SS_IDLE. 137 * 138 * @return scan_state_t New state of the translator. 139 */ 140 static scan_state_t ScancodeToHidUsage(scan_state_t state, uint8_t scanCode, uint32_t *pUsage) 141 { 142 uint32_t keyUp; 143 uint8_t usage; 144 145 Assert(pUsage); 146 147 /* Isolate the scan code and key break flag. */ 148 keyUp = (scanCode & 0x80) << 24; 149 150 switch (state) { 151 case SS_IDLE: 152 if (scanCode == 0xE0) { 153 state = SS_EXT; 154 } else if (scanCode == 0xE1) { 155 state = SS_EXT1; 156 } else { 157 usage = aScancode2Hid[scanCode & 0x7F]; 158 *pUsage = usage | keyUp; 159 /* Remain in SS_IDLE state. */ 160 } 161 break; 162 case SS_EXT: 163 usage = aExtScan2Hid[scanCode & 0x7F]; 164 *pUsage = usage | keyUp; 165 state = SS_IDLE; 166 break; 167 case SS_EXT1: 168 /* The sequence is E1 1D 45 E1 9D C5. We take the easy way out and remain 169 * in the SS_EXT1 state until 45 or C5 is received. 170 */ 171 if ((scanCode & 0x7F) == 0x45) { 172 *pUsage = 0x48; 173 if (scanCode == 0xC5) 174 *pUsage |= keyUp; 175 state = SS_IDLE; 176 } 177 /* Else remain in SS_EXT1 state. */ 178 break; 179 } 180 return state; 181 } 72 182 73 183 … … 101 211 * @returns VBox status code. 102 212 * @param pInterface Pointer to this interface structure. 103 * @param u8 KeyCode The keycode toqueue.213 * @param u8ScanCode The scan code to translate/queue. 104 214 * @thread Any thread. 105 215 */ 106 static DECLCALLBACK(int) drvKbdQueuePutEvent (PPDMIKEYBOARDPORT pInterface, uint8_t u8KeyCode)216 static DECLCALLBACK(int) drvKbdQueuePutEventScan(PPDMIKEYBOARDPORT pInterface, uint8_t u8ScanCode) 107 217 { 108 218 PDRVKBDQUEUE pDrv = IKEYBOARDPORT_2_DRVKBDQUEUE(pInterface); … … 111 221 return VINF_SUCCESS; 112 222 113 PDRVKBDQUEUEITEM pItem = (PDRVKBDQUEUEITEM)PDMQueueAlloc(pDrv->pQueue); 114 if (pItem) 115 { 116 pItem->u8KeyCode = u8KeyCode; 117 PDMQueueInsert(pDrv->pQueue, &pItem->Core); 223 uint32_t u32Usage = 0; 224 pDrv->XlatState = ScancodeToHidUsage(pDrv->XlatState, u8ScanCode, &u32Usage); 225 226 if (pDrv->XlatState == SS_IDLE) { 227 PDRVKBDQUEUEITEM pItem = (PDRVKBDQUEUEITEM)PDMQueueAlloc(pDrv->pQueue); 228 if (pItem) 229 { 230 pItem->u32UsageCode = u32Usage; 231 PDMQueueInsert(pDrv->pQueue, &pItem->Core); 232 return VINF_SUCCESS; 233 } 234 if (!pDrv->fSuspended) 235 AssertMsgFailed(("drvKbdQueuePutEventScan: Queue is full!!!!\n")); 236 return VERR_PDM_NO_QUEUE_ITEMS; 237 } 238 else 118 239 return VINF_SUCCESS; 119 }120 if (!pDrv->fSuspended)121 AssertMsgFailed(("drvKbdQueuePutEvent: Queue is full!!!!\n"));122 return VERR_PDM_NO_QUEUE_ITEMS;123 240 } 124 241 … … 170 287 PDRVKBDQUEUE pThis = PDMINS_2_DATA(pDrvIns, PDRVKBDQUEUE); 171 288 PDRVKBDQUEUEITEM pItem = (PDRVKBDQUEUEITEM)pItemCore; 172 int rc = pThis->pUpPort->pfnPutEvent (pThis->pUpPort, pItem->u8KeyCode);289 int rc = pThis->pUpPort->pfnPutEventHid(pThis->pUpPort, pItem->u32UsageCode); 173 290 return RT_SUCCESS(rc); 174 291 } … … 264 381 pDrv->fInactive = true; 265 382 pDrv->fSuspended = false; 383 pDrv->XlatState = SS_IDLE; 266 384 /* IBase. */ 267 385 pDrvIns->IBase.pfnQueryInterface = drvKbdQueueQueryInterface; … … 270 388 pDrv->IConnector.pfnSetActive = drvKbdPassThruSetActive; 271 389 /* IKeyboardPort. */ 272 pDrv->IPort.pfnPutEvent = drvKbdQueuePutEvent;390 pDrv->IPort.pfnPutEventScan = drvKbdQueuePutEventScan; 273 391 274 392 /* -
trunk/src/VBox/Devices/Input/PS2K.cpp
r49469 r50962 462 462 *******************************************************************************/ 463 463 464 /*465 * Because of historical reasons and poor design, VirtualBox internally uses BIOS466 * PC/XT style scan codes to represent keyboard events. Each key press and release is467 * represented as a stream of bytes, typically only one byte but up to four-byte468 * sequences are possible. In the typical case, the GUI front end generates the stream469 * of scan codes which we need to translate back to a single up/down event.470 *471 * This function could possibly live somewhere else.472 */473 474 /** Lookup table for converting PC/XT scan codes to USB HID usage codes. */475 static uint8_t aScancode2Hid[] =476 {477 0x00, 0x29, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, /* 00-07 */478 0x24, 0x25, 0x26, 0x27, 0x2d, 0x2e, 0x2a, 0x2b, /* 08-1F */479 0x14, 0x1a, 0x08, 0x15, 0x17, 0x1c, 0x18, 0x0c, /* 10-17 */480 0x12, 0x13, 0x2f, 0x30, 0x28, 0xe0, 0x04, 0x16, /* 18-1F */481 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x0f, 0x33, /* 20-27 */482 0x34, 0x35, 0xe1, 0x31, 0x1d, 0x1b, 0x06, 0x19, /* 28-2F */483 0x05, 0x11, 0x10, 0x36, 0x37, 0x38, 0xe5, 0x55, /* 30-37 */484 0xe2, 0x2c, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, /* 38-3F */485 0x3f, 0x40, 0x41, 0x42, 0x43, 0x53, 0x47, 0x5f, /* 40-47 */486 0x60, 0x61, 0x56, 0x5c, 0x5d, 0x5e, 0x57, 0x59, /* 48-4F */487 0x5a, 0x5b, 0x62, 0x63, 0x46, 0x00, 0x64, 0x44, /* 50-57 */488 0x45, 0x67, 0x00, 0x00, 0x8c, 0x00, 0x00, 0x00, /* 58-5F */489 0x00, 0x00, 0x00, 0x00, 0x68, 0x69, 0x6a, 0x6b, /* 60-67 */490 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x00, /* 68-6F */491 0x88, 0x91, 0x90, 0x87, 0x00, 0x00, 0x00, 0x00, /* 70-77 */492 0x00, 0x8a, 0x00, 0x8b, 0x00, 0x89, 0x85, 0x00 /* 78-7F */493 };494 495 /** Lookup table for extended scancodes (arrow keys etc.). */496 static uint8_t aExtScan2Hid[] =497 {498 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 00-07 */499 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 08-1F */500 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 10-17 */501 0x00, 0x00, 0x00, 0x00, 0x58, 0xe4, 0x00, 0x00, /* 18-1F */502 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 20-27 */503 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 28-2F */504 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0x00, 0x46, /* 30-37 */505 /* Sun-specific keys. Most of the XT codes are made up */506 0xe6, 0x00, 0x00, 0x75, 0x76, 0x77, 0xA3, 0x78, /* 38-3F */507 0x80, 0x81, 0x82, 0x79, 0x00, 0x00, 0x48, 0x4a, /* 40-47 */508 0x52, 0x4b, 0x00, 0x50, 0x00, 0x4f, 0x00, 0x4d, /* 48-4F */509 0x51, 0x4e, 0x49, 0x4c, 0x00, 0x00, 0x00, 0x00, /* 50-57 */510 0x00, 0x00, 0x00, 0xe3, 0xe7, 0x65, 0x66, 0x00, /* 58-5F */511 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 60-67 */512 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 68-6F */513 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 70-77 */514 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 /* 78-7F */515 };516 517 /**518 * Convert a PC scan code to a USB HID usage byte.519 *520 * @param state Current state of the translator (scan_state_t).521 * @param scanCode Incoming scan code.522 * @param pUsage Pointer to usage; high bit set for key up events. The523 * contents are only valid if returned state is SS_IDLE.524 *525 * @return scan_state_t New state of the translator.526 */527 static scan_state_t ScancodeToHidUsage(scan_state_t state, uint8_t scanCode, uint32_t *pUsage)528 {529 uint32_t keyUp;530 uint8_t usage;531 532 Assert(pUsage);533 534 /* Isolate the scan code and key break flag. */535 keyUp = (scanCode & 0x80) << 24;536 537 switch (state) {538 case SS_IDLE:539 if (scanCode == 0xE0) {540 state = SS_EXT;541 } else if (scanCode == 0xE1) {542 state = SS_EXT1;543 } else {544 usage = aScancode2Hid[scanCode & 0x7F];545 *pUsage = usage | keyUp;546 /* Remain in SS_IDLE state. */547 }548 break;549 case SS_EXT:550 usage = aExtScan2Hid[scanCode & 0x7F];551 *pUsage = usage | keyUp;552 state = SS_IDLE;553 break;554 case SS_EXT1:555 /* The sequence is E1 1D 45 E1 9D C5. We take the easy way out and remain556 * in the SS_EXT1 state until 45 or C5 is received.557 */558 if ((scanCode & 0x7F) == 0x45) {559 *pUsage = 0x48;560 if (scanCode == 0xC5)561 *pUsage |= keyUp;562 state = SS_IDLE;563 }564 /* Else remain in SS_EXT1 state. */565 break;566 }567 return state;568 }569 570 464 /******************************************************************************* 571 465 * Internal Functions * … … 884 778 #ifdef IN_RING3 885 779 886 static int ps k2ProcessKeyEvent(PPS2K pThis, uint8_t u8HidCode, bool fKeyDown)780 static int ps2kProcessKeyEvent(PPS2K pThis, uint8_t u8HidCode, bool fKeyDown) 887 781 { 888 782 unsigned int i = 0; … … 1116 1010 if (pThis->enmTypematicState == KBD_TMS_REPEAT) 1117 1011 { 1118 ps k2ProcessKeyEvent(pThis, pThis->u8TypematicKey, true /* Key down */ );1012 ps2kProcessKeyEvent(pThis, pThis->u8TypematicKey, true /* Key down */ ); 1119 1013 TMTimerSetMillies(pThis->CTX_SUFF(pKbdTypematicTimer), pThis->uTypematicRepeat); 1120 1014 } … … 1148 1042 { 1149 1043 LogFlowFunc(("Releasing keys...\n")); 1150 LogRel(("Releasing keys...\n"));1151 1044 1152 1045 for (unsigned uKey = 0; uKey < sizeof(pThis->abDepressedKeys); ++uKey) 1153 1046 if (pThis->abDepressedKeys[uKey]) 1154 1047 { 1155 LogRel(("Releasing key %02X\n", uKey)); 1156 psk2ProcessKeyEvent(pThis, uKey, false /* key up */); 1048 ps2kProcessKeyEvent(pThis, uKey, false /* key up */); 1157 1049 pThis->abDepressedKeys[uKey] = 0; 1158 1050 } … … 1247 1139 AssertReleaseRC(rc); 1248 1140 1249 rc = ps k2ProcessKeyEvent(pThis, u8HidCode, fKeyDown);1141 rc = ps2kProcessKeyEvent(pThis, u8HidCode, fKeyDown); 1250 1142 1251 1143 PDMCritSectLeave(pThis->pCritSectR3); … … 1255 1147 } 1256 1148 1257 static DECLCALLBACK(int) ps2kPutEventWrapper(PPDMIKEYBOARDPORT pInterface, uint 8_t u8KeyCode)1149 static DECLCALLBACK(int) ps2kPutEventWrapper(PPDMIKEYBOARDPORT pInterface, uint32_t u32UsageCode) 1258 1150 { 1259 1151 PPS2K pThis = RT_FROM_MEMBER(pInterface, PS2K, Keyboard.IPort); 1260 uint32_t u32Usage = 0;1261 1152 int rc; 1262 1153 1263 LogFlowFunc(("key code %02X\n", u8KeyCode)); 1154 LogFlowFunc(("key code %08X\n", u32UsageCode)); 1155 1156 rc = PDMCritSectEnter(pThis->pCritSectR3, VERR_SEM_BUSY); 1157 AssertReleaseRC(rc); 1264 1158 1265 1159 /* The 'BAT fail' scancode is reused as a signal to release keys. No actual 1266 1160 * key is allowed to use this scancode. 1267 1161 */ 1268 if (RT_UNLIKELY(u8KeyCode == KRSP_BAT_FAIL)) 1269 { 1270 rc = PDMCritSectEnter(pThis->pCritSectR3, VERR_SEM_BUSY); 1271 AssertReleaseRC(rc); 1272 1162 if (RT_UNLIKELY(u32UsageCode == KRSP_BAT_FAIL)) 1163 { 1273 1164 ps2kReleaseKeys(pThis); 1274 1275 PDMCritSectLeave(pThis->pCritSectR3);1276 1165 } 1277 1166 else 1278 1167 { 1279 pThis->XlatState = ScancodeToHidUsage(pThis->XlatState, u8KeyCode, &u32Usage); 1280 1281 if (pThis->XlatState == SS_IDLE) 1282 { 1283 /* Stupid Korean key hack: convert a lone break key into a press/release sequence. */ 1284 if (u32Usage == 0x80000090 || u32Usage == 0x80000091) 1285 ps2kPutEventWorker(pThis, u32Usage & ~0x80000000); 1286 1287 ps2kPutEventWorker(pThis, u32Usage); 1288 } 1289 } 1168 /* Stupid Korean key hack: convert a lone break key into a press/release sequence. */ 1169 if (u32UsageCode == 0x80000090 || u32UsageCode == 0x80000091) 1170 ps2kPutEventWorker(pThis, u32UsageCode & ~0x80000000); 1171 1172 ps2kPutEventWorker(pThis, u32UsageCode); 1173 } 1174 1175 PDMCritSectLeave(pThis->pCritSectR3); 1290 1176 1291 1177 return VINF_SUCCESS; … … 1500 1386 1501 1387 pThis->Keyboard.IBase.pfnQueryInterface = ps2kQueryInterface; 1502 pThis->Keyboard.IPort.pfnPutEvent 1388 pThis->Keyboard.IPort.pfnPutEventHid = ps2kPutEventWrapper; 1503 1389 1504 1390 /* -
trunk/src/VBox/Devices/Input/UsbKbd.cpp
r49814 r50962 133 133 } USBHIDK_REPORT, *PUSBHIDK_REPORT; 134 134 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 135 /** 143 136 * The USB HID instance data. … … 160 153 /** The state of the HID (state machine).*/ 161 154 USBHIDREQSTATE enmState; 162 163 /** State of the scancode translation. */164 scan_state_t XlatState;165 155 166 156 /** Pending to-host queue. … … 358 348 }; 359 349 360 361 /*362 * Because of historical reasons and poor design, VirtualBox internally uses BIOS363 * PC/XT style scan codes to represent keyboard events. Each key press and release is364 * represented as a stream of bytes, typically only one byte but up to four-byte365 * sequences are possible. In the typical case, the GUI front end generates the stream366 * of scan codes which we need to translate back to a single up/down event.367 *368 * This function could possibly live somewhere else.369 */370 371 /** Lookup table for converting PC/XT scan codes to USB HID usage codes. */372 /** We map the scan codes for F13 to F23 to the usage codes for Sun keyboard373 * left-hand side function keys rather than to the standard F13 to F23 usage374 * codes, since we suspect that there are more people wanting Sun keyboard375 * emulation than emulation of other keyboards with extended function keys. */376 static uint8_t aScancode2Hid[] =377 {378 0x00, 0x29, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, /* 00-07 */379 0x24, 0x25, 0x26, 0x27, 0x2d, 0x2e, 0x2a, 0x2b, /* 08-1F */380 0x14, 0x1a, 0x08, 0x15, 0x17, 0x1c, 0x18, 0x0c, /* 10-17 */381 0x12, 0x13, 0x2f, 0x30, 0x28, 0xe0, 0x04, 0x16, /* 18-1F */382 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x0f, 0x33, /* 20-27 */383 0x34, 0x35, 0xe1, 0x31, 0x1d, 0x1b, 0x06, 0x19, /* 28-2F */384 0x05, 0x11, 0x10, 0x36, 0x37, 0x38, 0xe5, 0x55, /* 30-37 */385 0xe2, 0x2c, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, /* 38-3F */386 0x3f, 0x40, 0x41, 0x42, 0x43, 0x53, 0x47, 0x5f, /* 40-47 */387 0x60, 0x61, 0x56, 0x5c, 0x5d, 0x5e, 0x57, 0x59, /* 48-4F */388 0x5a, 0x5b, 0x62, 0x63, 0x46, 0x00, 0x64, 0x44, /* 50-57 */389 0x45, 0x67, 0x00, 0x00, 0x8c, 0x00, 0x00, 0x00, /* 58-5F */390 /* Sun keys: Props Undo Front Copy */391 0x00, 0x00, 0x00, 0x00, 0x76, 0x7a, 0x77, 0x7c, /* 60-67 */392 /* Open Paste Find Cut Stop Again Help */393 0x74, 0x7d, 0x7e, 0x7b, 0x78, 0x79, 0x75, 0x00, /* 68-6F */394 0x88, 0x91, 0x90, 0x87, 0x00, 0x00, 0x00, 0x00, /* 70-77 */395 0x00, 0x8a, 0x00, 0x8b, 0x00, 0x89, 0x85, 0x00 /* 78-7F */396 };397 398 /** Lookup table for extended scancodes (arrow keys etc.). */399 static uint8_t aExtScan2Hid[] =400 {401 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 00-07 */402 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 08-1F */403 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 10-17 */404 0x00, 0x00, 0x00, 0x00, 0x58, 0xe4, 0x00, 0x00, /* 18-1F */405 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 20-27 */406 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 28-2F */407 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0x00, 0x46, /* 30-37 */408 0xe6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 38-3F */409 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x4a, /* 40-47 */410 0x52, 0x4b, 0x00, 0x50, 0x00, 0x4f, 0x00, 0x4d, /* 48-4F */411 0x51, 0x4e, 0x49, 0x4c, 0x00, 0x00, 0x00, 0x00, /* 50-57 */412 0x00, 0x00, 0x00, 0xe3, 0xe7, 0x65, 0x66, 0x00, /* 58-5F */413 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 60-67 */414 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 68-6F */415 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 70-77 */416 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 /* 78-7F */417 };418 419 /**420 * Convert a PC scan code to a USB HID usage byte.421 *422 * @param state Current state of the translator (scan_state_t).423 * @param scanCode Incoming scan code.424 * @param pUsage Pointer to usage; high bit set for key up events. The425 * contents are only valid if returned state is SS_IDLE.426 *427 * @return scan_state_t New state of the translator.428 */429 static scan_state_t ScancodeToHidUsage(scan_state_t state, uint8_t scanCode, uint32_t *pUsage)430 {431 uint32_t keyUp;432 uint8_t usage;433 434 Assert(pUsage);435 436 /* Isolate the scan code and key break flag. */437 keyUp = (scanCode & 0x80) << 24;438 439 switch (state) {440 case SS_IDLE:441 if (scanCode == 0xE0) {442 state = SS_EXT;443 } else if (scanCode == 0xE1) {444 state = SS_EXT1;445 } else {446 usage = aScancode2Hid[scanCode & 0x7F];447 *pUsage = usage | keyUp;448 /* Remain in SS_IDLE state. */449 }450 break;451 case SS_EXT:452 usage = aExtScan2Hid[scanCode & 0x7F];453 *pUsage = usage | keyUp;454 state = SS_IDLE;455 break;456 case SS_EXT1:457 Assert(0); //@todo - sort out the Pause key458 *pUsage = 0;459 state = SS_IDLE;460 break;461 }462 return state;463 }464 350 465 351 /******************************************************************************* … … 933 819 * @returns VBox status code. 934 820 * @param pInterface Pointer to the keyboard port interface (KBDState::Keyboard.IPort). 935 * @param u 8KeyCode The keycode.936 */ 937 static DECLCALLBACK(int) usbHidKeyboardPutEvent(PPDMIKEYBOARDPORT pInterface, uint 8_t u8KeyCode)821 * @param u32UsageCode The key usage ID. 822 */ 823 static DECLCALLBACK(int) usbHidKeyboardPutEvent(PPDMIKEYBOARDPORT pInterface, uint32_t u32UsageCode) 938 824 { 939 825 PUSBHID pThis = RT_FROM_MEMBER(pInterface, USBHID, Lun0.IPort); 940 uint32_t u32Usage = 0;941 826 uint8_t u8HidCode; 942 827 int fKeyDown; … … 945 830 RTCritSectEnter(&pThis->CritSect); 946 831 947 if (RT_UNLIKELY(u 8KeyCode == KRSP_BAT_FAIL))832 if (RT_UNLIKELY(u32UsageCode == KRSP_BAT_FAIL)) 948 833 { 949 834 /* Clear all currently depressed and unreported keys. */ … … 954 839 else 955 840 { 956 957 pThis->XlatState = ScancodeToHidUsage(pThis->XlatState, u8KeyCode, &u32Usage); 958 959 if (pThis->XlatState == SS_IDLE) 841 fKeyDown = !(u32UsageCode & 0x80000000); 842 u8HidCode = u32UsageCode & 0xFF; 843 AssertReturn(u8HidCode <= VBOX_USB_MAX_USAGE_CODE, VERR_INTERNAL_ERROR); 844 845 LogFlowFunc(("key %s: 0x%x\n", fKeyDown ? "down" : "up", u8HidCode)); 846 847 if (fKeyDown) 960 848 { 961 /* The usage code is valid. */ 962 fKeyDown = !(u32Usage & 0x80000000); 963 u8HidCode = u32Usage & 0xFF; 964 AssertReturn(u8HidCode <= VBOX_USB_MAX_USAGE_CODE, VERR_INTERNAL_ERROR); 965 966 LogFlowFunc(("key %s: 0x%x->0x%x\n", 967 fKeyDown ? "down" : "up", u8KeyCode, u8HidCode)); 968 969 if (fKeyDown) 849 /* Due to host key repeat, we can get key events for keys which are 850 * already depressed. */ 851 if (!pThis->abDepressedKeys[u8HidCode]) 970 852 { 971 /* Due to host key repeat, we can get key events for keys which are 972 * already depressed. */ 973 if (!pThis->abDepressedKeys[u8HidCode]) 853 pThis->abUnreportedKeys[u8HidCode] = 1; 854 855 /* If a non-modifier key is being marked as unreported, also set 856 * all currently depressed modifer keys as unreported. This avoids 857 * problems where a simulated key sequence is sent too fast and 858 * by the time the key is reported, some previously reported 859 * modifiers are already released. This helps ensure that the guest 860 * sees the entire modifier(s)+key sequence in a single report. 861 */ 862 if (!usbHidUsageCodeIsModifier(u8HidCode)) 974 863 { 975 pThis->abUnreportedKeys[u8HidCode] = 1; 976 977 /* If a non-modifier key is being marked as unreported, also set 978 * all currently depressed modifer keys as unreported. This avoids 979 * problems where a simulated key sequence is sent too fast and 980 * by the time the key is reported, some previously reported 981 * modifiers are already released. This helps ensure that the guest 982 * sees the entire modifier(s)+key sequence in a single report. 983 */ 984 if (!usbHidUsageCodeIsModifier(u8HidCode)) 985 { 986 int iModKey; 987 988 for (iModKey = USBHID_MODIFIER_FIRST; iModKey <= USBHID_MODIFIER_LAST; ++iModKey) 989 if (pThis->abDepressedKeys[iModKey]) 990 pThis->abUnreportedKeys[iModKey] = 1; 991 } 864 int iModKey; 865 866 for (iModKey = USBHID_MODIFIER_FIRST; iModKey <= USBHID_MODIFIER_LAST; ++iModKey) 867 if (pThis->abDepressedKeys[iModKey]) 868 pThis->abUnreportedKeys[iModKey] = 1; 992 869 } 993 else994 fHaveEvent = false;995 pThis->abDepressedKeys[u8HidCode] = 1;996 870 } 997 871 else 998 { 999 /* For stupid Korean keyboards, we have to fake a key up/down sequence 1000 * because they only send break codes for Hangul/Hanja keys. 1001 */ 1002 if (u8HidCode == 0x90 || u8HidCode == 0x91) 1003 pThis->abUnreportedKeys[u8HidCode] = 1; 1004 pThis->abDepressedKeys[u8HidCode] = 0; 1005 } 1006 1007 1008 /* Send a report if the host is already waiting for it. */ 1009 if (fHaveEvent) 1010 usbHidSendReport(pThis); 872 fHaveEvent = false; 873 pThis->abDepressedKeys[u8HidCode] = 1; 1011 874 } 875 else 876 { 877 /* For stupid Korean keyboards, we have to fake a key up/down sequence 878 * because they only send break codes for Hangul/Hanja keys. 879 */ 880 if (u8HidCode == 0x90 || u8HidCode == 0x91) 881 pThis->abUnreportedKeys[u8HidCode] = 1; 882 pThis->abDepressedKeys[u8HidCode] = 0; 883 } 884 885 886 /* Send a report if the host is already waiting for it. */ 887 if (fHaveEvent) 888 usbHidSendReport(pThis); 1012 889 } 1013 890 … … 1504 1381 pThis->pUsbIns = pUsbIns; 1505 1382 pThis->hEvtDoneQueue = NIL_RTSEMEVENT; 1506 pThis->XlatState = SS_IDLE;1507 1383 usbHidQueueInit(&pThis->ToHostQueue); 1508 1384 usbHidQueueInit(&pThis->DoneQueue); … … 1522 1398 1523 1399 pThis->Lun0.IBase.pfnQueryInterface = usbHidKeyboardQueryInterface; 1524 pThis->Lun0.IPort.pfnPutEvent 1400 pThis->Lun0.IPort.pfnPutEventHid = usbHidKeyboardPutEvent; 1525 1401 1526 1402 /* -
trunk/src/VBox/Main/src-client/KeyboardImpl.cpp
r50544 r50962 211 211 uint32_t sent; 212 212 for (sent = 0; (sent < keys.size()) && RT_SUCCESS(vrc); sent++) 213 vrc = pUpPort->pfnPutEvent (pUpPort, (uint8_t)keys[sent]);213 vrc = pUpPort->pfnPutEventScan(pUpPort, (uint8_t)keys[sent]); 214 214 215 215 if (codesStored)
Note:
See TracChangeset
for help on using the changeset viewer.
