[1] | 1 | /** @file
|
---|
| 2 | *
|
---|
| 3 | * VirtualBox COM class implementation
|
---|
| 4 | */
|
---|
| 5 |
|
---|
| 6 | /*
|
---|
[8155] | 7 | * Copyright (C) 2006-2007 Sun Microsystems, Inc.
|
---|
[1] | 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
|
---|
[5999] | 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.
|
---|
[8155] | 16 | *
|
---|
| 17 | * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
|
---|
| 18 | * Clara, CA 95054 USA or visit http://www.sun.com if you need
|
---|
| 19 | * additional information or have any questions.
|
---|
[1] | 20 | */
|
---|
| 21 |
|
---|
| 22 | #include "KeyboardImpl.h"
|
---|
| 23 | #include "ConsoleImpl.h"
|
---|
| 24 |
|
---|
| 25 | #include "Logging.h"
|
---|
| 26 |
|
---|
[11661] | 27 | #include <VBox/com/array.h>
|
---|
[4015] | 28 | #include <VBox/pdmdrv.h>
|
---|
[1] | 29 | #include <iprt/asm.h>
|
---|
| 30 |
|
---|
| 31 | // defines
|
---|
| 32 | ////////////////////////////////////////////////////////////////////////////////
|
---|
| 33 |
|
---|
| 34 | // globals
|
---|
| 35 | ////////////////////////////////////////////////////////////////////////////////
|
---|
| 36 |
|
---|
| 37 | /**
|
---|
| 38 | * Keyboard driver instance data.
|
---|
| 39 | */
|
---|
| 40 | typedef struct DRVMAINKEYBOARD
|
---|
| 41 | {
|
---|
| 42 | /** Pointer to the keyboard object. */
|
---|
| 43 | Keyboard *pKeyboard;
|
---|
| 44 | /** Pointer to the driver instance structure. */
|
---|
| 45 | PPDMDRVINS pDrvIns;
|
---|
| 46 | /** Pointer to the keyboard port interface of the driver/device above us. */
|
---|
| 47 | PPDMIKEYBOARDPORT pUpPort;
|
---|
| 48 | /** Our mouse connector interface. */
|
---|
| 49 | PDMIKEYBOARDCONNECTOR Connector;
|
---|
| 50 | } DRVMAINKEYBOARD, *PDRVMAINKEYBOARD;
|
---|
| 51 |
|
---|
| 52 | /** Converts PDMIVMMDEVCONNECTOR pointer to a DRVMAINVMMDEV pointer. */
|
---|
| 53 | #define PPDMIKEYBOARDCONNECTOR_2_MAINKEYBOARD(pInterface) ( (PDRVMAINKEYBOARD) ((uintptr_t)pInterface - RT_OFFSETOF(DRVMAINKEYBOARD, Connector)) )
|
---|
| 54 |
|
---|
| 55 |
|
---|
| 56 | // constructor / destructor
|
---|
| 57 | ////////////////////////////////////////////////////////////////////////////////
|
---|
| 58 |
|
---|
| 59 | HRESULT Keyboard::FinalConstruct()
|
---|
| 60 | {
|
---|
| 61 | mParent = NULL;
|
---|
| 62 | mpDrv = NULL;
|
---|
| 63 | mpVMMDev = NULL;
|
---|
| 64 | mfVMMDevInited = false;
|
---|
| 65 | return S_OK;
|
---|
| 66 | }
|
---|
| 67 |
|
---|
| 68 | void Keyboard::FinalRelease()
|
---|
| 69 | {
|
---|
| 70 | if (isReady())
|
---|
| 71 | uninit();
|
---|
| 72 | }
|
---|
| 73 |
|
---|
| 74 | // public methods
|
---|
| 75 | ////////////////////////////////////////////////////////////////////////////////
|
---|
| 76 |
|
---|
| 77 | /**
|
---|
| 78 | * Initializes the keyboard object.
|
---|
| 79 | *
|
---|
| 80 | * @returns COM result indicator
|
---|
| 81 | * @param parent handle of our parent object
|
---|
| 82 | */
|
---|
| 83 | HRESULT Keyboard::init (Console *parent)
|
---|
| 84 | {
|
---|
| 85 | LogFlow(("Keyboard::init(): isReady=%d\n", isReady()));
|
---|
| 86 |
|
---|
| 87 | ComAssertRet (parent, E_INVALIDARG);
|
---|
| 88 |
|
---|
[8083] | 89 | AutoWriteLock alock (this);
|
---|
[1] | 90 | ComAssertRet (!isReady(), E_UNEXPECTED);
|
---|
| 91 |
|
---|
| 92 | mParent = parent;
|
---|
| 93 |
|
---|
| 94 | setReady (true);
|
---|
| 95 | return S_OK;
|
---|
| 96 | }
|
---|
| 97 |
|
---|
| 98 | /**
|
---|
| 99 | * Uninitializes the instance and sets the ready flag to FALSE.
|
---|
| 100 | * Called either from FinalRelease() or by the parent when it gets destroyed.
|
---|
| 101 | */
|
---|
| 102 | void Keyboard::uninit()
|
---|
| 103 | {
|
---|
| 104 | LogFlow(("Keyboard::uninit(): isReady=%d\n", isReady()));
|
---|
| 105 |
|
---|
[8083] | 106 | AutoWriteLock alock (this);
|
---|
[1] | 107 | AssertReturn (isReady(), (void) 0);
|
---|
| 108 |
|
---|
| 109 | if (mpDrv)
|
---|
| 110 | mpDrv->pKeyboard = NULL;
|
---|
| 111 | mpDrv = NULL;
|
---|
| 112 | mpVMMDev = NULL;
|
---|
| 113 | mfVMMDevInited = true;
|
---|
| 114 |
|
---|
| 115 | setReady (false);
|
---|
| 116 | }
|
---|
| 117 |
|
---|
| 118 | /**
|
---|
| 119 | * Sends a scancode to the keyboard.
|
---|
| 120 | *
|
---|
| 121 | * @returns COM status code
|
---|
| 122 | * @param scancode The scancode to send
|
---|
| 123 | */
|
---|
| 124 | STDMETHODIMP Keyboard::PutScancode(LONG scancode)
|
---|
| 125 | {
|
---|
[8083] | 126 | AutoWriteLock alock (this);
|
---|
[1] | 127 | CHECK_READY();
|
---|
| 128 |
|
---|
| 129 | CHECK_CONSOLE_DRV (mpDrv);
|
---|
| 130 |
|
---|
| 131 | int rcVBox = mpDrv->pUpPort->pfnPutEvent(mpDrv->pUpPort, (uint8_t)scancode);
|
---|
| 132 |
|
---|
| 133 | if (VBOX_FAILURE (rcVBox))
|
---|
| 134 | return setError (E_FAIL,
|
---|
| 135 | tr ("Could not send scan code 0x%08X to the virtual keyboard (%Vrc)"),
|
---|
| 136 | scancode, rcVBox);
|
---|
| 137 |
|
---|
| 138 | return S_OK;
|
---|
| 139 | }
|
---|
| 140 |
|
---|
| 141 | /**
|
---|
| 142 | * Sends a list of scancodes to the keyboard.
|
---|
| 143 | *
|
---|
| 144 | * @returns COM status code
|
---|
| 145 | * @param scancodes Pointer to the first scancode
|
---|
| 146 | * @param count Number of scancodes
|
---|
| 147 | * @param codesStored Address of variable to store the number
|
---|
| 148 | * of scancodes that were sent to the keyboard.
|
---|
| 149 | This value can be NULL.
|
---|
| 150 | */
|
---|
[11661] | 151 | STDMETHODIMP Keyboard::PutScancodes(ComSafeArrayIn (LONG, scancodes),
|
---|
[1] | 152 | ULONG *codesStored)
|
---|
| 153 | {
|
---|
[11661] | 154 | if (ComSafeArrayInIsNull(scancodes))
|
---|
[1] | 155 | return E_INVALIDARG;
|
---|
| 156 |
|
---|
[8083] | 157 | AutoWriteLock alock (this);
|
---|
[1] | 158 | CHECK_READY();
|
---|
| 159 |
|
---|
| 160 | CHECK_CONSOLE_DRV (mpDrv);
|
---|
| 161 |
|
---|
[11661] | 162 | com::SafeArray <LONG> keys(ComSafeArrayInArg(scancodes));
|
---|
[1] | 163 | int rcVBox = VINF_SUCCESS;
|
---|
| 164 |
|
---|
[11661] | 165 | for (uint32_t i = 0; (i < keys.size()) && VBOX_SUCCESS(rcVBox); i++)
|
---|
[1] | 166 | {
|
---|
[11661] | 167 | rcVBox = mpDrv->pUpPort->pfnPutEvent(mpDrv->pUpPort, (uint8_t)keys[i]);
|
---|
[1] | 168 | }
|
---|
| 169 |
|
---|
| 170 | if (VBOX_FAILURE (rcVBox))
|
---|
| 171 | return setError (E_FAIL,
|
---|
| 172 | tr ("Could not send all scan codes to the virtual keyboard (%Vrc)"), rcVBox);
|
---|
| 173 |
|
---|
| 174 | /// @todo is it actually possible that not all scancodes can be transmitted?
|
---|
| 175 | if (codesStored)
|
---|
[11661] | 176 | *codesStored = keys.size();
|
---|
[1] | 177 |
|
---|
| 178 | return S_OK;
|
---|
| 179 | }
|
---|
| 180 |
|
---|
| 181 | /**
|
---|
| 182 | * Sends Control-Alt-Delete to the keyboard. This could be done otherwise
|
---|
| 183 | * but it's so common that we'll be nice and supply a convenience API.
|
---|
| 184 | *
|
---|
| 185 | * @returns COM status code
|
---|
| 186 | *
|
---|
| 187 | */
|
---|
| 188 | STDMETHODIMP Keyboard::PutCAD()
|
---|
| 189 | {
|
---|
[11661] | 190 | static com::SafeArray<LONG> cadSequence(6);
|
---|
| 191 |
|
---|
| 192 | cadSequence[0] = 0x1d; // Ctrl down
|
---|
| 193 | cadSequence[1] = 0x38; // Alt down
|
---|
| 194 | cadSequence[2] = 0x53; // Del down
|
---|
| 195 | cadSequence[3] = 0xd3; // Del up
|
---|
| 196 | cadSequence[4] = 0xb8; // Alt up
|
---|
| 197 | cadSequence[5] = 0x9d; // Ctrl up
|
---|
[1] | 198 |
|
---|
[11661] | 199 | return PutScancodes (ComSafeArrayAsInParam(cadSequence), NULL);
|
---|
[1] | 200 | }
|
---|
| 201 |
|
---|
| 202 | //
|
---|
| 203 | // private methods
|
---|
| 204 | //
|
---|
| 205 |
|
---|
| 206 | /**
|
---|
| 207 | * Queries an interface to the driver.
|
---|
| 208 | *
|
---|
| 209 | * @returns Pointer to interface.
|
---|
| 210 | * @returns NULL if the interface was not supported by the driver.
|
---|
| 211 | * @param pInterface Pointer to this interface structure.
|
---|
| 212 | * @param enmInterface The requested interface identification.
|
---|
| 213 | */
|
---|
| 214 | DECLCALLBACK(void *) Keyboard::drvQueryInterface(PPDMIBASE pInterface, PDMINTERFACE enmInterface)
|
---|
| 215 | {
|
---|
| 216 | PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
|
---|
[11296] | 217 | PDRVMAINKEYBOARD pDrv = PDMINS_2_DATA(pDrvIns, PDRVMAINKEYBOARD);
|
---|
[1] | 218 | switch (enmInterface)
|
---|
| 219 | {
|
---|
| 220 | case PDMINTERFACE_BASE:
|
---|
| 221 | return &pDrvIns->IBase;
|
---|
| 222 | case PDMINTERFACE_KEYBOARD_CONNECTOR:
|
---|
| 223 | return &pDrv->Connector;
|
---|
| 224 | default:
|
---|
| 225 | return NULL;
|
---|
| 226 | }
|
---|
| 227 | }
|
---|
| 228 |
|
---|
| 229 |
|
---|
| 230 | /**
|
---|
| 231 | * Destruct a keyboard driver instance.
|
---|
| 232 | *
|
---|
| 233 | * @returns VBox status.
|
---|
| 234 | * @param pDrvIns The driver instance data.
|
---|
| 235 | */
|
---|
| 236 | DECLCALLBACK(void) Keyboard::drvDestruct(PPDMDRVINS pDrvIns)
|
---|
| 237 | {
|
---|
[11296] | 238 | PDRVMAINKEYBOARD pData = PDMINS_2_DATA(pDrvIns, PDRVMAINKEYBOARD);
|
---|
[1] | 239 | LogFlow(("Keyboard::drvDestruct: iInstance=%d\n", pDrvIns->iInstance));
|
---|
| 240 | if (pData->pKeyboard)
|
---|
| 241 | {
|
---|
[8083] | 242 | AutoWriteLock kbdLock (pData->pKeyboard);
|
---|
[1] | 243 | pData->pKeyboard->mpDrv = NULL;
|
---|
| 244 | pData->pKeyboard->mpVMMDev = NULL;
|
---|
| 245 | }
|
---|
| 246 | }
|
---|
| 247 |
|
---|
| 248 | DECLCALLBACK(void) keyboardLedStatusChange(PPDMIKEYBOARDCONNECTOR pInterface, PDMKEYBLEDS enmLeds)
|
---|
| 249 | {
|
---|
| 250 | PDRVMAINKEYBOARD pDrv = PPDMIKEYBOARDCONNECTOR_2_MAINKEYBOARD(pInterface);
|
---|
| 251 | pDrv->pKeyboard->getParent()->onKeyboardLedsChange(!!(enmLeds & PDMKEYBLEDS_NUMLOCK),
|
---|
| 252 | !!(enmLeds & PDMKEYBLEDS_CAPSLOCK),
|
---|
| 253 | !!(enmLeds & PDMKEYBLEDS_SCROLLLOCK));
|
---|
| 254 | }
|
---|
| 255 |
|
---|
| 256 | /**
|
---|
| 257 | * Construct a keyboard driver instance.
|
---|
| 258 | *
|
---|
| 259 | * @returns VBox status.
|
---|
| 260 | * @param pDrvIns The driver instance data.
|
---|
| 261 | * If the registration structure is needed, pDrvIns->pDrvReg points to it.
|
---|
| 262 | * @param pCfgHandle Configuration node handle for the driver. Use this to obtain the configuration
|
---|
| 263 | * of the driver instance. It's also found in pDrvIns->pCfgHandle, but like
|
---|
| 264 | * iInstance it's expected to be used a bit in this function.
|
---|
| 265 | */
|
---|
| 266 | DECLCALLBACK(int) Keyboard::drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfgHandle)
|
---|
| 267 | {
|
---|
[11296] | 268 | PDRVMAINKEYBOARD pData = PDMINS_2_DATA(pDrvIns, PDRVMAINKEYBOARD);
|
---|
[1] | 269 | LogFlow(("Keyboard::drvConstruct: iInstance=%d\n", pDrvIns->iInstance));
|
---|
| 270 |
|
---|
| 271 | /*
|
---|
| 272 | * Validate configuration.
|
---|
| 273 | */
|
---|
| 274 | if (!CFGMR3AreValuesValid(pCfgHandle, "Object\0"))
|
---|
| 275 | return VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES;
|
---|
| 276 | PPDMIBASE pBaseIgnore;
|
---|
| 277 | int rc = pDrvIns->pDrvHlp->pfnAttach(pDrvIns, &pBaseIgnore);
|
---|
| 278 | if (rc != VERR_PDM_NO_ATTACHED_DRIVER)
|
---|
| 279 | {
|
---|
| 280 | AssertMsgFailed(("Configuration error: Not possible to attach anything to this driver!\n"));
|
---|
| 281 | return VERR_PDM_DRVINS_NO_ATTACH;
|
---|
| 282 | }
|
---|
| 283 |
|
---|
| 284 | /*
|
---|
| 285 | * IBase.
|
---|
| 286 | */
|
---|
| 287 | pDrvIns->IBase.pfnQueryInterface = Keyboard::drvQueryInterface;
|
---|
| 288 |
|
---|
| 289 | pData->Connector.pfnLedStatusChange = keyboardLedStatusChange;
|
---|
| 290 |
|
---|
| 291 | /*
|
---|
| 292 | * Get the IKeyboardPort interface of the above driver/device.
|
---|
| 293 | */
|
---|
| 294 | pData->pUpPort = (PPDMIKEYBOARDPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_KEYBOARD_PORT);
|
---|
| 295 | if (!pData->pUpPort)
|
---|
| 296 | {
|
---|
| 297 | AssertMsgFailed(("Configuration error: No keyboard port interface above!\n"));
|
---|
| 298 | return VERR_PDM_MISSING_INTERFACE_ABOVE;
|
---|
| 299 | }
|
---|
| 300 |
|
---|
| 301 | /*
|
---|
| 302 | * Get the Keyboard object pointer and update the mpDrv member.
|
---|
| 303 | */
|
---|
| 304 | void *pv;
|
---|
| 305 | rc = CFGMR3QueryPtr(pCfgHandle, "Object", &pv);
|
---|
| 306 | if (VBOX_FAILURE(rc))
|
---|
| 307 | {
|
---|
| 308 | AssertMsgFailed(("Configuration error: No/bad \"Object\" value! rc=%Vrc\n", rc));
|
---|
| 309 | return rc;
|
---|
| 310 | }
|
---|
| 311 | pData->pKeyboard = (Keyboard *)pv; /** @todo Check this cast! */
|
---|
| 312 | pData->pKeyboard->mpDrv = pData;
|
---|
| 313 |
|
---|
| 314 | return VINF_SUCCESS;
|
---|
| 315 | }
|
---|
| 316 |
|
---|
| 317 |
|
---|
| 318 | /**
|
---|
| 319 | * Keyboard driver registration record.
|
---|
| 320 | */
|
---|
| 321 | const PDMDRVREG Keyboard::DrvReg =
|
---|
| 322 | {
|
---|
| 323 | /* u32Version */
|
---|
| 324 | PDM_DRVREG_VERSION,
|
---|
| 325 | /* szDriverName */
|
---|
| 326 | "MainKeyboard",
|
---|
| 327 | /* pszDescription */
|
---|
| 328 | "Main keyboard driver (Main as in the API).",
|
---|
| 329 | /* fFlags */
|
---|
| 330 | PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
|
---|
| 331 | /* fClass. */
|
---|
| 332 | PDM_DRVREG_CLASS_KEYBOARD,
|
---|
| 333 | /* cMaxInstances */
|
---|
| 334 | ~0,
|
---|
| 335 | /* cbInstance */
|
---|
| 336 | sizeof(DRVMAINKEYBOARD),
|
---|
| 337 | /* pfnConstruct */
|
---|
| 338 | Keyboard::drvConstruct,
|
---|
| 339 | /* pfnDestruct */
|
---|
| 340 | Keyboard::drvDestruct,
|
---|
| 341 | /* pfnIOCtl */
|
---|
| 342 | NULL,
|
---|
| 343 | /* pfnPowerOn */
|
---|
| 344 | NULL,
|
---|
| 345 | /* pfnReset */
|
---|
| 346 | NULL,
|
---|
| 347 | /* pfnSuspend */
|
---|
| 348 | NULL,
|
---|
| 349 | /* pfnResume */
|
---|
| 350 | NULL,
|
---|
| 351 | /* pfnDetach */
|
---|
| 352 | NULL
|
---|
| 353 | };
|
---|