VirtualBox

source: vbox/trunk/src/VBox/Devices/Input/DrvKeyboardQueue.cpp@ 64468

Last change on this file since 64468 was 62907, checked in by vboxsync, 8 years ago

Devices: warnings
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 17.6 KB
Line 
1/* $Id: DrvKeyboardQueue.cpp 62907 2016-08-03 11:21:49Z vboxsync $ */
2/** @file
3 * VBox input devices: Keyboard queue driver
4 */
5
6/*
7 * Copyright (C) 2006-2016 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18
19/*********************************************************************************************************************************
20* Header Files *
21*********************************************************************************************************************************/
22#define LOG_GROUP LOG_GROUP_DRV_KBD_QUEUE
23#include <VBox/vmm/pdmdrv.h>
24#include <iprt/assert.h>
25#include <iprt/uuid.h>
26
27#include "VBoxDD.h"
28
29
30
31/*********************************************************************************************************************************
32* Structures and Typedefs *
33*********************************************************************************************************************************/
34
35/** Scancode translator state. */
36typedef 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
42/**
43 * Keyboard queue driver instance data.
44 *
45 * @implements PDMIKEYBOARDCONNECTOR
46 * @implements PDMIKEYBOARDPORT
47 */
48typedef struct DRVKBDQUEUE
49{
50 /** Pointer to the driver instance structure. */
51 PPDMDRVINS pDrvIns;
52 /** Pointer to the keyboard port interface of the driver/device above us. */
53 PPDMIKEYBOARDPORT pUpPort;
54 /** Pointer to the keyboard port interface of the driver/device below us. */
55 PPDMIKEYBOARDCONNECTOR pDownConnector;
56 /** Our keyboard connector interface. */
57 PDMIKEYBOARDCONNECTOR IConnector;
58 /** Our keyboard port interface. */
59 PDMIKEYBOARDPORT IPort;
60 /** The queue handle. */
61 PPDMQUEUE pQueue;
62 /** State of the scancode translation. */
63 scan_state_t XlatState;
64 /** Discard input when this flag is set. */
65 bool fInactive;
66 /** When VM is suspended, queue full errors are not fatal. */
67 bool fSuspended;
68} DRVKBDQUEUE, *PDRVKBDQUEUE;
69
70
71/**
72 * Keyboard queue item.
73 */
74typedef struct DRVKBDQUEUEITEM
75{
76 /** The core part owned by the queue manager. */
77 PDMQUEUEITEMCORE Core;
78 /** The keycode. */
79 uint32_t u32UsageCode;
80} DRVKBDQUEUEITEM, *PDRVKBDQUEUEITEM;
81
82
83/*********************************************************************************************************************************
84* Global Variables *
85*********************************************************************************************************************************/
86
87/** Lookup table for converting PC/XT scan codes to USB HID usage codes. */
88static 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.). */
109static 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 */
140static 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}
182
183
184/* -=-=-=-=- IBase -=-=-=-=- */
185
186/**
187 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
188 */
189static DECLCALLBACK(void *) drvKbdQueueQueryInterface(PPDMIBASE pInterface, const char *pszIID)
190{
191 PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
192 PDRVKBDQUEUE pThis = PDMINS_2_DATA(pDrvIns, PDRVKBDQUEUE);
193
194 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
195 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIKEYBOARDCONNECTOR, &pThis->IConnector);
196 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIKEYBOARDPORT, &pThis->IPort);
197 return NULL;
198}
199
200
201/* -=-=-=-=- IKeyboardPort -=-=-=-=- */
202
203/** Converts a pointer to DRVKBDQUEUE::IPort to a DRVKBDQUEUE pointer. */
204#define IKEYBOARDPORT_2_DRVKBDQUEUE(pInterface) ( (PDRVKBDQUEUE)((char *)(pInterface) - RT_OFFSETOF(DRVKBDQUEUE, IPort)) )
205
206
207/**
208 * Queues a keyboard event.
209 * Because of the event queueing the EMT context requirement is lifted.
210 *
211 * @returns VBox status code.
212 * @param pInterface Pointer to this interface structure.
213 * @param u8ScanCode The scan code to translate/queue.
214 * @thread Any thread.
215 */
216static DECLCALLBACK(int) drvKbdQueuePutEventScan(PPDMIKEYBOARDPORT pInterface, uint8_t u8ScanCode)
217{
218 PDRVKBDQUEUE pDrv = IKEYBOARDPORT_2_DRVKBDQUEUE(pInterface);
219 /* Ignore any attempt to send events if queue is inactive. */
220 if (pDrv->fInactive)
221 return VINF_SUCCESS;
222
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 /*
231 * Work around incredibly poorly desgined Korean keyboards which
232 * only send break events for Hangul/Hanja keys -- convert a lone
233 * key up into a key up/key down sequence.
234 */
235 if (u32Usage == 0x80000090 || u32Usage == 0x80000091)
236 {
237 PDRVKBDQUEUEITEM pItem2 = (PDRVKBDQUEUEITEM)PDMQueueAlloc(pDrv->pQueue);
238 /*
239 * NB: If there's no room in the queue, we will drop the faked
240 * key down event. Probably less bad than the alternatives.
241 */
242 if (pItem2)
243 {
244 /* Manufacture a key down event. */
245 pItem2->u32UsageCode = u32Usage & ~0x80000000;
246 PDMQueueInsert(pDrv->pQueue, &pItem2->Core);
247 }
248 }
249
250 pItem->u32UsageCode = u32Usage;
251 PDMQueueInsert(pDrv->pQueue, &pItem->Core);
252
253 return VINF_SUCCESS;
254 }
255 if (!pDrv->fSuspended)
256 AssertMsgFailed(("drvKbdQueuePutEventScan: Queue is full!!!!\n"));
257 return VERR_PDM_NO_QUEUE_ITEMS;
258 }
259 else
260 return VINF_SUCCESS;
261}
262
263
264/* -=-=-=-=- IConnector -=-=-=-=- */
265
266#define PPDMIKEYBOARDCONNECTOR_2_DRVKBDQUEUE(pInterface) ( (PDRVKBDQUEUE)((char *)(pInterface) - RT_OFFSETOF(DRVKBDQUEUE, IConnector)) )
267
268
269/**
270 * Pass LED status changes from the guest thru to the frontend driver.
271 *
272 * @param pInterface Pointer to the keyboard connector interface structure.
273 * @param enmLeds The new LED mask.
274 */
275static DECLCALLBACK(void) drvKbdPassThruLedsChange(PPDMIKEYBOARDCONNECTOR pInterface, PDMKEYBLEDS enmLeds)
276{
277 PDRVKBDQUEUE pDrv = PPDMIKEYBOARDCONNECTOR_2_DRVKBDQUEUE(pInterface);
278 pDrv->pDownConnector->pfnLedStatusChange(pDrv->pDownConnector, enmLeds);
279}
280
281/**
282 * Pass keyboard state changes from the guest thru to the frontend driver.
283 *
284 * @param pInterface Pointer to the keyboard connector interface structure.
285 * @param fActive The new active/inactive state.
286 */
287static DECLCALLBACK(void) drvKbdPassThruSetActive(PPDMIKEYBOARDCONNECTOR pInterface, bool fActive)
288{
289 PDRVKBDQUEUE pDrv = PPDMIKEYBOARDCONNECTOR_2_DRVKBDQUEUE(pInterface);
290
291 AssertPtr(pDrv->pDownConnector->pfnSetActive);
292 pDrv->pDownConnector->pfnSetActive(pDrv->pDownConnector, fActive);
293}
294
295/**
296 * Flush the keyboard queue if there are pending events.
297 *
298 * @param pInterface Pointer to the keyboard connector interface structure.
299 */
300static DECLCALLBACK(void) drvKbdFlushQueue(PPDMIKEYBOARDCONNECTOR pInterface)
301{
302 PDRVKBDQUEUE pDrv = PPDMIKEYBOARDCONNECTOR_2_DRVKBDQUEUE(pInterface);
303
304 AssertPtr(pDrv->pQueue);
305 PDMQueueFlushIfNecessary(pDrv->pQueue);
306}
307
308
309/* -=-=-=-=- queue -=-=-=-=- */
310
311/**
312 * Queue callback for processing a queued item.
313 *
314 * @returns Success indicator.
315 * If false the item will not be removed and the flushing will stop.
316 * @param pDrvIns The driver instance.
317 * @param pItemCore Pointer to the queue item to process.
318 */
319static DECLCALLBACK(bool) drvKbdQueueConsumer(PPDMDRVINS pDrvIns, PPDMQUEUEITEMCORE pItemCore)
320{
321 PDRVKBDQUEUE pThis = PDMINS_2_DATA(pDrvIns, PDRVKBDQUEUE);
322 PDRVKBDQUEUEITEM pItem = (PDRVKBDQUEUEITEM)pItemCore;
323 int rc = pThis->pUpPort->pfnPutEventHid(pThis->pUpPort, pItem->u32UsageCode);
324 return RT_SUCCESS(rc);
325}
326
327
328/* -=-=-=-=- driver interface -=-=-=-=- */
329
330/**
331 * Power On notification.
332 *
333 * @returns VBox status code.
334 * @param pDrvIns The drive instance data.
335 */
336static DECLCALLBACK(void) drvKbdQueuePowerOn(PPDMDRVINS pDrvIns)
337{
338 PDRVKBDQUEUE pThis = PDMINS_2_DATA(pDrvIns, PDRVKBDQUEUE);
339 pThis->fInactive = false;
340}
341
342
343/**
344 * Reset notification.
345 *
346 * @returns VBox status code.
347 * @param pDrvIns The drive instance data.
348 */
349static DECLCALLBACK(void) drvKbdQueueReset(PPDMDRVINS pDrvIns)
350{
351 //PDRVKBDQUEUE pThis = PDMINS_2_DATA(pDrvIns, PDRVKBDQUEUE);
352 /** @todo purge the queue on reset. */
353 RT_NOREF(pDrvIns);
354}
355
356
357/**
358 * Suspend notification.
359 *
360 * @returns VBox status code.
361 * @param pDrvIns The drive instance data.
362 */
363static DECLCALLBACK(void) drvKbdQueueSuspend(PPDMDRVINS pDrvIns)
364{
365 PDRVKBDQUEUE pThis = PDMINS_2_DATA(pDrvIns, PDRVKBDQUEUE);
366 pThis->fSuspended = true;
367}
368
369
370/**
371 * Resume notification.
372 *
373 * @returns VBox status code.
374 * @param pDrvIns The drive instance data.
375 */
376static DECLCALLBACK(void) drvKbdQueueResume(PPDMDRVINS pDrvIns)
377{
378 PDRVKBDQUEUE pThis = PDMINS_2_DATA(pDrvIns, PDRVKBDQUEUE);
379 pThis->fInactive = false;
380 pThis->fSuspended = false;
381}
382
383
384/**
385 * Power Off notification.
386 *
387 * @param pDrvIns The drive instance data.
388 */
389static DECLCALLBACK(void) drvKbdQueuePowerOff(PPDMDRVINS pDrvIns)
390{
391 PDRVKBDQUEUE pThis = PDMINS_2_DATA(pDrvIns, PDRVKBDQUEUE);
392 pThis->fInactive = true;
393}
394
395
396/**
397 * Construct a keyboard driver instance.
398 *
399 * @copydoc FNPDMDRVCONSTRUCT
400 */
401static DECLCALLBACK(int) drvKbdQueueConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
402{
403 PDRVKBDQUEUE pDrv = PDMINS_2_DATA(pDrvIns, PDRVKBDQUEUE);
404 LogFlow(("drvKbdQueueConstruct: iInstance=%d\n", pDrvIns->iInstance));
405 PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
406
407 /*
408 * Validate configuration.
409 */
410 if (!CFGMR3AreValuesValid(pCfg, "QueueSize\0Interval\0"))
411 return VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES;
412
413 /*
414 * Init basic data members and interfaces.
415 */
416 pDrv->fInactive = true;
417 pDrv->fSuspended = false;
418 pDrv->XlatState = SS_IDLE;
419 /* IBase. */
420 pDrvIns->IBase.pfnQueryInterface = drvKbdQueueQueryInterface;
421 /* IKeyboardConnector. */
422 pDrv->IConnector.pfnLedStatusChange = drvKbdPassThruLedsChange;
423 pDrv->IConnector.pfnSetActive = drvKbdPassThruSetActive;
424 pDrv->IConnector.pfnFlushQueue = drvKbdFlushQueue;
425 /* IKeyboardPort. */
426 pDrv->IPort.pfnPutEventScan = drvKbdQueuePutEventScan;
427
428 /*
429 * Get the IKeyboardPort interface of the above driver/device.
430 */
431 pDrv->pUpPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIKEYBOARDPORT);
432 if (!pDrv->pUpPort)
433 {
434 AssertMsgFailed(("Configuration error: No keyboard port interface above!\n"));
435 return VERR_PDM_MISSING_INTERFACE_ABOVE;
436 }
437
438 /*
439 * Attach driver below and query it's connector interface.
440 */
441 PPDMIBASE pDownBase;
442 int rc = PDMDrvHlpAttach(pDrvIns, fFlags, &pDownBase);
443 if (RT_FAILURE(rc))
444 {
445 AssertMsgFailed(("Failed to attach driver below us! rc=%Rra\n", rc));
446 return rc;
447 }
448 pDrv->pDownConnector = PDMIBASE_QUERY_INTERFACE(pDownBase, PDMIKEYBOARDCONNECTOR);
449 if (!pDrv->pDownConnector)
450 {
451 AssertMsgFailed(("Configuration error: No keyboard connector interface below!\n"));
452 return VERR_PDM_MISSING_INTERFACE_BELOW;
453 }
454
455 /*
456 * Create the queue.
457 */
458 uint32_t cMilliesInterval = 0;
459 rc = CFGMR3QueryU32(pCfg, "Interval", &cMilliesInterval);
460 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
461 cMilliesInterval = 0;
462 else if (RT_FAILURE(rc))
463 {
464 AssertMsgFailed(("Configuration error: 32-bit \"Interval\" -> rc=%Rrc\n", rc));
465 return rc;
466 }
467
468 uint32_t cItems = 0;
469 rc = CFGMR3QueryU32(pCfg, "QueueSize", &cItems);
470 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
471 cItems = 128;
472 else if (RT_FAILURE(rc))
473 {
474 AssertMsgFailed(("Configuration error: 32-bit \"QueueSize\" -> rc=%Rrc\n", rc));
475 return rc;
476 }
477
478 rc = PDMDrvHlpQueueCreate(pDrvIns, sizeof(DRVKBDQUEUEITEM), cItems, cMilliesInterval, drvKbdQueueConsumer, "Keyboard", &pDrv->pQueue);
479 if (RT_FAILURE(rc))
480 {
481 AssertMsgFailed(("Failed to create driver: cItems=%d cMilliesInterval=%d rc=%Rrc\n", cItems, cMilliesInterval, rc));
482 return rc;
483 }
484
485 return VINF_SUCCESS;
486}
487
488
489/**
490 * Keyboard queue driver registration record.
491 */
492const PDMDRVREG g_DrvKeyboardQueue =
493{
494 /* u32Version */
495 PDM_DRVREG_VERSION,
496 /* szName */
497 "KeyboardQueue",
498 /* szRCMod */
499 "",
500 /* szR0Mod */
501 "",
502 /* pszDescription */
503 "Keyboard queue driver to plug in between the key source and the device to do queueing and inter-thread transport.",
504 /* fFlags */
505 PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
506 /* fClass. */
507 PDM_DRVREG_CLASS_KEYBOARD,
508 /* cMaxInstances */
509 ~0U,
510 /* cbInstance */
511 sizeof(DRVKBDQUEUE),
512 /* pfnConstruct */
513 drvKbdQueueConstruct,
514 /* pfnRelocate */
515 NULL,
516 /* pfnDestruct */
517 NULL,
518 /* pfnIOCtl */
519 NULL,
520 /* pfnPowerOn */
521 drvKbdQueuePowerOn,
522 /* pfnReset */
523 drvKbdQueueReset,
524 /* pfnSuspend */
525 drvKbdQueueSuspend,
526 /* pfnResume */
527 drvKbdQueueResume,
528 /* pfnAttach */
529 NULL,
530 /* pfnDetach */
531 NULL,
532 /* pfnPowerOff */
533 drvKbdQueuePowerOff,
534 /* pfnSoftReset */
535 NULL,
536 /* u32EndVersion */
537 PDM_DRVREG_VERSION
538};
539
Note: See TracBrowser for help on using the repository browser.

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