[26970] | 1 | /* $Id: PDMUsb.cpp 49092 2013-10-14 22:01:16Z vboxsync $ */
|
---|
| 2 | /** @file
|
---|
| 3 | * PDM - Pluggable Device and Driver Manager, USB part.
|
---|
| 4 | */
|
---|
| 5 |
|
---|
| 6 | /*
|
---|
[44358] | 7 | * Copyright (C) 2006-2013 Oracle Corporation
|
---|
[26970] | 8 | *
|
---|
[27901] | 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.
|
---|
[26970] | 16 | */
|
---|
| 17 |
|
---|
| 18 |
|
---|
| 19 | /*******************************************************************************
|
---|
| 20 | * Header Files *
|
---|
| 21 | *******************************************************************************/
|
---|
| 22 | #define LOG_GROUP LOG_GROUP_PDM_DRIVER
|
---|
| 23 | #include "PDMInternal.h"
|
---|
[35346] | 24 | #include <VBox/vmm/pdm.h>
|
---|
[26970] | 25 | #include <VBox/vusb.h>
|
---|
[35346] | 26 | #include <VBox/vmm/mm.h>
|
---|
| 27 | #include <VBox/vmm/cfgm.h>
|
---|
| 28 | #include <VBox/vmm/vmm.h>
|
---|
[26970] | 29 | #include <VBox/sup.h>
|
---|
[35346] | 30 | #include <VBox/vmm/vm.h>
|
---|
[44351] | 31 | #include <VBox/vmm/uvm.h>
|
---|
[26970] | 32 | #include <VBox/version.h>
|
---|
| 33 | #include <VBox/err.h>
|
---|
| 34 |
|
---|
| 35 | #include <VBox/log.h>
|
---|
| 36 | #include <iprt/assert.h>
|
---|
| 37 | #include <iprt/thread.h>
|
---|
| 38 | #include <iprt/string.h>
|
---|
| 39 | #include <iprt/asm.h>
|
---|
| 40 | #include <iprt/alloc.h>
|
---|
| 41 | #include <iprt/alloca.h>
|
---|
| 42 | #include <iprt/path.h>
|
---|
| 43 | #include <iprt/uuid.h>
|
---|
| 44 |
|
---|
| 45 |
|
---|
| 46 | /*******************************************************************************
|
---|
| 47 | * Structures and Typedefs *
|
---|
| 48 | *******************************************************************************/
|
---|
| 49 | /**
|
---|
| 50 | * Internal callback structure pointer.
|
---|
| 51 | *
|
---|
| 52 | * The main purpose is to define the extra data we associate
|
---|
| 53 | * with PDMUSBREGCB so we can find the VM instance and so on.
|
---|
| 54 | */
|
---|
| 55 | typedef struct PDMUSBREGCBINT
|
---|
| 56 | {
|
---|
| 57 | /** The callback structure. */
|
---|
| 58 | PDMUSBREGCB Core;
|
---|
| 59 | /** A bit of padding. */
|
---|
| 60 | uint32_t u32[4];
|
---|
| 61 | /** VM Handle. */
|
---|
| 62 | PVM pVM;
|
---|
| 63 | } PDMUSBREGCBINT, *PPDMUSBREGCBINT;
|
---|
| 64 | typedef const PDMUSBREGCBINT *PCPDMUSBREGCBINT;
|
---|
| 65 |
|
---|
| 66 |
|
---|
| 67 | /*******************************************************************************
|
---|
| 68 | * Defined Constants And Macros *
|
---|
| 69 | *******************************************************************************/
|
---|
| 70 | /** @def PDMUSB_ASSERT_USBINS
|
---|
| 71 | * Asserts the validity of the USB device instance.
|
---|
| 72 | */
|
---|
| 73 | #ifdef VBOX_STRICT
|
---|
| 74 | # define PDMUSB_ASSERT_USBINS(pUsbIns) \
|
---|
| 75 | do { \
|
---|
| 76 | AssertPtr(pUsbIns); \
|
---|
| 77 | Assert(pUsbIns->u32Version == PDM_USBINS_VERSION); \
|
---|
| 78 | Assert(pUsbIns->pvInstanceDataR3 == (void *)&pUsbIns->achInstanceData[0]); \
|
---|
| 79 | } while (0)
|
---|
| 80 | #else
|
---|
| 81 | # define PDMUSB_ASSERT_USBINS(pUsbIns) do { } while (0)
|
---|
| 82 | #endif
|
---|
| 83 |
|
---|
| 84 |
|
---|
| 85 | /*******************************************************************************
|
---|
| 86 | * Internal Functions *
|
---|
| 87 | *******************************************************************************/
|
---|
| 88 | static void pdmR3UsbDestroyDevice(PVM pVM, PPDMUSBINS pUsbIns);
|
---|
| 89 |
|
---|
| 90 |
|
---|
| 91 | /*******************************************************************************
|
---|
| 92 | * Global Variables *
|
---|
| 93 | *******************************************************************************/
|
---|
| 94 | extern const PDMUSBHLP g_pdmR3UsbHlp;
|
---|
| 95 |
|
---|
| 96 |
|
---|
| 97 | AssertCompile(sizeof(PDMUSBINSINT) <= RT_SIZEOFMEMB(PDMUSBINS, Internal.padding));
|
---|
| 98 |
|
---|
| 99 |
|
---|
| 100 | /**
|
---|
| 101 | * Registers a USB hub driver.
|
---|
| 102 | *
|
---|
| 103 | * @returns VBox status code.
|
---|
[41783] | 104 | * @param pVM Pointer to the VM.
|
---|
[26970] | 105 | * @param pDrvIns The driver instance of the hub.
|
---|
| 106 | * @param fVersions Indicates the kinds of USB devices that can be attached to this HUB.
|
---|
| 107 | * @param cPorts The number of ports.
|
---|
| 108 | * @param pUsbHubReg The hub callback structure that PDMUsb uses to interact with it.
|
---|
| 109 | * @param ppUsbHubHlp The helper callback structure that the hub uses to talk to PDMUsb.
|
---|
| 110 | * @thread EMT
|
---|
| 111 | */
|
---|
| 112 | int pdmR3UsbRegisterHub(PVM pVM, PPDMDRVINS pDrvIns, uint32_t fVersions, uint32_t cPorts, PCPDMUSBHUBREG pUsbHubReg, PPCPDMUSBHUBHLP ppUsbHubHlp)
|
---|
| 113 | {
|
---|
| 114 | /*
|
---|
| 115 | * Validate input.
|
---|
| 116 | */
|
---|
| 117 | /* The driver must be in the USB class. */
|
---|
| 118 | if (!(pDrvIns->pReg->fClass & PDM_DRVREG_CLASS_USB))
|
---|
| 119 | {
|
---|
| 120 | LogRel(("pdmR3UsbRegisterHub: fClass=%#x expected %#x to be set\n", pDrvIns->pReg->fClass, PDM_DRVREG_CLASS_USB));
|
---|
| 121 | return VERR_INVALID_PARAMETER;
|
---|
| 122 | }
|
---|
| 123 | AssertMsgReturn(!(fVersions & ~(VUSB_STDVER_11 | VUSB_STDVER_20)), ("%#x\n", fVersions), VERR_INVALID_PARAMETER);
|
---|
| 124 | AssertPtrReturn(ppUsbHubHlp, VERR_INVALID_POINTER);
|
---|
| 125 | AssertPtrReturn(pUsbHubReg, VERR_INVALID_POINTER);
|
---|
| 126 | AssertReturn(pUsbHubReg->u32Version == PDM_USBHUBREG_VERSION, VERR_INVALID_MAGIC);
|
---|
| 127 | AssertReturn(pUsbHubReg->u32TheEnd == PDM_USBHUBREG_VERSION, VERR_INVALID_MAGIC);
|
---|
| 128 | AssertPtrReturn(pUsbHubReg->pfnAttachDevice, VERR_INVALID_PARAMETER);
|
---|
| 129 | AssertPtrReturn(pUsbHubReg->pfnDetachDevice, VERR_INVALID_PARAMETER);
|
---|
| 130 |
|
---|
| 131 | /*
|
---|
| 132 | * Check for duplicate registration and find the last hub for FIFO registration.
|
---|
| 133 | */
|
---|
| 134 | PPDMUSBHUB pPrev = NULL;
|
---|
| 135 | for (PPDMUSBHUB pCur = pVM->pdm.s.pUsbHubs; pCur; pCur = pCur->pNext)
|
---|
| 136 | {
|
---|
| 137 | if (pCur->pDrvIns == pDrvIns)
|
---|
| 138 | return VERR_PDM_USB_HUB_EXISTS;
|
---|
| 139 | pPrev = pCur;
|
---|
| 140 | }
|
---|
| 141 |
|
---|
| 142 | /*
|
---|
| 143 | * Create an internal USB hub structure.
|
---|
| 144 | */
|
---|
| 145 | PPDMUSBHUB pHub = (PPDMUSBHUB)MMR3HeapAlloc(pVM, MM_TAG_PDM_DRIVER, sizeof(*pHub));
|
---|
| 146 | if (!pHub)
|
---|
| 147 | return VERR_NO_MEMORY;
|
---|
| 148 |
|
---|
| 149 | pHub->fVersions = fVersions;
|
---|
| 150 | pHub->cPorts = cPorts;
|
---|
| 151 | pHub->cAvailablePorts = cPorts;
|
---|
| 152 | pHub->pDrvIns = pDrvIns;
|
---|
| 153 | pHub->Reg = *pUsbHubReg;
|
---|
| 154 | pHub->pNext = NULL;
|
---|
| 155 |
|
---|
| 156 | /* link it */
|
---|
| 157 | if (pPrev)
|
---|
| 158 | pPrev->pNext = pHub;
|
---|
| 159 | else
|
---|
| 160 | pVM->pdm.s.pUsbHubs = pHub;
|
---|
| 161 |
|
---|
| 162 | Log(("PDM: Registered USB hub %p/%s\n", pDrvIns, pDrvIns->pReg->szName));
|
---|
| 163 | return VINF_SUCCESS;
|
---|
| 164 | }
|
---|
| 165 |
|
---|
| 166 |
|
---|
| 167 | /**
|
---|
| 168 | * Loads one device module and call the registration entry point.
|
---|
| 169 | *
|
---|
| 170 | * @returns VBox status code.
|
---|
[41800] | 171 | * @param pVM Pointer to the VM.
|
---|
[26970] | 172 | * @param pRegCB The registration callback stuff.
|
---|
| 173 | * @param pszFilename Module filename.
|
---|
| 174 | * @param pszName Module name.
|
---|
| 175 | */
|
---|
| 176 | static int pdmR3UsbLoad(PVM pVM, PCPDMUSBREGCBINT pRegCB, const char *pszFilename, const char *pszName)
|
---|
| 177 | {
|
---|
| 178 | /*
|
---|
| 179 | * Load it.
|
---|
| 180 | */
|
---|
| 181 | int rc = pdmR3LoadR3U(pVM->pUVM, pszFilename, pszName);
|
---|
| 182 | if (RT_SUCCESS(rc))
|
---|
| 183 | {
|
---|
| 184 | /*
|
---|
| 185 | * Get the registration export and call it.
|
---|
| 186 | */
|
---|
| 187 | FNPDMVBOXUSBREGISTER *pfnVBoxUsbRegister;
|
---|
| 188 | rc = PDMR3LdrGetSymbolR3(pVM, pszName, "VBoxUsbRegister", (void **)&pfnVBoxUsbRegister);
|
---|
| 189 | if (RT_SUCCESS(rc))
|
---|
| 190 | {
|
---|
| 191 | Log(("PDM: Calling VBoxUsbRegister (%p) of %s (%s)\n", pfnVBoxUsbRegister, pszName, pszFilename));
|
---|
| 192 | rc = pfnVBoxUsbRegister(&pRegCB->Core, VBOX_VERSION);
|
---|
| 193 | if (RT_SUCCESS(rc))
|
---|
| 194 | Log(("PDM: Successfully loaded device module %s (%s).\n", pszName, pszFilename));
|
---|
| 195 | else
|
---|
| 196 | AssertMsgFailed(("VBoxDevicesRegister failed with rc=%Rrc for module %s (%s)\n", rc, pszName, pszFilename));
|
---|
| 197 | }
|
---|
| 198 | else
|
---|
| 199 | {
|
---|
| 200 | AssertMsgFailed(("Failed to locate 'VBoxUsbRegister' in %s (%s) rc=%Rrc\n", pszName, pszFilename, rc));
|
---|
| 201 | if (rc == VERR_SYMBOL_NOT_FOUND)
|
---|
| 202 | rc = VERR_PDM_NO_REGISTRATION_EXPORT;
|
---|
| 203 | }
|
---|
| 204 | }
|
---|
| 205 | else
|
---|
| 206 | AssertMsgFailed(("Failed to load VBoxDD!\n"));
|
---|
| 207 | return rc;
|
---|
| 208 | }
|
---|
| 209 |
|
---|
| 210 |
|
---|
| 211 |
|
---|
| 212 | /**
|
---|
| 213 | * @interface_method_impl{PDMUSBREGCB,pfnRegister}
|
---|
| 214 | */
|
---|
| 215 | static DECLCALLBACK(int) pdmR3UsbReg_Register(PCPDMUSBREGCB pCallbacks, PCPDMUSBREG pReg)
|
---|
| 216 | {
|
---|
| 217 | /*
|
---|
| 218 | * Validate the registration structure.
|
---|
| 219 | */
|
---|
| 220 | Assert(pReg);
|
---|
| 221 | AssertMsgReturn(pReg->u32Version == PDM_USBREG_VERSION,
|
---|
| 222 | ("Unknown struct version %#x!\n", pReg->u32Version),
|
---|
| 223 | VERR_PDM_UNKNOWN_USBREG_VERSION);
|
---|
| 224 | AssertMsgReturn( pReg->szName[0]
|
---|
[39839] | 225 | && strlen(pReg->szName) < sizeof(pReg->szName)
|
---|
| 226 | && pdmR3IsValidName(pReg->szName),
|
---|
| 227 | ("Invalid name '%.s'\n", sizeof(pReg->szName), pReg->szName),
|
---|
[26970] | 228 | VERR_PDM_INVALID_USB_REGISTRATION);
|
---|
[49092] | 229 | AssertMsgReturn((pReg->fFlags & ~(PDM_USBREG_HIGHSPEED_CAPABLE | PDM_USBREG_EMULATED_DEVICE)) == 0,
|
---|
[43814] | 230 | ("fFlags=%#x\n", pReg->fFlags), VERR_PDM_INVALID_USB_REGISTRATION);
|
---|
[26970] | 231 | AssertMsgReturn(pReg->cMaxInstances > 0,
|
---|
| 232 | ("Max instances %u! (USB Device %s)\n", pReg->cMaxInstances, pReg->szName),
|
---|
| 233 | VERR_PDM_INVALID_USB_REGISTRATION);
|
---|
| 234 | AssertMsgReturn(pReg->cbInstance <= _1M,
|
---|
| 235 | ("Instance size %d bytes! (USB Device %s)\n", pReg->cbInstance, pReg->szName),
|
---|
| 236 | VERR_PDM_INVALID_USB_REGISTRATION);
|
---|
[33595] | 237 | AssertMsgReturn(pReg->pfnConstruct, ("No constructor! (USB Device %s)\n", pReg->szName),
|
---|
[26970] | 238 | VERR_PDM_INVALID_USB_REGISTRATION);
|
---|
| 239 |
|
---|
| 240 | /*
|
---|
| 241 | * Check for duplicate and find FIFO entry at the same time.
|
---|
| 242 | */
|
---|
| 243 | PCPDMUSBREGCBINT pRegCB = (PCPDMUSBREGCBINT)pCallbacks;
|
---|
| 244 | PPDMUSB pUsbPrev = NULL;
|
---|
| 245 | PPDMUSB pUsb = pRegCB->pVM->pdm.s.pUsbDevs;
|
---|
| 246 | for (; pUsb; pUsbPrev = pUsb, pUsb = pUsb->pNext)
|
---|
| 247 | AssertMsgReturn(strcmp(pUsb->pReg->szName, pReg->szName),
|
---|
| 248 | ("USB Device '%s' already exists\n", pReg->szName),
|
---|
| 249 | VERR_PDM_USB_NAME_CLASH);
|
---|
| 250 |
|
---|
| 251 | /*
|
---|
| 252 | * Allocate new device structure and insert it into the list.
|
---|
| 253 | */
|
---|
| 254 | pUsb = (PPDMUSB)MMR3HeapAlloc(pRegCB->pVM, MM_TAG_PDM_DEVICE, sizeof(*pUsb));
|
---|
| 255 | if (pUsb)
|
---|
| 256 | {
|
---|
| 257 | pUsb->pNext = NULL;
|
---|
| 258 | pUsb->iNextInstance = 0;
|
---|
| 259 | pUsb->pInstances = NULL;
|
---|
| 260 | pUsb->pReg = pReg;
|
---|
| 261 | pUsb->cchName = (RTUINT)strlen(pReg->szName);
|
---|
| 262 |
|
---|
| 263 | if (pUsbPrev)
|
---|
| 264 | pUsbPrev->pNext = pUsb;
|
---|
| 265 | else
|
---|
| 266 | pRegCB->pVM->pdm.s.pUsbDevs = pUsb;
|
---|
| 267 | Log(("PDM: Registered USB device '%s'\n", pReg->szName));
|
---|
| 268 | return VINF_SUCCESS;
|
---|
| 269 | }
|
---|
| 270 | return VERR_NO_MEMORY;
|
---|
| 271 | }
|
---|
| 272 |
|
---|
| 273 |
|
---|
| 274 | /**
|
---|
| 275 | * Load USB Device modules.
|
---|
| 276 | *
|
---|
| 277 | * This is called by pdmR3DevInit() after it has loaded it's device modules.
|
---|
| 278 | *
|
---|
| 279 | * @returns VBox status code.
|
---|
[41783] | 280 | * @param pVM Pointer to the VM.
|
---|
[26970] | 281 | */
|
---|
| 282 | int pdmR3UsbLoadModules(PVM pVM)
|
---|
| 283 | {
|
---|
| 284 | LogFlow(("pdmR3UsbLoadModules:\n"));
|
---|
| 285 |
|
---|
| 286 | AssertRelease(!(RT_OFFSETOF(PDMUSBINS, achInstanceData) & 15));
|
---|
| 287 | AssertRelease(sizeof(pVM->pdm.s.pUsbInstances->Internal.s) <= sizeof(pVM->pdm.s.pUsbInstances->Internal.padding));
|
---|
| 288 |
|
---|
| 289 | /*
|
---|
| 290 | * Initialize the callback structure.
|
---|
| 291 | */
|
---|
| 292 | PDMUSBREGCBINT RegCB;
|
---|
| 293 | RegCB.Core.u32Version = PDM_USBREG_CB_VERSION;
|
---|
| 294 | RegCB.Core.pfnRegister = pdmR3UsbReg_Register;
|
---|
| 295 | RegCB.pVM = pVM;
|
---|
| 296 |
|
---|
| 297 | /*
|
---|
| 298 | * Load the builtin module
|
---|
| 299 | */
|
---|
| 300 | PCFGMNODE pUsbNode = CFGMR3GetChild(CFGMR3GetRoot(pVM), "PDM/USB/");
|
---|
| 301 | bool fLoadBuiltin;
|
---|
| 302 | int rc = CFGMR3QueryBool(pUsbNode, "LoadBuiltin", &fLoadBuiltin);
|
---|
| 303 | if (rc == VERR_CFGM_VALUE_NOT_FOUND || rc == VERR_CFGM_NO_PARENT)
|
---|
| 304 | fLoadBuiltin = true;
|
---|
| 305 | else if (RT_FAILURE(rc))
|
---|
| 306 | {
|
---|
| 307 | AssertMsgFailed(("Configuration error: Querying boolean \"LoadBuiltin\" failed with %Rrc\n", rc));
|
---|
| 308 | return rc;
|
---|
| 309 | }
|
---|
| 310 | if (fLoadBuiltin)
|
---|
| 311 | {
|
---|
| 312 | /* make filename */
|
---|
[34241] | 313 | char *pszFilename = pdmR3FileR3("VBoxDD", true /*fShared*/);
|
---|
[26970] | 314 | if (!pszFilename)
|
---|
| 315 | return VERR_NO_TMP_MEMORY;
|
---|
| 316 | rc = pdmR3UsbLoad(pVM, &RegCB, pszFilename, "VBoxDD");
|
---|
| 317 | RTMemTmpFree(pszFilename);
|
---|
| 318 | if (RT_FAILURE(rc))
|
---|
| 319 | return rc;
|
---|
| 320 | }
|
---|
| 321 |
|
---|
| 322 | /*
|
---|
| 323 | * Load additional device modules.
|
---|
| 324 | */
|
---|
| 325 | PCFGMNODE pCur;
|
---|
| 326 | for (pCur = CFGMR3GetFirstChild(pUsbNode); pCur; pCur = CFGMR3GetNextChild(pCur))
|
---|
| 327 | {
|
---|
| 328 | /*
|
---|
| 329 | * Get the name and path.
|
---|
| 330 | */
|
---|
| 331 | char szName[PDMMOD_NAME_LEN];
|
---|
| 332 | rc = CFGMR3GetName(pCur, &szName[0], sizeof(szName));
|
---|
| 333 | if (rc == VERR_CFGM_NOT_ENOUGH_SPACE)
|
---|
| 334 | {
|
---|
| 335 | AssertMsgFailed(("configuration error: The module name is too long, cchName=%zu.\n", CFGMR3GetNameLen(pCur)));
|
---|
| 336 | return VERR_PDM_MODULE_NAME_TOO_LONG;
|
---|
| 337 | }
|
---|
| 338 | else if (RT_FAILURE(rc))
|
---|
| 339 | {
|
---|
| 340 | AssertMsgFailed(("CFGMR3GetName -> %Rrc.\n", rc));
|
---|
| 341 | return rc;
|
---|
| 342 | }
|
---|
| 343 |
|
---|
| 344 | /* the path is optional, if no path the module name + path is used. */
|
---|
| 345 | char szFilename[RTPATH_MAX];
|
---|
| 346 | rc = CFGMR3QueryString(pCur, "Path", &szFilename[0], sizeof(szFilename));
|
---|
| 347 | if (rc == VERR_CFGM_VALUE_NOT_FOUND)
|
---|
| 348 | strcpy(szFilename, szName);
|
---|
| 349 | else if (RT_FAILURE(rc))
|
---|
| 350 | {
|
---|
| 351 | AssertMsgFailed(("configuration error: Failure to query the module path, rc=%Rrc.\n", rc));
|
---|
| 352 | return rc;
|
---|
| 353 | }
|
---|
| 354 |
|
---|
| 355 | /* prepend path? */
|
---|
| 356 | if (!RTPathHavePath(szFilename))
|
---|
| 357 | {
|
---|
[34241] | 358 | char *psz = pdmR3FileR3(szFilename, false /*fShared*/);
|
---|
[26970] | 359 | if (!psz)
|
---|
| 360 | return VERR_NO_TMP_MEMORY;
|
---|
| 361 | size_t cch = strlen(psz) + 1;
|
---|
| 362 | if (cch > sizeof(szFilename))
|
---|
| 363 | {
|
---|
| 364 | RTMemTmpFree(psz);
|
---|
| 365 | AssertMsgFailed(("Filename too long! cch=%d '%s'\n", cch, psz));
|
---|
| 366 | return VERR_FILENAME_TOO_LONG;
|
---|
| 367 | }
|
---|
| 368 | memcpy(szFilename, psz, cch);
|
---|
| 369 | RTMemTmpFree(psz);
|
---|
| 370 | }
|
---|
| 371 |
|
---|
| 372 | /*
|
---|
| 373 | * Load the module and register it's devices.
|
---|
| 374 | */
|
---|
| 375 | rc = pdmR3UsbLoad(pVM, &RegCB, szFilename, szName);
|
---|
| 376 | if (RT_FAILURE(rc))
|
---|
| 377 | return rc;
|
---|
| 378 | }
|
---|
| 379 |
|
---|
| 380 | return VINF_SUCCESS;
|
---|
| 381 | }
|
---|
| 382 |
|
---|
| 383 |
|
---|
| 384 | /**
|
---|
| 385 | * Send the init-complete notification to all the USB devices.
|
---|
| 386 | *
|
---|
[33540] | 387 | * This is called from pdmR3DevInit() after it has do its notification round.
|
---|
[26970] | 388 | *
|
---|
| 389 | * @returns VBox status code.
|
---|
[41783] | 390 | * @param pVM Pointer to the VM.
|
---|
[26970] | 391 | */
|
---|
| 392 | int pdmR3UsbVMInitComplete(PVM pVM)
|
---|
| 393 | {
|
---|
| 394 | for (PPDMUSBINS pUsbIns = pVM->pdm.s.pUsbInstances; pUsbIns; pUsbIns = pUsbIns->Internal.s.pNext)
|
---|
| 395 | {
|
---|
| 396 | if (pUsbIns->pReg->pfnVMInitComplete)
|
---|
| 397 | {
|
---|
| 398 | int rc = pUsbIns->pReg->pfnVMInitComplete(pUsbIns);
|
---|
| 399 | if (RT_FAILURE(rc))
|
---|
| 400 | {
|
---|
| 401 | AssertMsgFailed(("InitComplete on USB device '%s'/%d failed with rc=%Rrc\n",
|
---|
| 402 | pUsbIns->pReg->szName, pUsbIns->iInstance, rc));
|
---|
| 403 | return rc;
|
---|
| 404 | }
|
---|
| 405 | }
|
---|
| 406 | }
|
---|
| 407 | return VINF_SUCCESS;
|
---|
| 408 | }
|
---|
| 409 |
|
---|
| 410 |
|
---|
| 411 | /**
|
---|
| 412 | * Lookups a device structure by name.
|
---|
| 413 | * @internal
|
---|
| 414 | */
|
---|
| 415 | PPDMUSB pdmR3UsbLookup(PVM pVM, const char *pszName)
|
---|
| 416 | {
|
---|
| 417 | size_t cchName = strlen(pszName);
|
---|
| 418 | for (PPDMUSB pUsb = pVM->pdm.s.pUsbDevs; pUsb; pUsb = pUsb->pNext)
|
---|
| 419 | if ( pUsb->cchName == cchName
|
---|
| 420 | && !strcmp(pUsb->pReg->szName, pszName))
|
---|
| 421 | return pUsb;
|
---|
| 422 | return NULL;
|
---|
| 423 | }
|
---|
| 424 |
|
---|
| 425 |
|
---|
| 426 | /**
|
---|
| 427 | * Locates a suitable hub for the specified kind of device.
|
---|
| 428 | *
|
---|
| 429 | * @returns VINF_SUCCESS and *ppHub on success.
|
---|
| 430 | * VERR_PDM_NO_USB_HUBS or VERR_PDM_NO_USB_PORTS on failure.
|
---|
[41783] | 431 | * @param pVM Pointer to the VM.
|
---|
[26970] | 432 | * @param iUsbVersion The USB device version.
|
---|
| 433 | * @param ppHub Where to store the pointer to the USB hub.
|
---|
| 434 | */
|
---|
| 435 | static int pdmR3UsbFindHub(PVM pVM, uint32_t iUsbVersion, PPDMUSBHUB *ppHub)
|
---|
| 436 | {
|
---|
| 437 | *ppHub = NULL;
|
---|
| 438 | if (!pVM->pdm.s.pUsbHubs)
|
---|
| 439 | return VERR_PDM_NO_USB_HUBS;
|
---|
| 440 |
|
---|
| 441 | for (PPDMUSBHUB pCur = pVM->pdm.s.pUsbHubs; pCur; pCur = pCur->pNext)
|
---|
| 442 | if ( pCur->cAvailablePorts > 0
|
---|
| 443 | && ( (pCur->fVersions & iUsbVersion)
|
---|
| 444 | || pCur->fVersions == VUSB_STDVER_11))
|
---|
| 445 | {
|
---|
| 446 | *ppHub = pCur;
|
---|
| 447 | if (pCur->fVersions & iUsbVersion)
|
---|
| 448 | break;
|
---|
| 449 | }
|
---|
| 450 | if (*ppHub)
|
---|
| 451 | return VINF_SUCCESS;
|
---|
| 452 | return VERR_PDM_NO_USB_PORTS;
|
---|
| 453 | }
|
---|
| 454 |
|
---|
| 455 |
|
---|
| 456 | /**
|
---|
| 457 | * Creates the device.
|
---|
| 458 | *
|
---|
| 459 | * @returns VBox status code.
|
---|
[41783] | 460 | * @param pVM Pointer to the VM.
|
---|
[26970] | 461 | * @param pUsbDev The USB device emulation.
|
---|
| 462 | * @param iInstance -1 if not called by pdmR3UsbInstantiateDevices().
|
---|
| 463 | * @param pUuid The UUID for this device.
|
---|
[48234] | 464 | * @param ppInstanceNode Pointer to the device instance pointer. This is set to NULL if inserted
|
---|
[26970] | 465 | * into the tree or cleaned up.
|
---|
| 466 | *
|
---|
[48234] | 467 | * In the pdmR3UsbInstantiateDevices() case (iInstance != -1) this is
|
---|
| 468 | * the actual instance node and will not be cleaned up.
|
---|
[26970] | 469 | *
|
---|
[33540] | 470 | * @parma iUsbVersion The USB version preferred by the device.
|
---|
[26970] | 471 | */
|
---|
[39078] | 472 | static int pdmR3UsbCreateDevice(PVM pVM, PPDMUSBHUB pHub, PPDMUSB pUsbDev, int iInstance, PCRTUUID pUuid,
|
---|
[48234] | 473 | PCFGMNODE *ppInstanceNode, uint32_t iUsbVersion)
|
---|
[26970] | 474 | {
|
---|
[48234] | 475 | const bool fAtRuntime = iInstance == -1;
|
---|
[26970] | 476 | int rc;
|
---|
| 477 |
|
---|
[48234] | 478 | AssertPtrReturn(ppInstanceNode, VERR_INVALID_POINTER);
|
---|
| 479 | AssertPtrReturn(*ppInstanceNode, VERR_INVALID_POINTER);
|
---|
| 480 |
|
---|
[26970] | 481 | /*
|
---|
| 482 | * If not called by pdmR3UsbInstantiateDevices(), we'll have to fix
|
---|
| 483 | * the configuration now.
|
---|
| 484 | */
|
---|
| 485 | /* USB device node. */
|
---|
| 486 | PCFGMNODE pDevNode = CFGMR3GetChildF(CFGMR3GetRoot(pVM), "USB/%s/", pUsbDev->pReg->szName);
|
---|
| 487 | if (!pDevNode)
|
---|
| 488 | {
|
---|
| 489 | rc = CFGMR3InsertNodeF(CFGMR3GetRoot(pVM), &pDevNode, "USB/%s/", pUsbDev->pReg->szName);
|
---|
| 490 | AssertRCReturn(rc, rc);
|
---|
| 491 | }
|
---|
| 492 |
|
---|
| 493 | /* The instance node and number. */
|
---|
[48234] | 494 | PCFGMNODE pInstanceToDelete = NULL;
|
---|
| 495 | PCFGMNODE pInstanceNode = NULL;
|
---|
| 496 | if (fAtRuntime)
|
---|
[26970] | 497 | {
|
---|
[48234] | 498 | /** @todo r=bird: This code is bogus as it ASSUMES that all USB devices are
|
---|
| 499 | * capable of infinite number of instances. */
|
---|
[26970] | 500 | for (unsigned c = 0; c < _2M; c++)
|
---|
| 501 | {
|
---|
| 502 | iInstance = pUsbDev->iNextInstance++;
|
---|
| 503 | rc = CFGMR3InsertNodeF(pDevNode, &pInstanceNode, "%d/", iInstance);
|
---|
| 504 | if (rc != VERR_CFGM_NODE_EXISTS)
|
---|
| 505 | break;
|
---|
| 506 | }
|
---|
| 507 | AssertRCReturn(rc, rc);
|
---|
[48234] | 508 |
|
---|
| 509 | rc = CFGMR3ReplaceSubTree(pInstanceNode, *ppInstanceNode);
|
---|
| 510 | AssertRCReturn(rc, rc);
|
---|
| 511 | *ppInstanceNode = NULL;
|
---|
| 512 | pInstanceToDelete = pInstanceNode;
|
---|
[26970] | 513 | }
|
---|
| 514 | else
|
---|
| 515 | {
|
---|
| 516 | Assert(iInstance >= 0);
|
---|
| 517 | if (iInstance >= (int)pUsbDev->iNextInstance)
|
---|
| 518 | pUsbDev->iNextInstance = iInstance + 1;
|
---|
[48234] | 519 | pInstanceNode = *ppInstanceNode;
|
---|
[26970] | 520 | }
|
---|
| 521 |
|
---|
[48234] | 522 | /* Make sure the instance config node exists. */
|
---|
| 523 | PCFGMNODE pConfig = CFGMR3GetChild(pInstanceNode, "Config");
|
---|
| 524 | if (!pConfig)
|
---|
[26970] | 525 | {
|
---|
| 526 | rc = CFGMR3InsertNode(pInstanceNode, "Config", &pConfig);
|
---|
| 527 | AssertRCReturn(rc, rc);
|
---|
| 528 | }
|
---|
| 529 | Assert(CFGMR3GetChild(pInstanceNode, "Config") == pConfig);
|
---|
| 530 |
|
---|
| 531 | /* The global device config node. */
|
---|
| 532 | PCFGMNODE pGlobalConfig = CFGMR3GetChild(pDevNode, "GlobalConfig");
|
---|
| 533 | if (!pGlobalConfig)
|
---|
| 534 | {
|
---|
| 535 | rc = CFGMR3InsertNode(pDevNode, "GlobalConfig", &pGlobalConfig);
|
---|
| 536 | if (RT_FAILURE(rc))
|
---|
| 537 | {
|
---|
[48234] | 538 | CFGMR3RemoveNode(pInstanceToDelete);
|
---|
[26970] | 539 | AssertRCReturn(rc, rc);
|
---|
| 540 | }
|
---|
| 541 | }
|
---|
| 542 |
|
---|
| 543 | /*
|
---|
| 544 | * Allocate the device instance.
|
---|
| 545 | */
|
---|
| 546 | size_t cb = RT_OFFSETOF(PDMUSBINS, achInstanceData[pUsbDev->pReg->cbInstance]);
|
---|
| 547 | cb = RT_ALIGN_Z(cb, 16);
|
---|
| 548 | PPDMUSBINS pUsbIns;
|
---|
| 549 | rc = MMR3HeapAllocZEx(pVM, MM_TAG_PDM_USB, cb, (void **)&pUsbIns);
|
---|
| 550 | if (RT_FAILURE(rc))
|
---|
| 551 | {
|
---|
| 552 | AssertMsgFailed(("Failed to allocate %d bytes of instance data for USB device '%s'. rc=%Rrc\n",
|
---|
| 553 | cb, pUsbDev->pReg->szName, rc));
|
---|
[48234] | 554 | CFGMR3RemoveNode(pInstanceToDelete);
|
---|
[26970] | 555 | return rc;
|
---|
| 556 | }
|
---|
| 557 |
|
---|
| 558 | /*
|
---|
| 559 | * Initialize it.
|
---|
| 560 | */
|
---|
| 561 | pUsbIns->u32Version = PDM_USBINS_VERSION;
|
---|
| 562 | //pUsbIns->Internal.s.pNext = NULL;
|
---|
| 563 | //pUsbIns->Internal.s.pPerDeviceNext = NULL;
|
---|
| 564 | pUsbIns->Internal.s.pUsbDev = pUsbDev;
|
---|
| 565 | pUsbIns->Internal.s.pVM = pVM;
|
---|
| 566 | //pUsbIns->Internal.s.pLuns = NULL;
|
---|
| 567 | pUsbIns->Internal.s.pCfg = pInstanceNode;
|
---|
[48234] | 568 | pUsbIns->Internal.s.pCfgDelete = pInstanceToDelete;
|
---|
[26970] | 569 | pUsbIns->Internal.s.pCfgGlobal = pGlobalConfig;
|
---|
| 570 | pUsbIns->Internal.s.Uuid = *pUuid;
|
---|
| 571 | //pUsbIns->Internal.s.pHub = NULL;
|
---|
| 572 | pUsbIns->Internal.s.iPort = UINT32_MAX; /* to be determined. */
|
---|
[48890] | 573 | /* Set the flag accordingly.
|
---|
| 574 | * Oherwise VMPowerOff, VMSuspend will not be called for devices attached at runtime.
|
---|
| 575 | */
|
---|
| 576 | pUsbIns->Internal.s.fVMSuspended = !fAtRuntime;
|
---|
[26970] | 577 | //pUsbIns->Internal.s.pfnAsyncNotify = NULL;
|
---|
| 578 | pUsbIns->pHlpR3 = &g_pdmR3UsbHlp;
|
---|
| 579 | pUsbIns->pReg = pUsbDev->pReg;
|
---|
| 580 | pUsbIns->pCfg = pConfig;
|
---|
| 581 | pUsbIns->pCfgGlobal = pGlobalConfig;
|
---|
| 582 | pUsbIns->iInstance = iInstance;
|
---|
| 583 | pUsbIns->pvInstanceDataR3 = &pUsbIns->achInstanceData[0];
|
---|
[30528] | 584 | pUsbIns->pszName = RTStrDup(pUsbDev->pReg->szName);
|
---|
[40920] | 585 | //pUsbIns->fTracing = 0;
|
---|
| 586 | pUsbIns->idTracing = ++pVM->pdm.s.idTracingOther;
|
---|
[43814] | 587 | pUsbIns->iUsbHubVersion = iUsbVersion;
|
---|
[26970] | 588 |
|
---|
| 589 | /*
|
---|
| 590 | * Link it into all the lists.
|
---|
| 591 | */
|
---|
| 592 | /* The global instance FIFO. */
|
---|
| 593 | PPDMUSBINS pPrev1 = pVM->pdm.s.pUsbInstances;
|
---|
| 594 | if (!pPrev1)
|
---|
| 595 | pVM->pdm.s.pUsbInstances = pUsbIns;
|
---|
| 596 | else
|
---|
| 597 | {
|
---|
| 598 | while (pPrev1->Internal.s.pNext)
|
---|
| 599 | {
|
---|
| 600 | Assert(pPrev1->u32Version == PDM_USBINS_VERSION);
|
---|
| 601 | pPrev1 = pPrev1->Internal.s.pNext;
|
---|
| 602 | }
|
---|
| 603 | pPrev1->Internal.s.pNext = pUsbIns;
|
---|
| 604 | }
|
---|
| 605 |
|
---|
| 606 | /* The per device instance FIFO. */
|
---|
| 607 | PPDMUSBINS pPrev2 = pUsbDev->pInstances;
|
---|
| 608 | if (!pPrev2)
|
---|
| 609 | pUsbDev->pInstances = pUsbIns;
|
---|
| 610 | else
|
---|
| 611 | {
|
---|
| 612 | while (pPrev2->Internal.s.pPerDeviceNext)
|
---|
| 613 | {
|
---|
| 614 | Assert(pPrev2->u32Version == PDM_USBINS_VERSION);
|
---|
| 615 | pPrev2 = pPrev2->Internal.s.pPerDeviceNext;
|
---|
| 616 | }
|
---|
| 617 | pPrev2->Internal.s.pPerDeviceNext = pUsbIns;
|
---|
| 618 | }
|
---|
| 619 |
|
---|
| 620 | /*
|
---|
| 621 | * Call the constructor.
|
---|
| 622 | */
|
---|
| 623 | Log(("PDM: Constructing USB device '%s' instance %d...\n", pUsbIns->pReg->szName, pUsbIns->iInstance));
|
---|
| 624 | rc = pUsbIns->pReg->pfnConstruct(pUsbIns, pUsbIns->iInstance, pUsbIns->pCfg, pUsbIns->pCfgGlobal);
|
---|
| 625 | if (RT_SUCCESS(rc))
|
---|
| 626 | {
|
---|
| 627 | /*
|
---|
| 628 | * Attach it to the hub.
|
---|
| 629 | */
|
---|
| 630 | Log(("PDM: Attaching it...\n"));
|
---|
| 631 | rc = pHub->Reg.pfnAttachDevice(pHub->pDrvIns, pUsbIns, &pUsbIns->Internal.s.iPort);
|
---|
| 632 | if (RT_SUCCESS(rc))
|
---|
| 633 | {
|
---|
| 634 | pHub->cAvailablePorts--;
|
---|
| 635 | Assert((int32_t)pHub->cAvailablePorts >= 0 && pHub->cAvailablePorts < pHub->cPorts);
|
---|
| 636 | pUsbIns->Internal.s.pHub = pHub;
|
---|
| 637 |
|
---|
| 638 | /* Send the hot-plugged notification if applicable. */
|
---|
| 639 | if (fAtRuntime && pUsbIns->pReg->pfnHotPlugged)
|
---|
| 640 | pUsbIns->pReg->pfnHotPlugged(pUsbIns);
|
---|
| 641 |
|
---|
| 642 | Log(("PDM: Successfully attached USB device '%s' instance %d to hub %p\n",
|
---|
| 643 | pUsbIns->pReg->szName, pUsbIns->iInstance, pHub));
|
---|
| 644 | return VINF_SUCCESS;
|
---|
| 645 | }
|
---|
| 646 |
|
---|
| 647 | LogRel(("PDM: Failed to attach USB device '%s' instance %d to hub %p: %Rrc\n",
|
---|
| 648 | pUsbIns->pReg->szName, pUsbIns->iInstance, pHub, rc));
|
---|
| 649 | }
|
---|
| 650 | else
|
---|
[35810] | 651 | {
|
---|
[26970] | 652 | AssertMsgFailed(("Failed to construct '%s'/%d! %Rra\n", pUsbIns->pReg->szName, pUsbIns->iInstance, rc));
|
---|
[35810] | 653 | if (rc == VERR_VERSION_MISMATCH)
|
---|
| 654 | rc = VERR_PDM_DRIVER_VERSION_MISMATCH;
|
---|
| 655 | }
|
---|
[26970] | 656 | if (fAtRuntime)
|
---|
| 657 | pdmR3UsbDestroyDevice(pVM, pUsbIns);
|
---|
| 658 | /* else: destructors are invoked later. */
|
---|
| 659 | return rc;
|
---|
| 660 | }
|
---|
| 661 |
|
---|
| 662 |
|
---|
| 663 | /**
|
---|
| 664 | * Instantiate USB devices.
|
---|
| 665 | *
|
---|
| 666 | * This is called by pdmR3DevInit() after it has instantiated the
|
---|
| 667 | * other devices and their drivers. If there aren't any hubs
|
---|
| 668 | * around, we'll silently skip the USB devices.
|
---|
| 669 | *
|
---|
| 670 | * @returns VBox status code.
|
---|
| 671 | * @param pVM
|
---|
| 672 | */
|
---|
| 673 | int pdmR3UsbInstantiateDevices(PVM pVM)
|
---|
| 674 | {
|
---|
| 675 | /*
|
---|
| 676 | * Any hubs?
|
---|
| 677 | */
|
---|
| 678 | if (!pVM->pdm.s.pUsbHubs)
|
---|
| 679 | {
|
---|
| 680 | Log(("PDM: No USB hubs, skipping USB device instantiation.\n"));
|
---|
| 681 | return VINF_SUCCESS;
|
---|
| 682 | }
|
---|
| 683 |
|
---|
| 684 | /*
|
---|
| 685 | * Count the device instances.
|
---|
| 686 | */
|
---|
| 687 | PCFGMNODE pCur;
|
---|
| 688 | PCFGMNODE pUsbNode = CFGMR3GetChild(CFGMR3GetRoot(pVM), "USB/");
|
---|
| 689 | PCFGMNODE pInstanceNode;
|
---|
| 690 | unsigned cUsbDevs = 0;
|
---|
| 691 | for (pCur = CFGMR3GetFirstChild(pUsbNode); pCur; pCur = CFGMR3GetNextChild(pCur))
|
---|
| 692 | {
|
---|
| 693 | PCFGMNODE pGlobal = CFGMR3GetChild(pCur, "GlobalConfig/");
|
---|
| 694 | for (pInstanceNode = CFGMR3GetFirstChild(pCur); pInstanceNode; pInstanceNode = CFGMR3GetNextChild(pInstanceNode))
|
---|
| 695 | if (pInstanceNode != pGlobal)
|
---|
| 696 | cUsbDevs++;
|
---|
| 697 | }
|
---|
| 698 | if (!cUsbDevs)
|
---|
| 699 | {
|
---|
| 700 | Log(("PDM: No USB devices were configured!\n"));
|
---|
| 701 | return VINF_SUCCESS;
|
---|
| 702 | }
|
---|
| 703 | Log2(("PDM: cUsbDevs=%d!\n", cUsbDevs));
|
---|
| 704 |
|
---|
| 705 | /*
|
---|
| 706 | * Collect info on each USB device instance.
|
---|
| 707 | */
|
---|
| 708 | struct USBDEVORDER
|
---|
| 709 | {
|
---|
| 710 | /** Configuration node. */
|
---|
| 711 | PCFGMNODE pNode;
|
---|
| 712 | /** Pointer to the USB device. */
|
---|
| 713 | PPDMUSB pUsbDev;
|
---|
| 714 | /** Init order. */
|
---|
| 715 | uint32_t u32Order;
|
---|
| 716 | /** VBox instance number. */
|
---|
| 717 | uint32_t iInstance;
|
---|
[48980] | 718 | /** Device UUID. */
|
---|
| 719 | RTUUID Uuid;
|
---|
[26970] | 720 | } *paUsbDevs = (struct USBDEVORDER *)alloca(sizeof(paUsbDevs[0]) * (cUsbDevs + 1)); /* (One extra for swapping) */
|
---|
| 721 | Assert(paUsbDevs);
|
---|
| 722 | int rc;
|
---|
| 723 | unsigned i = 0;
|
---|
| 724 | for (pCur = CFGMR3GetFirstChild(pUsbNode); pCur; pCur = CFGMR3GetNextChild(pCur))
|
---|
| 725 | {
|
---|
| 726 | /* Get the device name. */
|
---|
| 727 | char szName[sizeof(paUsbDevs[0].pUsbDev->pReg->szName)];
|
---|
| 728 | rc = CFGMR3GetName(pCur, szName, sizeof(szName));
|
---|
| 729 | AssertMsgRCReturn(rc, ("Configuration error: device name is too long (or something)! rc=%Rrc\n", rc), rc);
|
---|
| 730 |
|
---|
| 731 | /* Find the device. */
|
---|
| 732 | PPDMUSB pUsbDev = pdmR3UsbLookup(pVM, szName);
|
---|
| 733 | AssertMsgReturn(pUsbDev, ("Configuration error: device '%s' not found!\n", szName), VERR_PDM_DEVICE_NOT_FOUND);
|
---|
| 734 |
|
---|
| 735 | /* Configured priority or use default? */
|
---|
| 736 | uint32_t u32Order;
|
---|
| 737 | rc = CFGMR3QueryU32(pCur, "Priority", &u32Order);
|
---|
| 738 | if (rc == VERR_CFGM_VALUE_NOT_FOUND)
|
---|
| 739 | u32Order = i << 4;
|
---|
| 740 | else
|
---|
| 741 | AssertMsgRCReturn(rc, ("Configuration error: reading \"Priority\" for the '%s' USB device failed rc=%Rrc!\n", szName, rc), rc);
|
---|
| 742 |
|
---|
| 743 | /* Global config. */
|
---|
| 744 | PCFGMNODE pGlobal = CFGMR3GetChild(pCur, "GlobalConfig/");
|
---|
| 745 | if (!pGlobal)
|
---|
| 746 | {
|
---|
| 747 | rc = CFGMR3InsertNode(pCur, "GlobalConfig/", &pGlobal);
|
---|
| 748 | AssertMsgRCReturn(rc, ("Failed to create GlobalConfig node! rc=%Rrc\n", rc), rc);
|
---|
| 749 | CFGMR3SetRestrictedRoot(pGlobal);
|
---|
| 750 | }
|
---|
| 751 |
|
---|
| 752 | /* Enumerate the device instances. */
|
---|
| 753 | for (pInstanceNode = CFGMR3GetFirstChild(pCur); pInstanceNode; pInstanceNode = CFGMR3GetNextChild(pInstanceNode))
|
---|
| 754 | {
|
---|
| 755 | if (pInstanceNode == pGlobal)
|
---|
| 756 | continue;
|
---|
| 757 |
|
---|
[48980] | 758 | /* Use the configured UUID if present, create our own otherwise. */
|
---|
| 759 | char *pszUuid = NULL;
|
---|
| 760 |
|
---|
| 761 | RTUuidClear(&paUsbDevs[i].Uuid);
|
---|
| 762 | rc = CFGMR3QueryStringAlloc(pInstanceNode, "UUID", &pszUuid);
|
---|
| 763 | if (RT_SUCCESS(rc))
|
---|
| 764 | {
|
---|
| 765 | AssertPtr(pszUuid);
|
---|
| 766 |
|
---|
| 767 | rc = RTUuidFromStr(&paUsbDevs[i].Uuid, pszUuid);
|
---|
| 768 | AssertMsgRCReturn(rc, ("Failed to convert UUID from string! rc=%Rrc\n", rc), rc);
|
---|
| 769 | MMR3HeapFree(pszUuid);
|
---|
| 770 | }
|
---|
| 771 | else if (rc == VERR_CFGM_VALUE_NOT_FOUND)
|
---|
| 772 | rc = RTUuidCreate(&paUsbDevs[i].Uuid);
|
---|
| 773 |
|
---|
| 774 | AssertRCReturn(rc, rc);
|
---|
[26970] | 775 | paUsbDevs[i].pNode = pInstanceNode;
|
---|
| 776 | paUsbDevs[i].pUsbDev = pUsbDev;
|
---|
| 777 | paUsbDevs[i].u32Order = u32Order;
|
---|
| 778 |
|
---|
| 779 | /* Get the instance number. */
|
---|
| 780 | char szInstance[32];
|
---|
| 781 | rc = CFGMR3GetName(pInstanceNode, szInstance, sizeof(szInstance));
|
---|
| 782 | AssertMsgRCReturn(rc, ("Configuration error: instance name is too long (or something)! rc=%Rrc\n", rc), rc);
|
---|
| 783 | char *pszNext = NULL;
|
---|
| 784 | rc = RTStrToUInt32Ex(szInstance, &pszNext, 0, &paUsbDevs[i].iInstance);
|
---|
| 785 | AssertMsgRCReturn(rc, ("Configuration error: RTStrToInt32Ex failed on the instance name '%s'! rc=%Rrc\n", szInstance, rc), rc);
|
---|
| 786 | AssertMsgReturn(!*pszNext, ("Configuration error: the instance name '%s' isn't all digits. (%s)\n", szInstance, pszNext), VERR_INVALID_PARAMETER);
|
---|
| 787 |
|
---|
| 788 | /* next instance */
|
---|
| 789 | i++;
|
---|
| 790 | }
|
---|
| 791 | } /* devices */
|
---|
| 792 | Assert(i == cUsbDevs);
|
---|
| 793 |
|
---|
| 794 | /*
|
---|
| 795 | * Sort the device array ascending on u32Order. (bubble)
|
---|
| 796 | */
|
---|
| 797 | unsigned c = cUsbDevs - 1;
|
---|
| 798 | while (c)
|
---|
| 799 | {
|
---|
| 800 | unsigned j = 0;
|
---|
| 801 | for (i = 0; i < c; i++)
|
---|
| 802 | if (paUsbDevs[i].u32Order > paUsbDevs[i + 1].u32Order)
|
---|
| 803 | {
|
---|
| 804 | paUsbDevs[cUsbDevs] = paUsbDevs[i + 1];
|
---|
| 805 | paUsbDevs[i + 1] = paUsbDevs[i];
|
---|
| 806 | paUsbDevs[i] = paUsbDevs[cUsbDevs];
|
---|
| 807 | j = i;
|
---|
| 808 | }
|
---|
| 809 | c = j;
|
---|
| 810 | }
|
---|
| 811 |
|
---|
| 812 | /*
|
---|
| 813 | * Instantiate the devices.
|
---|
| 814 | */
|
---|
| 815 | for (i = 0; i < cUsbDevs; i++)
|
---|
| 816 | {
|
---|
| 817 | /*
|
---|
| 818 | * Make sure there is a config node and mark it as restricted.
|
---|
| 819 | */
|
---|
| 820 | PCFGMNODE pConfigNode = CFGMR3GetChild(paUsbDevs[i].pNode, "Config/");
|
---|
| 821 | if (!pConfigNode)
|
---|
| 822 | {
|
---|
| 823 | rc = CFGMR3InsertNode(paUsbDevs[i].pNode, "Config", &pConfigNode);
|
---|
| 824 | AssertMsgRCReturn(rc, ("Failed to create Config node! rc=%Rrc\n", rc), rc);
|
---|
| 825 | }
|
---|
| 826 | CFGMR3SetRestrictedRoot(pConfigNode);
|
---|
| 827 |
|
---|
[43814] | 828 | /*
|
---|
| 829 | * Every device must support USB 1.x hubs; optionally, high-speed USB 2.0 hubs
|
---|
| 830 | * might be also supported. This determines where to attach the device.
|
---|
[26970] | 831 | */
|
---|
| 832 | uint32_t iUsbVersion = VUSB_STDVER_11;
|
---|
| 833 |
|
---|
[43814] | 834 | if (paUsbDevs[i].pUsbDev->pReg->fFlags & PDM_USBREG_HIGHSPEED_CAPABLE)
|
---|
| 835 | iUsbVersion |= VUSB_STDVER_20;
|
---|
[48936] | 836 |
|
---|
[26970] | 837 | /*
|
---|
| 838 | * Find a suitable hub with free ports.
|
---|
| 839 | */
|
---|
| 840 | PPDMUSBHUB pHub;
|
---|
| 841 | rc = pdmR3UsbFindHub(pVM, iUsbVersion, &pHub);
|
---|
| 842 | if (RT_FAILURE(rc))
|
---|
| 843 | {
|
---|
| 844 | Log(("pdmR3UsbFindHub failed %Rrc\n", rc));
|
---|
| 845 | return rc;
|
---|
| 846 | }
|
---|
| 847 |
|
---|
| 848 | /*
|
---|
[43814] | 849 | * This is how we inform the device what speed it's communicating at, and hence
|
---|
| 850 | * which descriptors it should present to the guest.
|
---|
| 851 | */
|
---|
| 852 | iUsbVersion &= pHub->fVersions;
|
---|
| 853 |
|
---|
| 854 | /*
|
---|
[26970] | 855 | * Create and attach the device.
|
---|
| 856 | */
|
---|
[48980] | 857 | rc = pdmR3UsbCreateDevice(pVM, pHub, paUsbDevs[i].pUsbDev, paUsbDevs[i].iInstance, &paUsbDevs[i].Uuid,
|
---|
| 858 | &paUsbDevs[i].pNode, iUsbVersion);
|
---|
[26970] | 859 | if (RT_FAILURE(rc))
|
---|
| 860 | return rc;
|
---|
| 861 | } /* for device instances */
|
---|
| 862 |
|
---|
| 863 | return VINF_SUCCESS;
|
---|
| 864 | }
|
---|
| 865 |
|
---|
| 866 |
|
---|
| 867 | /**
|
---|
[48234] | 868 | * Creates an emulated USB device instance at runtime.
|
---|
| 869 | *
|
---|
| 870 | * This will find an appropriate HUB for the USB device
|
---|
| 871 | * and try instantiate the emulated device.
|
---|
| 872 | *
|
---|
| 873 | * @returns VBox status code.
|
---|
| 874 | * @param pUVM The user mode VM handle.
|
---|
| 875 | * @param pszDeviceName The name of the PDM device to instantiate.
|
---|
| 876 | * @param pInstanceNode The instance CFGM node.
|
---|
[48406] | 877 | * @param pUuid The UUID to be associated with the device.
|
---|
[48234] | 878 | *
|
---|
| 879 | * @thread EMT
|
---|
| 880 | */
|
---|
[48406] | 881 | VMMR3DECL(int) PDMR3UsbCreateEmulatedDevice(PUVM pUVM, const char *pszDeviceName, PCFGMNODE pInstanceNode, PCRTUUID pUuid)
|
---|
[48234] | 882 | {
|
---|
| 883 | /*
|
---|
| 884 | * Validate input.
|
---|
| 885 | */
|
---|
| 886 | UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
|
---|
| 887 | PVM pVM = pUVM->pVM;
|
---|
| 888 | VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
|
---|
| 889 | VM_ASSERT_EMT_RETURN(pVM, VERR_VM_THREAD_NOT_EMT);
|
---|
| 890 | AssertPtrReturn(pszDeviceName, VERR_INVALID_POINTER);
|
---|
| 891 | AssertPtrReturn(pInstanceNode, VERR_INVALID_POINTER);
|
---|
| 892 |
|
---|
| 893 | /*
|
---|
| 894 | * Find the device.
|
---|
| 895 | */
|
---|
| 896 | PPDMUSB pUsbDev = pdmR3UsbLookup(pVM, pszDeviceName);
|
---|
| 897 | if (!pUsbDev)
|
---|
| 898 | {
|
---|
| 899 | LogRel(("PDMR3UsbCreateEmulatedDevice: The '%s' device wasn't found\n", pszDeviceName));
|
---|
| 900 | return VERR_PDM_NO_USBPROXY;
|
---|
| 901 | }
|
---|
| 902 |
|
---|
| 903 | /*
|
---|
| 904 | * Every device must support USB 1.x hubs; optionally, high-speed USB 2.0 hubs
|
---|
| 905 | * might be also supported. This determines where to attach the device.
|
---|
| 906 | */
|
---|
| 907 | uint32_t iUsbVersion = VUSB_STDVER_11;
|
---|
| 908 | if (pUsbDev->pReg->fFlags & PDM_USBREG_HIGHSPEED_CAPABLE)
|
---|
| 909 | iUsbVersion |= VUSB_STDVER_20;
|
---|
| 910 |
|
---|
| 911 | /*
|
---|
| 912 | * Find a suitable hub with free ports.
|
---|
| 913 | */
|
---|
| 914 | PPDMUSBHUB pHub;
|
---|
| 915 | int rc = pdmR3UsbFindHub(pVM, iUsbVersion, &pHub);
|
---|
| 916 | if (RT_FAILURE(rc))
|
---|
| 917 | {
|
---|
| 918 | Log(("pdmR3UsbFindHub: failed %Rrc\n", rc));
|
---|
| 919 | return rc;
|
---|
| 920 | }
|
---|
| 921 |
|
---|
| 922 | /*
|
---|
| 923 | * This is how we inform the device what speed it's communicating at, and hence
|
---|
| 924 | * which descriptors it should present to the guest.
|
---|
| 925 | */
|
---|
| 926 | iUsbVersion &= pHub->fVersions;
|
---|
| 927 |
|
---|
| 928 | /*
|
---|
| 929 | * Create and attach the device.
|
---|
| 930 | */
|
---|
| 931 | rc = pdmR3UsbCreateDevice(pVM, pHub, pUsbDev, -1, pUuid, &pInstanceNode, iUsbVersion);
|
---|
| 932 | AssertRCReturn(rc, rc);
|
---|
| 933 |
|
---|
| 934 | return rc;
|
---|
| 935 | }
|
---|
| 936 |
|
---|
| 937 |
|
---|
| 938 | /**
|
---|
[26970] | 939 | * Creates a USB proxy device instance.
|
---|
| 940 | *
|
---|
| 941 | * This will find an appropriate HUB for the USB device, create the necessary CFGM stuff
|
---|
| 942 | * and try instantiate the proxy device.
|
---|
| 943 | *
|
---|
| 944 | * @returns VBox status code.
|
---|
[44351] | 945 | * @param pUVM The user mode VM handle.
|
---|
[33540] | 946 | * @param pUuid The UUID to be associated with the device.
|
---|
[26970] | 947 | * @param fRemote Whether it's a remove or local device.
|
---|
| 948 | * @param pszAddress The address string.
|
---|
| 949 | * @param pvBackend Pointer to the backend.
|
---|
| 950 | * @param iUsbVersion The preferred USB version.
|
---|
| 951 | * @param fMaskedIfs The interfaces to hide from the guest.
|
---|
| 952 | */
|
---|
[44351] | 953 | VMMR3DECL(int) PDMR3UsbCreateProxyDevice(PUVM pUVM, PCRTUUID pUuid, bool fRemote, const char *pszAddress, void *pvBackend,
|
---|
[26970] | 954 | uint32_t iUsbVersion, uint32_t fMaskedIfs)
|
---|
| 955 | {
|
---|
| 956 | /*
|
---|
| 957 | * Validate input.
|
---|
| 958 | */
|
---|
[44351] | 959 | UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
|
---|
| 960 | PVM pVM = pUVM->pVM;
|
---|
| 961 | VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
|
---|
[48234] | 962 | VM_ASSERT_EMT_RETURN(pVM, VERR_VM_THREAD_NOT_EMT);
|
---|
[26970] | 963 | AssertPtrReturn(pUuid, VERR_INVALID_POINTER);
|
---|
| 964 | AssertPtrReturn(pszAddress, VERR_INVALID_POINTER);
|
---|
| 965 | AssertReturn( iUsbVersion == VUSB_STDVER_20
|
---|
| 966 | || iUsbVersion == VUSB_STDVER_11, VERR_INVALID_PARAMETER);
|
---|
| 967 |
|
---|
| 968 | /*
|
---|
| 969 | * Find the USBProxy driver.
|
---|
| 970 | */
|
---|
| 971 | PPDMUSB pUsbDev = pdmR3UsbLookup(pVM, "USBProxy");
|
---|
| 972 | if (!pUsbDev)
|
---|
| 973 | {
|
---|
[44351] | 974 | LogRel(("PDMR3UsbCreateProxyDevice: The USBProxy device class wasn't found\n"));
|
---|
[26970] | 975 | return VERR_PDM_NO_USBPROXY;
|
---|
| 976 | }
|
---|
| 977 |
|
---|
| 978 | /*
|
---|
| 979 | * Find a suitable hub with free ports.
|
---|
| 980 | */
|
---|
| 981 | PPDMUSBHUB pHub;
|
---|
| 982 | int rc = pdmR3UsbFindHub(pVM, iUsbVersion, &pHub);
|
---|
| 983 | if (RT_FAILURE(rc))
|
---|
| 984 | {
|
---|
| 985 | Log(("pdmR3UsbFindHub: failed %Rrc\n", rc));
|
---|
| 986 | return rc;
|
---|
| 987 | }
|
---|
| 988 |
|
---|
| 989 | /*
|
---|
[48234] | 990 | * Create the CFGM instance node.
|
---|
[26970] | 991 | */
|
---|
[48234] | 992 | PCFGMNODE pInstance = CFGMR3CreateTree(pUVM);
|
---|
| 993 | AssertReturn(pInstance, VERR_NO_MEMORY);
|
---|
[26970] | 994 | do /* break loop */
|
---|
| 995 | {
|
---|
[48234] | 996 | PCFGMNODE pConfig;
|
---|
| 997 | rc = CFGMR3InsertNode(pInstance, "Config", &pConfig); AssertRCBreak(rc);
|
---|
[26970] | 998 | rc = CFGMR3InsertString(pConfig, "Address", pszAddress); AssertRCBreak(rc);
|
---|
| 999 | char szUuid[RTUUID_STR_LENGTH];
|
---|
| 1000 | rc = RTUuidToStr(pUuid, &szUuid[0], sizeof(szUuid)); AssertRCBreak(rc);
|
---|
| 1001 | rc = CFGMR3InsertString(pConfig, "UUID", szUuid); AssertRCBreak(rc);
|
---|
| 1002 | rc = CFGMR3InsertInteger(pConfig, "Remote", fRemote); AssertRCBreak(rc);
|
---|
| 1003 | rc = CFGMR3InsertInteger(pConfig, "USBVersion", iUsbVersion); AssertRCBreak(rc);
|
---|
| 1004 | rc = CFGMR3InsertInteger(pConfig, "pvBackend", (uintptr_t)pvBackend); AssertRCBreak(rc);
|
---|
| 1005 | rc = CFGMR3InsertInteger(pConfig, "MaskedIfs", fMaskedIfs); AssertRCBreak(rc);
|
---|
| 1006 | rc = CFGMR3InsertInteger(pConfig, "Force11Device", !(pHub->fVersions & iUsbVersion)); AssertRCBreak(rc);
|
---|
| 1007 | } while (0); /* break loop */
|
---|
| 1008 | if (RT_FAILURE(rc))
|
---|
| 1009 | {
|
---|
[48234] | 1010 | CFGMR3RemoveNode(pInstance);
|
---|
[44351] | 1011 | LogRel(("PDMR3UsbCreateProxyDevice: failed to setup CFGM config, rc=%Rrc\n", rc));
|
---|
[26970] | 1012 | return rc;
|
---|
| 1013 | }
|
---|
| 1014 |
|
---|
| 1015 | /*
|
---|
[43814] | 1016 | * Finally, try to create it.
|
---|
[26970] | 1017 | */
|
---|
[48234] | 1018 | rc = pdmR3UsbCreateDevice(pVM, pHub, pUsbDev, -1, pUuid, &pInstance, iUsbVersion);
|
---|
| 1019 | if (RT_FAILURE(rc) && pInstance)
|
---|
| 1020 | CFGMR3RemoveNode(pInstance);
|
---|
[26970] | 1021 | return rc;
|
---|
| 1022 | }
|
---|
| 1023 |
|
---|
| 1024 |
|
---|
| 1025 | /**
|
---|
| 1026 | * Destroys a hot-plugged USB device.
|
---|
| 1027 | *
|
---|
| 1028 | * The device must be detached from the HUB at this point.
|
---|
| 1029 | *
|
---|
[41777] | 1030 | * @param pVM Pointer to the VM.
|
---|
[26970] | 1031 | * @param pUsbIns The USB device instance to destroy.
|
---|
| 1032 | * @thread EMT
|
---|
| 1033 | */
|
---|
| 1034 | static void pdmR3UsbDestroyDevice(PVM pVM, PPDMUSBINS pUsbIns)
|
---|
| 1035 | {
|
---|
| 1036 | Assert(!pUsbIns->Internal.s.pHub);
|
---|
| 1037 |
|
---|
| 1038 | /*
|
---|
| 1039 | * Do the unplug notification.
|
---|
| 1040 | */
|
---|
| 1041 | /** @todo what about the drivers? */
|
---|
| 1042 | if (pUsbIns->pReg->pfnHotUnplugged)
|
---|
| 1043 | pUsbIns->pReg->pfnHotUnplugged(pUsbIns);
|
---|
| 1044 |
|
---|
| 1045 | /*
|
---|
| 1046 | * Destroy the luns with their driver chains and call the device destructor.
|
---|
| 1047 | */
|
---|
| 1048 | while (pUsbIns->Internal.s.pLuns)
|
---|
| 1049 | {
|
---|
| 1050 | PPDMLUN pLun = pUsbIns->Internal.s.pLuns;
|
---|
| 1051 | pUsbIns->Internal.s.pLuns = pLun->pNext;
|
---|
| 1052 | if (pLun->pTop)
|
---|
| 1053 | pdmR3DrvDestroyChain(pLun->pTop, PDM_TACH_FLAGS_NOT_HOT_PLUG); /* Hotplugging is handled differently here atm. */
|
---|
| 1054 | MMR3HeapFree(pLun);
|
---|
| 1055 | }
|
---|
| 1056 |
|
---|
| 1057 | /* finally, the device. */
|
---|
| 1058 | if (pUsbIns->pReg->pfnDestruct)
|
---|
| 1059 | {
|
---|
| 1060 | Log(("PDM: Destructing USB device '%s' instance %d...\n", pUsbIns->pReg->szName, pUsbIns->iInstance));
|
---|
| 1061 | pUsbIns->pReg->pfnDestruct(pUsbIns);
|
---|
| 1062 | }
|
---|
[37358] | 1063 | TMR3TimerDestroyUsb(pVM, pUsbIns);
|
---|
[48986] | 1064 | SSMR3DeregisterUsb(pVM, pUsbIns, NULL, 0);
|
---|
[26970] | 1065 | pdmR3ThreadDestroyUsb(pVM, pUsbIns);
|
---|
[44358] | 1066 | #ifdef VBOX_WITH_PDM_ASYNC_COMPLETION
|
---|
| 1067 | pdmR3AsyncCompletionTemplateDestroyUsb(pVM, pUsbIns);
|
---|
| 1068 | #endif
|
---|
[26970] | 1069 |
|
---|
| 1070 | /*
|
---|
| 1071 | * Unlink it.
|
---|
| 1072 | */
|
---|
| 1073 | /* The global instance FIFO. */
|
---|
| 1074 | if (pVM->pdm.s.pUsbInstances == pUsbIns)
|
---|
| 1075 | pVM->pdm.s.pUsbInstances = pUsbIns->Internal.s.pNext;
|
---|
| 1076 | else
|
---|
| 1077 | {
|
---|
| 1078 | PPDMUSBINS pPrev = pVM->pdm.s.pUsbInstances;
|
---|
| 1079 | while (pPrev && pPrev->Internal.s.pNext != pUsbIns)
|
---|
| 1080 | {
|
---|
| 1081 | Assert(pPrev->u32Version == PDM_USBINS_VERSION);
|
---|
| 1082 | pPrev = pPrev->Internal.s.pNext;
|
---|
| 1083 | }
|
---|
| 1084 | Assert(pPrev); Assert(pPrev != pUsbIns);
|
---|
| 1085 | if (pPrev)
|
---|
| 1086 | pPrev->Internal.s.pNext = pUsbIns->Internal.s.pNext;
|
---|
| 1087 | }
|
---|
| 1088 |
|
---|
| 1089 | /* The per device instance FIFO. */
|
---|
| 1090 | PPDMUSB pUsbDev = pUsbIns->Internal.s.pUsbDev;
|
---|
| 1091 | if (pUsbDev->pInstances == pUsbIns)
|
---|
| 1092 | pUsbDev->pInstances = pUsbIns->Internal.s.pPerDeviceNext;
|
---|
| 1093 | else
|
---|
| 1094 | {
|
---|
| 1095 | PPDMUSBINS pPrev = pUsbDev->pInstances;
|
---|
| 1096 | while (pPrev && pPrev->Internal.s.pPerDeviceNext != pUsbIns)
|
---|
| 1097 | {
|
---|
| 1098 | Assert(pPrev->u32Version == PDM_USBINS_VERSION);
|
---|
| 1099 | pPrev = pPrev->Internal.s.pPerDeviceNext;
|
---|
| 1100 | }
|
---|
| 1101 | Assert(pPrev); Assert(pPrev != pUsbIns);
|
---|
| 1102 | if (pPrev)
|
---|
| 1103 | pPrev->Internal.s.pPerDeviceNext = pUsbIns->Internal.s.pPerDeviceNext;
|
---|
| 1104 | }
|
---|
| 1105 |
|
---|
| 1106 | /*
|
---|
| 1107 | * Trash it.
|
---|
| 1108 | */
|
---|
| 1109 | pUsbIns->u32Version = 0;
|
---|
| 1110 | pUsbIns->pReg = NULL;
|
---|
[30528] | 1111 | if (pUsbIns->pszName)
|
---|
| 1112 | {
|
---|
| 1113 | RTStrFree(pUsbIns->pszName);
|
---|
| 1114 | pUsbIns->pszName = NULL;
|
---|
| 1115 | }
|
---|
[26970] | 1116 | CFGMR3RemoveNode(pUsbIns->Internal.s.pCfgDelete);
|
---|
| 1117 | MMR3HeapFree(pUsbIns);
|
---|
| 1118 | }
|
---|
| 1119 |
|
---|
| 1120 |
|
---|
| 1121 | /**
|
---|
| 1122 | * Detaches and destroys a USB device.
|
---|
| 1123 | *
|
---|
| 1124 | * @returns VBox status code.
|
---|
[44351] | 1125 | * @param pUVM The user mode VM handle.
|
---|
[26970] | 1126 | * @param pUuid The UUID associated with the device to detach.
|
---|
| 1127 | * @thread EMT
|
---|
| 1128 | */
|
---|
[44351] | 1129 | VMMR3DECL(int) PDMR3UsbDetachDevice(PUVM pUVM, PCRTUUID pUuid)
|
---|
[26970] | 1130 | {
|
---|
| 1131 | /*
|
---|
| 1132 | * Validate input.
|
---|
| 1133 | */
|
---|
[44351] | 1134 | UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
|
---|
| 1135 | PVM pVM = pUVM->pVM;
|
---|
| 1136 | VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
|
---|
[26970] | 1137 | VM_ASSERT_EMT(pVM);
|
---|
| 1138 | AssertPtrReturn(pUuid, VERR_INVALID_POINTER);
|
---|
| 1139 |
|
---|
| 1140 | /*
|
---|
| 1141 | * Search the global list for it.
|
---|
| 1142 | */
|
---|
| 1143 | PPDMUSBINS pUsbIns = pVM->pdm.s.pUsbInstances;
|
---|
| 1144 | for ( ; pUsbIns; pUsbIns = pUsbIns->Internal.s.pNext)
|
---|
| 1145 | if (!RTUuidCompare(&pUsbIns->Internal.s.Uuid, pUuid))
|
---|
| 1146 | break;
|
---|
| 1147 | if (!pUsbIns)
|
---|
| 1148 | return VERR_PDM_DEVICE_INSTANCE_NOT_FOUND; /** @todo VERR_PDM_USB_INSTANCE_NOT_FOUND */
|
---|
| 1149 |
|
---|
| 1150 | /*
|
---|
| 1151 | * Detach it from the HUB (if it's actually attached to one).
|
---|
| 1152 | */
|
---|
| 1153 | PPDMUSBHUB pHub = pUsbIns->Internal.s.pHub;
|
---|
| 1154 | if (pHub)
|
---|
| 1155 | {
|
---|
| 1156 | int rc = pHub->Reg.pfnDetachDevice(pHub->pDrvIns, pUsbIns, pUsbIns->Internal.s.iPort);
|
---|
| 1157 | if (RT_FAILURE(rc))
|
---|
| 1158 | {
|
---|
| 1159 | LogRel(("PDM: Failed to detach USB device '%s' instance %d from %p: %Rrc\n",
|
---|
| 1160 | pUsbIns->pReg->szName, pUsbIns->iInstance, pHub, rc));
|
---|
| 1161 | return rc;
|
---|
| 1162 | }
|
---|
| 1163 |
|
---|
| 1164 | pHub->cAvailablePorts++;
|
---|
| 1165 | Assert(pHub->cAvailablePorts > 0 && pHub->cAvailablePorts <= pHub->cPorts);
|
---|
| 1166 | pUsbIns->Internal.s.pHub = NULL;
|
---|
| 1167 | }
|
---|
| 1168 |
|
---|
| 1169 | /*
|
---|
| 1170 | * Notify about unplugging and destroy the device with it's drivers.
|
---|
| 1171 | */
|
---|
| 1172 | pdmR3UsbDestroyDevice(pVM, pUsbIns);
|
---|
| 1173 |
|
---|
| 1174 | return VINF_SUCCESS;
|
---|
| 1175 | }
|
---|
| 1176 |
|
---|
| 1177 |
|
---|
| 1178 | /**
|
---|
| 1179 | * Checks if there are any USB hubs attached.
|
---|
| 1180 | *
|
---|
| 1181 | * @returns true / false accordingly.
|
---|
[44351] | 1182 | * @param pUVM The user mode VM handle.
|
---|
[26970] | 1183 | */
|
---|
[44351] | 1184 | VMMR3DECL(bool) PDMR3UsbHasHub(PUVM pUVM)
|
---|
[26970] | 1185 | {
|
---|
[44351] | 1186 | UVM_ASSERT_VALID_EXT_RETURN(pUVM, false);
|
---|
| 1187 | PVM pVM = pUVM->pVM;
|
---|
| 1188 | VM_ASSERT_VALID_EXT_RETURN(pVM, false);
|
---|
[26970] | 1189 | return pVM->pdm.s.pUsbHubs != NULL;
|
---|
| 1190 | }
|
---|
| 1191 |
|
---|
| 1192 |
|
---|
[48980] | 1193 | /**
|
---|
| 1194 | * Locates a LUN.
|
---|
| 1195 | *
|
---|
| 1196 | * @returns VBox status code.
|
---|
| 1197 | * @param pVM Pointer to the VM.
|
---|
| 1198 | * @param pszDevice Device name.
|
---|
| 1199 | * @param iInstance Device instance.
|
---|
| 1200 | * @param iLun The Logical Unit to obtain the interface of.
|
---|
| 1201 | * @param ppLun Where to store the pointer to the LUN if found.
|
---|
| 1202 | * @thread Try only do this in EMT...
|
---|
| 1203 | */
|
---|
| 1204 | static int pdmR3UsbFindLun(PVM pVM, const char *pszDevice, unsigned iInstance, unsigned iLun, PPPDMLUN ppLun)
|
---|
| 1205 | {
|
---|
| 1206 | /*
|
---|
| 1207 | * Iterate registered devices looking for the device.
|
---|
| 1208 | */
|
---|
| 1209 | size_t cchDevice = strlen(pszDevice);
|
---|
| 1210 | for (PPDMUSB pUsbDev = pVM->pdm.s.pUsbDevs; pUsbDev; pUsbDev = pUsbDev->pNext)
|
---|
| 1211 | {
|
---|
| 1212 | if ( pUsbDev->cchName == cchDevice
|
---|
| 1213 | && !memcmp(pUsbDev->pReg->szName, pszDevice, cchDevice))
|
---|
| 1214 | {
|
---|
| 1215 | /*
|
---|
| 1216 | * Iterate device instances.
|
---|
| 1217 | */
|
---|
| 1218 | for (PPDMUSBINS pUsbIns = pUsbDev->pInstances; pUsbIns; pUsbIns = pUsbIns->Internal.s.pPerDeviceNext)
|
---|
| 1219 | {
|
---|
| 1220 | if (pUsbIns->iInstance == iInstance)
|
---|
| 1221 | {
|
---|
| 1222 | /*
|
---|
| 1223 | * Iterate luns.
|
---|
| 1224 | */
|
---|
| 1225 | for (PPDMLUN pLun = pUsbIns->Internal.s.pLuns; pLun; pLun = pLun->pNext)
|
---|
| 1226 | {
|
---|
| 1227 | if (pLun->iLun == iLun)
|
---|
| 1228 | {
|
---|
| 1229 | *ppLun = pLun;
|
---|
| 1230 | return VINF_SUCCESS;
|
---|
| 1231 | }
|
---|
| 1232 | }
|
---|
| 1233 | return VERR_PDM_LUN_NOT_FOUND;
|
---|
| 1234 | }
|
---|
| 1235 | }
|
---|
| 1236 | return VERR_PDM_DEVICE_INSTANCE_NOT_FOUND;
|
---|
| 1237 | }
|
---|
| 1238 | }
|
---|
| 1239 | return VERR_PDM_DEVICE_NOT_FOUND;
|
---|
| 1240 | }
|
---|
| 1241 |
|
---|
| 1242 |
|
---|
| 1243 | /**
|
---|
| 1244 | * Attaches a preconfigured driver to an existing device or driver instance.
|
---|
| 1245 | *
|
---|
| 1246 | * This is used to change drivers and suchlike at runtime. The driver or device
|
---|
| 1247 | * at the end of the chain will be told to attach to whatever is configured
|
---|
| 1248 | * below it.
|
---|
| 1249 | *
|
---|
| 1250 | * @returns VBox status code.
|
---|
| 1251 | * @param pUVM The user mode VM handle.
|
---|
| 1252 | * @param pszDevice Device name.
|
---|
| 1253 | * @param iInstance Device instance.
|
---|
| 1254 | * @param iLun The Logical Unit to obtain the interface of.
|
---|
| 1255 | * @param fFlags Flags, combination of the PDM_TACH_FLAGS_* \#defines.
|
---|
| 1256 | * @param ppBase Where to store the base interface pointer. Optional.
|
---|
| 1257 | *
|
---|
| 1258 | * @thread EMT
|
---|
| 1259 | */
|
---|
| 1260 | VMMR3DECL(int) PDMR3UsbDriverAttach(PUVM pUVM, const char *pszDevice, unsigned iDevIns, unsigned iLun, uint32_t fFlags,
|
---|
| 1261 | PPPDMIBASE ppBase)
|
---|
| 1262 | {
|
---|
| 1263 | LogFlow(("PDMR3UsbDriverAttach: pszDevice=%p:{%s} iDevIns=%d iLun=%d fFlags=%#x ppBase=%p\n",
|
---|
| 1264 | pszDevice, pszDevice, iDevIns, iLun, fFlags, ppBase));
|
---|
| 1265 | UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
|
---|
| 1266 | PVM pVM = pUVM->pVM;
|
---|
| 1267 | VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
|
---|
| 1268 | VM_ASSERT_EMT(pVM);
|
---|
| 1269 |
|
---|
| 1270 | if (ppBase)
|
---|
| 1271 | *ppBase = NULL;
|
---|
| 1272 |
|
---|
| 1273 | /*
|
---|
| 1274 | * Find the LUN in question.
|
---|
| 1275 | */
|
---|
| 1276 | PPDMLUN pLun;
|
---|
| 1277 | int rc = pdmR3UsbFindLun(pVM, pszDevice, iDevIns, iLun, &pLun);
|
---|
| 1278 | if (RT_SUCCESS(rc))
|
---|
| 1279 | {
|
---|
| 1280 | /*
|
---|
| 1281 | * Anything attached to the LUN?
|
---|
| 1282 | */
|
---|
| 1283 | PPDMDRVINS pDrvIns = pLun->pTop;
|
---|
| 1284 | if (!pDrvIns)
|
---|
| 1285 | {
|
---|
| 1286 | /* No, ask the device to attach to the new stuff. */
|
---|
| 1287 | PPDMUSBINS pUsbIns = pLun->pUsbIns;
|
---|
| 1288 | if (pUsbIns->pReg->pfnDriverAttach)
|
---|
| 1289 | {
|
---|
| 1290 | rc = pUsbIns->pReg->pfnDriverAttach(pUsbIns, iLun, fFlags);
|
---|
| 1291 | if (RT_SUCCESS(rc) && ppBase)
|
---|
| 1292 | *ppBase = pLun->pTop ? &pLun->pTop->IBase : NULL;
|
---|
| 1293 | }
|
---|
| 1294 | else
|
---|
| 1295 | rc = VERR_PDM_DEVICE_NO_RT_ATTACH;
|
---|
| 1296 | }
|
---|
| 1297 | else
|
---|
| 1298 | {
|
---|
| 1299 | /* Yes, find the bottom most driver and ask it to attach to the new stuff. */
|
---|
| 1300 | while (pDrvIns->Internal.s.pDown)
|
---|
| 1301 | pDrvIns = pDrvIns->Internal.s.pDown;
|
---|
| 1302 | if (pDrvIns->pReg->pfnAttach)
|
---|
| 1303 | {
|
---|
| 1304 | rc = pDrvIns->pReg->pfnAttach(pDrvIns, fFlags);
|
---|
| 1305 | if (RT_SUCCESS(rc) && ppBase)
|
---|
| 1306 | *ppBase = pDrvIns->Internal.s.pDown
|
---|
| 1307 | ? &pDrvIns->Internal.s.pDown->IBase
|
---|
| 1308 | : NULL;
|
---|
| 1309 | }
|
---|
| 1310 | else
|
---|
| 1311 | rc = VERR_PDM_DRIVER_NO_RT_ATTACH;
|
---|
| 1312 | }
|
---|
| 1313 | }
|
---|
| 1314 |
|
---|
| 1315 | if (ppBase)
|
---|
| 1316 | LogFlow(("PDMR3UsbDriverAttach: returns %Rrc *ppBase=%p\n", rc, *ppBase));
|
---|
| 1317 | else
|
---|
| 1318 | LogFlow(("PDMR3UsbDriverAttach: returns %Rrc\n", rc));
|
---|
| 1319 | return rc;
|
---|
| 1320 | }
|
---|
| 1321 |
|
---|
| 1322 |
|
---|
| 1323 | /**
|
---|
| 1324 | * Detaches the specified driver instance.
|
---|
| 1325 | *
|
---|
| 1326 | * This is used to replumb drivers at runtime for simulating hot plugging and
|
---|
| 1327 | * media changes.
|
---|
| 1328 | *
|
---|
| 1329 | * This method allows detaching drivers from
|
---|
| 1330 | * any driver or device by specifying the driver to start detaching at. The
|
---|
| 1331 | * only prerequisite is that the driver or device above implements the
|
---|
| 1332 | * pfnDetach callback (PDMDRVREG / PDMUSBREG).
|
---|
| 1333 | *
|
---|
| 1334 | * @returns VBox status code.
|
---|
| 1335 | * @param pUVM The user mode VM handle.
|
---|
| 1336 | * @param pszDevice Device name.
|
---|
| 1337 | * @param iDevIns Device instance.
|
---|
| 1338 | * @param iLun The Logical Unit in which to look for the driver.
|
---|
| 1339 | * @param pszDriver The name of the driver which to detach. If NULL
|
---|
| 1340 | * then the entire driver chain is detatched.
|
---|
| 1341 | * @param iOccurance The occurrence of that driver in the chain. This is
|
---|
| 1342 | * usually 0.
|
---|
| 1343 | * @param fFlags Flags, combination of the PDM_TACH_FLAGS_* \#defines.
|
---|
| 1344 | * @thread EMT
|
---|
| 1345 | */
|
---|
| 1346 | VMMR3DECL(int) PDMR3UsbDriverDetach(PUVM pUVM, const char *pszDevice, unsigned iDevIns, unsigned iLun,
|
---|
| 1347 | const char *pszDriver, unsigned iOccurance, uint32_t fFlags)
|
---|
| 1348 | {
|
---|
| 1349 | LogFlow(("PDMR3UsbDriverDetach: pszDevice=%p:{%s} iDevIns=%u iLun=%u pszDriver=%p:{%s} iOccurance=%u fFlags=%#x\n",
|
---|
| 1350 | pszDevice, pszDevice, iDevIns, iLun, pszDriver, iOccurance, fFlags));
|
---|
| 1351 | UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
|
---|
| 1352 | PVM pVM = pUVM->pVM;
|
---|
| 1353 | VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
|
---|
| 1354 | VM_ASSERT_EMT(pVM);
|
---|
| 1355 | AssertPtr(pszDevice);
|
---|
| 1356 | AssertPtrNull(pszDriver);
|
---|
| 1357 | Assert(iOccurance == 0 || pszDriver);
|
---|
| 1358 | Assert(!(fFlags & ~(PDM_TACH_FLAGS_NOT_HOT_PLUG)));
|
---|
| 1359 |
|
---|
| 1360 | /*
|
---|
| 1361 | * Find the LUN in question.
|
---|
| 1362 | */
|
---|
| 1363 | PPDMLUN pLun;
|
---|
| 1364 | int rc = pdmR3UsbFindLun(pVM, pszDevice, iDevIns, iLun, &pLun);
|
---|
| 1365 | if (RT_SUCCESS(rc))
|
---|
| 1366 | {
|
---|
| 1367 | /*
|
---|
| 1368 | * Locate the driver.
|
---|
| 1369 | */
|
---|
| 1370 | PPDMDRVINS pDrvIns = pLun->pTop;
|
---|
| 1371 | if (pDrvIns)
|
---|
| 1372 | {
|
---|
| 1373 | if (pszDriver)
|
---|
| 1374 | {
|
---|
| 1375 | while (pDrvIns)
|
---|
| 1376 | {
|
---|
| 1377 | if (!strcmp(pDrvIns->pReg->szName, pszDriver))
|
---|
| 1378 | {
|
---|
| 1379 | if (iOccurance == 0)
|
---|
| 1380 | break;
|
---|
| 1381 | iOccurance--;
|
---|
| 1382 | }
|
---|
| 1383 | pDrvIns = pDrvIns->Internal.s.pDown;
|
---|
| 1384 | }
|
---|
| 1385 | }
|
---|
| 1386 | if (pDrvIns)
|
---|
| 1387 | rc = pdmR3DrvDetach(pDrvIns, fFlags);
|
---|
| 1388 | else
|
---|
| 1389 | rc = VERR_PDM_DRIVER_INSTANCE_NOT_FOUND;
|
---|
| 1390 | }
|
---|
| 1391 | else
|
---|
| 1392 | rc = VINF_PDM_NO_DRIVER_ATTACHED_TO_LUN;
|
---|
| 1393 | }
|
---|
| 1394 |
|
---|
| 1395 | LogFlow(("PDMR3UsbDriverDetach: returns %Rrc\n", rc));
|
---|
| 1396 | return rc;
|
---|
| 1397 | }
|
---|
| 1398 |
|
---|
| 1399 |
|
---|
[26970] | 1400 | /** @name USB Device Helpers
|
---|
| 1401 | * @{
|
---|
| 1402 | */
|
---|
| 1403 |
|
---|
| 1404 | /** @interface_method_impl{PDMUSBHLPR3,pfnDriverAttach} */
|
---|
[42139] | 1405 | static DECLCALLBACK(int) pdmR3UsbHlp_DriverAttach(PPDMUSBINS pUsbIns, RTUINT iLun, PPDMIBASE pBaseInterface,
|
---|
| 1406 | PPDMIBASE *ppBaseInterface, const char *pszDesc)
|
---|
[26970] | 1407 | {
|
---|
| 1408 | PDMUSB_ASSERT_USBINS(pUsbIns);
|
---|
| 1409 | PVM pVM = pUsbIns->Internal.s.pVM;
|
---|
| 1410 | VM_ASSERT_EMT(pVM);
|
---|
| 1411 | LogFlow(("pdmR3UsbHlp_DriverAttach: caller='%s'/%d: iLun=%d pBaseInterface=%p ppBaseInterface=%p pszDesc=%p:{%s}\n",
|
---|
| 1412 | pUsbIns->pReg->szName, pUsbIns->iInstance, iLun, pBaseInterface, ppBaseInterface, pszDesc, pszDesc));
|
---|
| 1413 |
|
---|
| 1414 | /*
|
---|
| 1415 | * Lookup the LUN, it might already be registered.
|
---|
| 1416 | */
|
---|
| 1417 | PPDMLUN pLunPrev = NULL;
|
---|
| 1418 | PPDMLUN pLun = pUsbIns->Internal.s.pLuns;
|
---|
| 1419 | for (; pLun; pLunPrev = pLun, pLun = pLun->pNext)
|
---|
| 1420 | if (pLun->iLun == iLun)
|
---|
| 1421 | break;
|
---|
| 1422 |
|
---|
| 1423 | /*
|
---|
| 1424 | * Create the LUN if if wasn't found, else check if driver is already attached to it.
|
---|
| 1425 | */
|
---|
| 1426 | if (!pLun)
|
---|
| 1427 | {
|
---|
| 1428 | if ( !pBaseInterface
|
---|
| 1429 | || !pszDesc
|
---|
| 1430 | || !*pszDesc)
|
---|
| 1431 | {
|
---|
| 1432 | Assert(pBaseInterface);
|
---|
| 1433 | Assert(pszDesc || *pszDesc);
|
---|
| 1434 | return VERR_INVALID_PARAMETER;
|
---|
| 1435 | }
|
---|
| 1436 |
|
---|
| 1437 | pLun = (PPDMLUN)MMR3HeapAlloc(pVM, MM_TAG_PDM_LUN, sizeof(*pLun));
|
---|
| 1438 | if (!pLun)
|
---|
| 1439 | return VERR_NO_MEMORY;
|
---|
| 1440 |
|
---|
| 1441 | pLun->iLun = iLun;
|
---|
| 1442 | pLun->pNext = pLunPrev ? pLunPrev->pNext : NULL;
|
---|
| 1443 | pLun->pTop = NULL;
|
---|
| 1444 | pLun->pBottom = NULL;
|
---|
| 1445 | pLun->pDevIns = NULL;
|
---|
| 1446 | pLun->pUsbIns = pUsbIns;
|
---|
| 1447 | pLun->pszDesc = pszDesc;
|
---|
| 1448 | pLun->pBase = pBaseInterface;
|
---|
| 1449 | if (!pLunPrev)
|
---|
| 1450 | pUsbIns->Internal.s.pLuns = pLun;
|
---|
| 1451 | else
|
---|
| 1452 | pLunPrev->pNext = pLun;
|
---|
| 1453 | Log(("pdmR3UsbHlp_DriverAttach: Registered LUN#%d '%s' with device '%s'/%d.\n",
|
---|
| 1454 | iLun, pszDesc, pUsbIns->pReg->szName, pUsbIns->iInstance));
|
---|
| 1455 | }
|
---|
| 1456 | else if (pLun->pTop)
|
---|
| 1457 | {
|
---|
| 1458 | AssertMsgFailed(("Already attached! The device should keep track of such things!\n"));
|
---|
| 1459 | LogFlow(("pdmR3UsbHlp_DriverAttach: caller='%s'/%d: returns %Rrc\n", pUsbIns->pReg->szName, pUsbIns->iInstance, VERR_PDM_DRIVER_ALREADY_ATTACHED));
|
---|
| 1460 | return VERR_PDM_DRIVER_ALREADY_ATTACHED;
|
---|
| 1461 | }
|
---|
| 1462 | Assert(pLun->pBase == pBaseInterface);
|
---|
| 1463 |
|
---|
| 1464 |
|
---|
| 1465 | /*
|
---|
| 1466 | * Get the attached driver configuration.
|
---|
| 1467 | */
|
---|
| 1468 | int rc;
|
---|
| 1469 | PCFGMNODE pNode = CFGMR3GetChildF(pUsbIns->Internal.s.pCfg, "LUN#%u", iLun);
|
---|
| 1470 | if (pNode)
|
---|
| 1471 | rc = pdmR3DrvInstantiate(pVM, pNode, pBaseInterface, NULL /*pDrvAbove*/, pLun, ppBaseInterface);
|
---|
| 1472 | else
|
---|
| 1473 | rc = VERR_PDM_NO_ATTACHED_DRIVER;
|
---|
| 1474 |
|
---|
| 1475 |
|
---|
| 1476 | LogFlow(("pdmR3UsbHlp_DriverAttach: caller='%s'/%d: returns %Rrc\n", pUsbIns->pReg->szName, pUsbIns->iInstance, rc));
|
---|
| 1477 | return rc;
|
---|
| 1478 | }
|
---|
| 1479 |
|
---|
| 1480 |
|
---|
| 1481 | /** @interface_method_impl{PDMUSBHLP,pfnAssertEMT} */
|
---|
| 1482 | static DECLCALLBACK(bool) pdmR3UsbHlp_AssertEMT(PPDMUSBINS pUsbIns, const char *pszFile, unsigned iLine, const char *pszFunction)
|
---|
| 1483 | {
|
---|
| 1484 | PDMUSB_ASSERT_USBINS(pUsbIns);
|
---|
| 1485 | if (VM_IS_EMT(pUsbIns->Internal.s.pVM))
|
---|
| 1486 | return true;
|
---|
| 1487 |
|
---|
| 1488 | char szMsg[100];
|
---|
| 1489 | RTStrPrintf(szMsg, sizeof(szMsg), "AssertEMT '%s'/%d\n", pUsbIns->pReg->szName, pUsbIns->iInstance);
|
---|
| 1490 | RTAssertMsg1Weak(szMsg, iLine, pszFile, pszFunction);
|
---|
| 1491 | AssertBreakpoint();
|
---|
| 1492 | return false;
|
---|
| 1493 | }
|
---|
| 1494 |
|
---|
| 1495 |
|
---|
| 1496 | /** @interface_method_impl{PDMUSBHLP,pfnAssertOther} */
|
---|
| 1497 | static DECLCALLBACK(bool) pdmR3UsbHlp_AssertOther(PPDMUSBINS pUsbIns, const char *pszFile, unsigned iLine, const char *pszFunction)
|
---|
| 1498 | {
|
---|
| 1499 | PDMUSB_ASSERT_USBINS(pUsbIns);
|
---|
| 1500 | if (!VM_IS_EMT(pUsbIns->Internal.s.pVM))
|
---|
| 1501 | return true;
|
---|
| 1502 |
|
---|
| 1503 | char szMsg[100];
|
---|
| 1504 | RTStrPrintf(szMsg, sizeof(szMsg), "AssertOther '%s'/%d\n", pUsbIns->pReg->szName, pUsbIns->iInstance);
|
---|
| 1505 | RTAssertMsg1Weak(szMsg, iLine, pszFile, pszFunction);
|
---|
| 1506 | AssertBreakpoint();
|
---|
| 1507 | return false;
|
---|
| 1508 | }
|
---|
| 1509 |
|
---|
| 1510 |
|
---|
| 1511 | /** @interface_method_impl{PDMUSBHLP,pfnDBGFStopV} */
|
---|
| 1512 | static DECLCALLBACK(int) pdmR3UsbHlp_DBGFStopV(PPDMUSBINS pUsbIns, const char *pszFile, unsigned iLine, const char *pszFunction, const char *pszFormat, va_list args)
|
---|
| 1513 | {
|
---|
| 1514 | PDMUSB_ASSERT_USBINS(pUsbIns);
|
---|
| 1515 | #ifdef LOG_ENABLED
|
---|
| 1516 | va_list va2;
|
---|
| 1517 | va_copy(va2, args);
|
---|
| 1518 | LogFlow(("pdmR3UsbHlp_DBGFStopV: caller='%s'/%d: pszFile=%p:{%s} iLine=%d pszFunction=%p:{%s} pszFormat=%p:{%s} (%N)\n",
|
---|
| 1519 | pUsbIns->pReg->szName, pUsbIns->iInstance, pszFile, pszFile, iLine, pszFunction, pszFunction, pszFormat, pszFormat, pszFormat, &va2));
|
---|
| 1520 | va_end(va2);
|
---|
| 1521 | #endif
|
---|
| 1522 |
|
---|
| 1523 | PVM pVM = pUsbIns->Internal.s.pVM;
|
---|
| 1524 | VM_ASSERT_EMT(pVM);
|
---|
| 1525 | int rc = DBGFR3EventSrcV(pVM, DBGFEVENT_DEV_STOP, pszFile, iLine, pszFunction, pszFormat, args);
|
---|
| 1526 | if (rc == VERR_DBGF_NOT_ATTACHED)
|
---|
| 1527 | rc = VINF_SUCCESS;
|
---|
| 1528 |
|
---|
| 1529 | LogFlow(("pdmR3UsbHlp_DBGFStopV: caller='%s'/%d: returns %Rrc\n", pUsbIns->pReg->szName, pUsbIns->iInstance, rc));
|
---|
| 1530 | return rc;
|
---|
| 1531 | }
|
---|
| 1532 |
|
---|
| 1533 |
|
---|
| 1534 | /** @interface_method_impl{PDMUSBHLP,pfnDBGFInfoRegister} */
|
---|
| 1535 | static DECLCALLBACK(int) pdmR3UsbHlp_DBGFInfoRegister(PPDMUSBINS pUsbIns, const char *pszName, const char *pszDesc, PFNDBGFHANDLERUSB pfnHandler)
|
---|
| 1536 | {
|
---|
| 1537 | PDMUSB_ASSERT_USBINS(pUsbIns);
|
---|
| 1538 | LogFlow(("pdmR3UsbHlp_DBGFInfoRegister: caller='%s'/%d: pszName=%p:{%s} pszDesc=%p:{%s} pfnHandler=%p\n",
|
---|
| 1539 | pUsbIns->pReg->szName, pUsbIns->iInstance, pszName, pszName, pszDesc, pszDesc, pfnHandler));
|
---|
| 1540 |
|
---|
| 1541 | PVM pVM = pUsbIns->Internal.s.pVM;
|
---|
| 1542 | VM_ASSERT_EMT(pVM);
|
---|
[39034] | 1543 | NOREF(pVM); /** @todo int rc = DBGFR3InfoRegisterUsb(pVM, pszName, pszDesc, pfnHandler, pUsbIns); */
|
---|
[26970] | 1544 | int rc = VERR_NOT_IMPLEMENTED; AssertFailed();
|
---|
| 1545 |
|
---|
| 1546 | LogFlow(("pdmR3UsbHlp_DBGFInfoRegister: caller='%s'/%d: returns %Rrc\n", pUsbIns->pReg->szName, pUsbIns->iInstance, rc));
|
---|
| 1547 | return rc;
|
---|
| 1548 | }
|
---|
| 1549 |
|
---|
| 1550 |
|
---|
| 1551 | /** @interface_method_impl{PDMUSBHLP,pfnMMHeapAlloc} */
|
---|
| 1552 | static DECLCALLBACK(void *) pdmR3UsbHlp_MMHeapAlloc(PPDMUSBINS pUsbIns, size_t cb)
|
---|
| 1553 | {
|
---|
| 1554 | PDMUSB_ASSERT_USBINS(pUsbIns);
|
---|
| 1555 | LogFlow(("pdmR3UsbHlp_MMHeapAlloc: caller='%s'/%d: cb=%#x\n", pUsbIns->pReg->szName, pUsbIns->iInstance, cb));
|
---|
| 1556 |
|
---|
| 1557 | void *pv = MMR3HeapAlloc(pUsbIns->Internal.s.pVM, MM_TAG_PDM_USB_USER, cb);
|
---|
| 1558 |
|
---|
| 1559 | LogFlow(("pdmR3UsbHlp_MMHeapAlloc: caller='%s'/%d: returns %p\n", pUsbIns->pReg->szName, pUsbIns->iInstance, pv));
|
---|
| 1560 | return pv;
|
---|
| 1561 | }
|
---|
| 1562 |
|
---|
| 1563 |
|
---|
| 1564 | /** @interface_method_impl{PDMUSBHLP,pfnMMHeapAllocZ} */
|
---|
| 1565 | static DECLCALLBACK(void *) pdmR3UsbHlp_MMHeapAllocZ(PPDMUSBINS pUsbIns, size_t cb)
|
---|
| 1566 | {
|
---|
| 1567 | PDMUSB_ASSERT_USBINS(pUsbIns);
|
---|
| 1568 | LogFlow(("pdmR3UsbHlp_MMHeapAllocZ: caller='%s'/%d: cb=%#x\n", pUsbIns->pReg->szName, pUsbIns->iInstance, cb));
|
---|
| 1569 |
|
---|
| 1570 | void *pv = MMR3HeapAllocZ(pUsbIns->Internal.s.pVM, MM_TAG_PDM_USB_USER, cb);
|
---|
| 1571 |
|
---|
| 1572 | LogFlow(("pdmR3UsbHlp_MMHeapAllocZ: caller='%s'/%d: returns %p\n", pUsbIns->pReg->szName, pUsbIns->iInstance, pv));
|
---|
| 1573 | return pv;
|
---|
| 1574 | }
|
---|
| 1575 |
|
---|
| 1576 |
|
---|
| 1577 | /** @interface_method_impl{PDMUSBHLP,pfnPDMQueueCreate} */
|
---|
| 1578 | static DECLCALLBACK(int) pdmR3UsbHlp_PDMQueueCreate(PPDMUSBINS pUsbIns, RTUINT cbItem, RTUINT cItems, uint32_t cMilliesInterval,
|
---|
| 1579 | PFNPDMQUEUEUSB pfnCallback, const char *pszName, PPDMQUEUE *ppQueue)
|
---|
| 1580 | {
|
---|
| 1581 | PDMUSB_ASSERT_USBINS(pUsbIns);
|
---|
| 1582 | LogFlow(("pdmR3UsbHlp_PDMQueueCreate: caller='%s'/%d: cbItem=%#x cItems=%#x cMilliesInterval=%u pfnCallback=%p pszName=%p:{%s} ppQueue=%p\n",
|
---|
| 1583 | pUsbIns->pReg->szName, pUsbIns->iInstance, cbItem, cItems, cMilliesInterval, pfnCallback, pszName, pszName, ppQueue));
|
---|
| 1584 |
|
---|
| 1585 | PVM pVM = pUsbIns->Internal.s.pVM;
|
---|
| 1586 | VM_ASSERT_EMT(pVM);
|
---|
| 1587 |
|
---|
| 1588 | if (pUsbIns->iInstance > 0)
|
---|
| 1589 | {
|
---|
| 1590 | pszName = MMR3HeapAPrintf(pVM, MM_TAG_PDM_DEVICE_DESC, "%s_%u", pszName, pUsbIns->iInstance);
|
---|
| 1591 | AssertLogRelReturn(pszName, VERR_NO_MEMORY);
|
---|
| 1592 | }
|
---|
| 1593 |
|
---|
| 1594 | /** @todo int rc = PDMR3QueueCreateUsb(pVM, pUsbIns, cbItem, cItems, cMilliesInterval, pfnCallback, fGCEnabled, pszName, ppQueue); */
|
---|
| 1595 | int rc = VERR_NOT_IMPLEMENTED; AssertFailed();
|
---|
| 1596 |
|
---|
| 1597 | LogFlow(("pdmR3UsbHlp_PDMQueueCreate: caller='%s'/%d: returns %Rrc *ppQueue=%p\n", pUsbIns->pReg->szName, pUsbIns->iInstance, rc, *ppQueue));
|
---|
| 1598 | return rc;
|
---|
| 1599 | }
|
---|
| 1600 |
|
---|
| 1601 |
|
---|
| 1602 | /** @interface_method_impl{PDMUSBHLP,pfnSSMRegister} */
|
---|
| 1603 | static DECLCALLBACK(int) pdmR3UsbHlp_SSMRegister(PPDMUSBINS pUsbIns, uint32_t uVersion, size_t cbGuess,
|
---|
| 1604 | PFNSSMUSBLIVEPREP pfnLivePrep, PFNSSMUSBLIVEEXEC pfnLiveExec, PFNSSMUSBLIVEVOTE pfnLiveVote,
|
---|
| 1605 | PFNSSMUSBSAVEPREP pfnSavePrep, PFNSSMUSBSAVEEXEC pfnSaveExec, PFNSSMUSBSAVEDONE pfnSaveDone,
|
---|
| 1606 | PFNSSMUSBLOADPREP pfnLoadPrep, PFNSSMUSBLOADEXEC pfnLoadExec, PFNSSMUSBLOADDONE pfnLoadDone)
|
---|
| 1607 | {
|
---|
| 1608 | PDMUSB_ASSERT_USBINS(pUsbIns);
|
---|
| 1609 | VM_ASSERT_EMT(pUsbIns->Internal.s.pVM);
|
---|
| 1610 | LogFlow(("pdmR3UsbHlp_SSMRegister: caller='%s'/%d: uVersion=#x cbGuess=%#x\n"
|
---|
| 1611 | " pfnLivePrep=%p pfnLiveExec=%p pfnLiveVote=%p pfnSavePrep=%p pfnSaveExec=%p pfnSaveDone=%p pszLoadPrep=%p pfnLoadExec=%p pfnLoadDone=%p\n",
|
---|
| 1612 | pUsbIns->pReg->szName, pUsbIns->iInstance, uVersion, cbGuess,
|
---|
| 1613 | pfnLivePrep, pfnLiveExec, pfnLiveVote,
|
---|
| 1614 | pfnSavePrep, pfnSaveExec, pfnSaveDone,
|
---|
| 1615 | pfnLoadPrep, pfnLoadExec, pfnLoadDone));
|
---|
| 1616 |
|
---|
| 1617 | int rc = SSMR3RegisterUsb(pUsbIns->Internal.s.pVM, pUsbIns, pUsbIns->pReg->szName, pUsbIns->iInstance,
|
---|
| 1618 | uVersion, cbGuess,
|
---|
| 1619 | pfnLivePrep, pfnLiveExec, pfnLiveVote,
|
---|
| 1620 | pfnSavePrep, pfnSaveExec, pfnSaveDone,
|
---|
[48986] | 1621 | pfnLoadPrep, pfnLoadExec, pfnLoadDone);
|
---|
[26970] | 1622 |
|
---|
| 1623 | LogFlow(("pdmR3UsbHlp_SSMRegister: caller='%s'/%d: returns %Rrc\n", pUsbIns->pReg->szName, pUsbIns->iInstance, rc));
|
---|
| 1624 | return rc;
|
---|
| 1625 | }
|
---|
| 1626 |
|
---|
| 1627 |
|
---|
| 1628 | /** @interface_method_impl{PDMUSBHLP,pfnSTAMRegisterV} */
|
---|
| 1629 | static DECLCALLBACK(void) pdmR3UsbHlp_STAMRegisterV(PPDMUSBINS pUsbIns, void *pvSample, STAMTYPE enmType, STAMVISIBILITY enmVisibility,
|
---|
| 1630 | STAMUNIT enmUnit, const char *pszDesc, const char *pszName, va_list args)
|
---|
| 1631 | {
|
---|
| 1632 | PDMUSB_ASSERT_USBINS(pUsbIns);
|
---|
| 1633 | PVM pVM = pUsbIns->Internal.s.pVM;
|
---|
| 1634 | VM_ASSERT_EMT(pVM);
|
---|
| 1635 |
|
---|
| 1636 | int rc = STAMR3RegisterV(pVM, pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName, args);
|
---|
| 1637 | AssertRC(rc);
|
---|
| 1638 |
|
---|
| 1639 | NOREF(pVM);
|
---|
| 1640 | }
|
---|
| 1641 |
|
---|
| 1642 |
|
---|
| 1643 | /** @interface_method_impl{PDMUSBHLP,pfnTMTimerCreate} */
|
---|
| 1644 | static DECLCALLBACK(int) pdmR3UsbHlp_TMTimerCreate(PPDMUSBINS pUsbIns, TMCLOCK enmClock, PFNTMTIMERUSB pfnCallback, void *pvUser,
|
---|
| 1645 | uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer)
|
---|
| 1646 | {
|
---|
| 1647 | PDMUSB_ASSERT_USBINS(pUsbIns);
|
---|
| 1648 | PVM pVM = pUsbIns->Internal.s.pVM;
|
---|
| 1649 | VM_ASSERT_EMT(pVM);
|
---|
| 1650 | LogFlow(("pdmR3UsbHlp_TMTimerCreate: caller='%s'/%d: enmClock=%d pfnCallback=%p pvUser=%p fFlags=%#x pszDesc=%p:{%s} ppTimer=%p\n",
|
---|
| 1651 | pUsbIns->pReg->szName, pUsbIns->iInstance, enmClock, pfnCallback, pvUser, fFlags, pszDesc, pszDesc, ppTimer));
|
---|
| 1652 |
|
---|
| 1653 | if (pUsbIns->iInstance > 0) /** @todo use a string cache here later. */
|
---|
| 1654 | {
|
---|
| 1655 | char *pszDesc2 = MMR3HeapAPrintf(pVM, MM_TAG_PDM_USB_DESC, "%s [%u]", pszDesc, pUsbIns->iInstance);
|
---|
| 1656 | if (pszDesc2)
|
---|
| 1657 | pszDesc = pszDesc2;
|
---|
| 1658 | }
|
---|
| 1659 |
|
---|
[37358] | 1660 | int rc = TMR3TimerCreateUsb(pVM, pUsbIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, ppTimer);
|
---|
[26970] | 1661 |
|
---|
| 1662 | LogFlow(("pdmR3UsbHlp_TMTimerCreate: caller='%s'/%d: returns %Rrc\n", pUsbIns->pReg->szName, pUsbIns->iInstance, rc));
|
---|
| 1663 | return rc;
|
---|
| 1664 | }
|
---|
| 1665 |
|
---|
| 1666 |
|
---|
| 1667 | /** @interface_method_impl{PDMUSBHLP,pfnVMSetErrorV} */
|
---|
| 1668 | static DECLCALLBACK(int) pdmR3UsbHlp_VMSetErrorV(PPDMUSBINS pUsbIns, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list va)
|
---|
| 1669 | {
|
---|
| 1670 | PDMUSB_ASSERT_USBINS(pUsbIns);
|
---|
| 1671 | int rc2 = VMSetErrorV(pUsbIns->Internal.s.pVM, rc, RT_SRC_POS_ARGS, pszFormat, va); Assert(rc2 == rc); NOREF(rc2);
|
---|
| 1672 | return rc;
|
---|
| 1673 | }
|
---|
| 1674 |
|
---|
| 1675 |
|
---|
| 1676 | /** @interface_method_impl{PDMUSBHLP,pfnVMSetRuntimeErrorV} */
|
---|
| 1677 | static DECLCALLBACK(int) pdmR3UsbHlp_VMSetRuntimeErrorV(PPDMUSBINS pUsbIns, uint32_t fFlags, const char *pszErrorId, const char *pszFormat, va_list va)
|
---|
| 1678 | {
|
---|
| 1679 | PDMUSB_ASSERT_USBINS(pUsbIns);
|
---|
| 1680 | int rc = VMSetRuntimeErrorV(pUsbIns->Internal.s.pVM, fFlags, pszErrorId, pszFormat, va);
|
---|
| 1681 | return rc;
|
---|
| 1682 | }
|
---|
| 1683 |
|
---|
| 1684 |
|
---|
| 1685 | /** @interface_method_impl{PDMUSBHLP,pfnVMState} */
|
---|
| 1686 | static DECLCALLBACK(VMSTATE) pdmR3UsbHlp_VMState(PPDMUSBINS pUsbIns)
|
---|
| 1687 | {
|
---|
| 1688 | PDMUSB_ASSERT_USBINS(pUsbIns);
|
---|
| 1689 |
|
---|
| 1690 | VMSTATE enmVMState = VMR3GetState(pUsbIns->Internal.s.pVM);
|
---|
| 1691 |
|
---|
| 1692 | LogFlow(("pdmR3UsbHlp_VMState: caller='%s'/%d: returns %d (%s)\n", pUsbIns->pReg->szName, pUsbIns->iInstance,
|
---|
| 1693 | enmVMState, VMR3GetStateName(enmVMState)));
|
---|
| 1694 | return enmVMState;
|
---|
| 1695 | }
|
---|
| 1696 |
|
---|
[37859] | 1697 | /** @interface_method_impl{PDMUSBHLP,pfnThreadCreate} */
|
---|
| 1698 | static DECLCALLBACK(int) pdmR3UsbHlp_ThreadCreate(PPDMUSBINS pUsbIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADUSB pfnThread,
|
---|
| 1699 | PFNPDMTHREADWAKEUPUSB pfnWakeup, size_t cbStack, RTTHREADTYPE enmType, const char *pszName)
|
---|
| 1700 | {
|
---|
[37879] | 1701 | PDMUSB_ASSERT_USBINS(pUsbIns);
|
---|
[37859] | 1702 | VM_ASSERT_EMT(pUsbIns->Internal.s.pVM);
|
---|
| 1703 | LogFlow(("pdmR3UsbHlp_ThreadCreate: caller='%s'/%d: ppThread=%p pvUser=%p pfnThread=%p pfnWakeup=%p cbStack=%#zx enmType=%d pszName=%p:{%s}\n",
|
---|
| 1704 | pUsbIns->pReg->szName, pUsbIns->iInstance, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName, pszName));
|
---|
| 1705 |
|
---|
| 1706 | int rc = pdmR3ThreadCreateUsb(pUsbIns->Internal.s.pVM, pUsbIns, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName);
|
---|
| 1707 |
|
---|
| 1708 | LogFlow(("pdmR3UsbHlp_ThreadCreate: caller='%s'/%d: returns %Rrc *ppThread=%RTthrd\n", pUsbIns->pReg->szName, pUsbIns->iInstance,
|
---|
| 1709 | rc, *ppThread));
|
---|
| 1710 | return rc;
|
---|
| 1711 | }
|
---|
| 1712 |
|
---|
| 1713 |
|
---|
[26970] | 1714 | /** @interface_method_impl{PDMUSBHLP,pfnSetAsyncNotification} */
|
---|
| 1715 | static DECLCALLBACK(int) pdmR3UsbHlp_SetAsyncNotification(PPDMUSBINS pUsbIns, PFNPDMUSBASYNCNOTIFY pfnAsyncNotify)
|
---|
| 1716 | {
|
---|
| 1717 | PDMUSB_ASSERT_USBINS(pUsbIns);
|
---|
| 1718 | VM_ASSERT_EMT0(pUsbIns->Internal.s.pVM);
|
---|
| 1719 | LogFlow(("pdmR3UsbHlp_SetAsyncNotification: caller='%s'/%d: pfnAsyncNotify=%p\n", pUsbIns->pReg->szName, pUsbIns->iInstance, pfnAsyncNotify));
|
---|
| 1720 |
|
---|
| 1721 | int rc = VINF_SUCCESS;
|
---|
| 1722 | AssertStmt(pfnAsyncNotify, rc = VERR_INVALID_PARAMETER);
|
---|
| 1723 | AssertStmt(!pUsbIns->Internal.s.pfnAsyncNotify, rc = VERR_WRONG_ORDER);
|
---|
| 1724 | AssertStmt(pUsbIns->Internal.s.fVMSuspended || pUsbIns->Internal.s.fVMReset, rc = VERR_WRONG_ORDER);
|
---|
| 1725 | VMSTATE enmVMState = VMR3GetState(pUsbIns->Internal.s.pVM);
|
---|
| 1726 | AssertStmt( enmVMState == VMSTATE_SUSPENDING
|
---|
| 1727 | || enmVMState == VMSTATE_SUSPENDING_EXT_LS
|
---|
| 1728 | || enmVMState == VMSTATE_SUSPENDING_LS
|
---|
| 1729 | || enmVMState == VMSTATE_RESETTING
|
---|
| 1730 | || enmVMState == VMSTATE_RESETTING_LS
|
---|
| 1731 | || enmVMState == VMSTATE_POWERING_OFF
|
---|
| 1732 | || enmVMState == VMSTATE_POWERING_OFF_LS,
|
---|
| 1733 | rc = VERR_INVALID_STATE);
|
---|
| 1734 |
|
---|
| 1735 | if (RT_SUCCESS(rc))
|
---|
| 1736 | pUsbIns->Internal.s.pfnAsyncNotify = pfnAsyncNotify;
|
---|
| 1737 |
|
---|
| 1738 | LogFlow(("pdmR3UsbHlp_SetAsyncNotification: caller='%s'/%d: returns %Rrc\n", pUsbIns->pReg->szName, pUsbIns->iInstance, rc));
|
---|
| 1739 | return rc;
|
---|
| 1740 | }
|
---|
| 1741 |
|
---|
| 1742 |
|
---|
| 1743 | /** @interface_method_impl{PDMUSBHLP,pfnAsyncNotificationCompleted} */
|
---|
| 1744 | static DECLCALLBACK(void) pdmR3UsbHlp_AsyncNotificationCompleted(PPDMUSBINS pUsbIns)
|
---|
| 1745 | {
|
---|
| 1746 | PDMUSB_ASSERT_USBINS(pUsbIns);
|
---|
| 1747 | PVM pVM = pUsbIns->Internal.s.pVM;
|
---|
| 1748 |
|
---|
| 1749 | VMSTATE enmVMState = VMR3GetState(pVM);
|
---|
| 1750 | if ( enmVMState == VMSTATE_SUSPENDING
|
---|
| 1751 | || enmVMState == VMSTATE_SUSPENDING_EXT_LS
|
---|
| 1752 | || enmVMState == VMSTATE_SUSPENDING_LS
|
---|
| 1753 | || enmVMState == VMSTATE_RESETTING
|
---|
| 1754 | || enmVMState == VMSTATE_RESETTING_LS
|
---|
| 1755 | || enmVMState == VMSTATE_POWERING_OFF
|
---|
| 1756 | || enmVMState == VMSTATE_POWERING_OFF_LS)
|
---|
| 1757 | {
|
---|
| 1758 | LogFlow(("pdmR3UsbHlp_AsyncNotificationCompleted: caller='%s'/%d:\n", pUsbIns->pReg->szName, pUsbIns->iInstance));
|
---|
| 1759 | VMR3AsyncPdmNotificationWakeupU(pVM->pUVM);
|
---|
| 1760 | }
|
---|
| 1761 | else
|
---|
| 1762 | LogFlow(("pdmR3UsbHlp_AsyncNotificationCompleted: caller='%s'/%d: enmVMState=%d\n", pUsbIns->pReg->szName, pUsbIns->iInstance, enmVMState));
|
---|
| 1763 | }
|
---|
| 1764 |
|
---|
| 1765 |
|
---|
[46788] | 1766 | /** @interface_method_impl{PDMUSBHLP,pfnVMGetSuspendReason} */
|
---|
| 1767 | static DECLCALLBACK(VMSUSPENDREASON) pdmR3UsbHlp_VMGetSuspendReason(PPDMUSBINS pUsbIns)
|
---|
| 1768 | {
|
---|
| 1769 | PDMUSB_ASSERT_USBINS(pUsbIns);
|
---|
| 1770 | PVM pVM = pUsbIns->Internal.s.pVM;
|
---|
| 1771 | VM_ASSERT_EMT(pVM);
|
---|
| 1772 | VMSUSPENDREASON enmReason = VMR3GetSuspendReason(pVM->pUVM);
|
---|
| 1773 | LogFlow(("pdmR3UsbHlp_VMGetSuspendReason: caller='%s'/%d: returns %d\n",
|
---|
| 1774 | pUsbIns->pReg->szName, pUsbIns->iInstance, enmReason));
|
---|
| 1775 | return enmReason;
|
---|
| 1776 | }
|
---|
| 1777 |
|
---|
| 1778 |
|
---|
| 1779 | /** @interface_method_impl{PDMUSBHLP,pfnVMGetResumeReason} */
|
---|
| 1780 | static DECLCALLBACK(VMRESUMEREASON) pdmR3UsbHlp_VMGetResumeReason(PPDMUSBINS pUsbIns)
|
---|
| 1781 | {
|
---|
| 1782 | PDMUSB_ASSERT_USBINS(pUsbIns);
|
---|
| 1783 | PVM pVM = pUsbIns->Internal.s.pVM;
|
---|
| 1784 | VM_ASSERT_EMT(pVM);
|
---|
| 1785 | VMRESUMEREASON enmReason = VMR3GetResumeReason(pVM->pUVM);
|
---|
| 1786 | LogFlow(("pdmR3UsbHlp_VMGetResumeReason: caller='%s'/%d: returns %d\n",
|
---|
| 1787 | pUsbIns->pReg->szName, pUsbIns->iInstance, enmReason));
|
---|
| 1788 | return enmReason;
|
---|
| 1789 | }
|
---|
| 1790 |
|
---|
| 1791 |
|
---|
[26970] | 1792 | /**
|
---|
| 1793 | * The USB device helper structure.
|
---|
| 1794 | */
|
---|
| 1795 | const PDMUSBHLP g_pdmR3UsbHlp =
|
---|
| 1796 | {
|
---|
| 1797 | PDM_USBHLP_VERSION,
|
---|
| 1798 | pdmR3UsbHlp_DriverAttach,
|
---|
| 1799 | pdmR3UsbHlp_AssertEMT,
|
---|
| 1800 | pdmR3UsbHlp_AssertOther,
|
---|
| 1801 | pdmR3UsbHlp_DBGFStopV,
|
---|
| 1802 | pdmR3UsbHlp_DBGFInfoRegister,
|
---|
| 1803 | pdmR3UsbHlp_MMHeapAlloc,
|
---|
| 1804 | pdmR3UsbHlp_MMHeapAllocZ,
|
---|
| 1805 | pdmR3UsbHlp_PDMQueueCreate,
|
---|
| 1806 | pdmR3UsbHlp_SSMRegister,
|
---|
| 1807 | pdmR3UsbHlp_STAMRegisterV,
|
---|
| 1808 | pdmR3UsbHlp_TMTimerCreate,
|
---|
| 1809 | pdmR3UsbHlp_VMSetErrorV,
|
---|
| 1810 | pdmR3UsbHlp_VMSetRuntimeErrorV,
|
---|
| 1811 | pdmR3UsbHlp_VMState,
|
---|
[37859] | 1812 | pdmR3UsbHlp_ThreadCreate,
|
---|
[26970] | 1813 | pdmR3UsbHlp_SetAsyncNotification,
|
---|
| 1814 | pdmR3UsbHlp_AsyncNotificationCompleted,
|
---|
[46788] | 1815 | pdmR3UsbHlp_VMGetSuspendReason,
|
---|
| 1816 | pdmR3UsbHlp_VMGetResumeReason,
|
---|
| 1817 | NULL,
|
---|
| 1818 | NULL,
|
---|
| 1819 | NULL,
|
---|
| 1820 | NULL,
|
---|
| 1821 | NULL,
|
---|
| 1822 | NULL,
|
---|
| 1823 | NULL,
|
---|
| 1824 | NULL,
|
---|
| 1825 | NULL,
|
---|
| 1826 | NULL,
|
---|
[26970] | 1827 | PDM_USBHLP_VERSION
|
---|
| 1828 | };
|
---|
| 1829 |
|
---|
| 1830 | /** @} */
|
---|