VirtualBox

source: vbox/trunk/src/VBox/Devices/USB/VUSBDevice.cpp@ 49983

Last change on this file since 49983 was 49814, checked in by vboxsync, 11 years ago

Devices/USB: First part of the rework, move most of the work to dedicated threads to improve performance
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 56.2 KB
Line 
1/* $Id: VUSBDevice.cpp 49814 2013-12-06 21:38:28Z vboxsync $ */
2/** @file
3 * Virtual USB - Device.
4 */
5
6/*
7 * Copyright (C) 2006-2012 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18
19/*******************************************************************************
20* Header Files *
21*******************************************************************************/
22#define LOG_GROUP LOG_GROUP_DRV_VUSB
23#include <VBox/vmm/pdm.h>
24#include <VBox/vmm/vmapi.h>
25#include <VBox/err.h>
26#include <VBox/log.h>
27#include <iprt/alloc.h>
28#include <iprt/time.h>
29#include <iprt/thread.h>
30#include <iprt/semaphore.h>
31#include <iprt/string.h>
32#include <iprt/assert.h>
33#include <iprt/asm.h>
34#include "VUSBInternal.h"
35
36
37/** Asserts that the give device state is valid. */
38#define VUSBDEV_ASSERT_VALID_STATE(enmState) \
39 AssertMsg((enmState) > VUSB_DEVICE_STATE_INVALID && (enmState) < VUSB_DEVICE_STATE_DESTROYED, ("enmState=%#x\n", enmState));
40
41
42/*******************************************************************************
43* Structures and Typedefs *
44*******************************************************************************/
45/**
46 * Argument package of vusbDevResetThread().
47 */
48typedef struct vusb_reset_args
49{
50 /** Pointer to the device which is being reset. */
51 PVUSBDEV pDev;
52 /** Can reset on linux. */
53 bool fResetOnLinux;
54 /** The reset return code. */
55 int rc;
56 /** Pointer to the completion callback. */
57 PFNVUSBRESETDONE pfnDone;
58 /** User argument to pfnDone. */
59 void *pvUser;
60} VUSBRESETARGS, *PVUSBRESETARGS;
61
62
63/*******************************************************************************
64* Global Variables *
65*******************************************************************************/
66/** Default message pipe. */
67const VUSBDESCENDPOINTEX g_Endpoint0 =
68{
69 {
70 /* .bLength = */ VUSB_DT_ENDPOINT_MIN_LEN,
71 /* .bDescriptorType = */ VUSB_DT_ENDPOINT,
72 /* .bEndpointAddress = */ 0,
73 /* .bmAttributes = */ 0,
74 /* .wMaxPacketSize = */ 64,
75 /* .bInterval = */ 0
76 },
77 NULL
78};
79
80/** Default configuration. */
81const VUSBDESCCONFIGEX g_Config0 =
82{
83 {
84 /* .bLength = */ VUSB_DT_CONFIG_MIN_LEN,
85 /* .bDescriptorType = */ VUSB_DT_CONFIG,
86 /* .WTotalLength = */ 0, /* (auto-calculated) */
87 /* .bNumInterfaces = */ 0,
88 /* .bConfigurationValue =*/ 0,
89 /* .iConfiguration = */ 0,
90 /* .bmAttributes = */ 0x80,
91 /* .MaxPower = */ 14
92 },
93 NULL,
94 NULL
95};
96
97
98
99static PCVUSBDESCCONFIGEX vusbDevFindCfgDesc(PVUSBDEV pDev, int iCfg)
100{
101 if (iCfg == 0)
102 return &g_Config0;
103
104 for (unsigned i = 0; i < pDev->pDescCache->pDevice->bNumConfigurations; i++)
105 if (pDev->pDescCache->paConfigs[i].Core.bConfigurationValue == iCfg)
106 return &pDev->pDescCache->paConfigs[i];
107 return NULL;
108}
109
110static PVUSBINTERFACESTATE vusbDevFindIfState(PVUSBDEV pDev, int iIf)
111{
112 for (unsigned i = 0; i < pDev->pCurCfgDesc->Core.bNumInterfaces; i++)
113 if (pDev->paIfStates[i].pIf->paSettings[0].Core.bInterfaceNumber == iIf)
114 return &pDev->paIfStates[i];
115 return NULL;
116}
117
118static PCVUSBDESCINTERFACEEX vusbDevFindAltIfDesc(PVUSBDEV pDev, PCVUSBINTERFACESTATE pIfState, int iAlt)
119{
120 for (uint32_t i = 0; i < pIfState->pIf->cSettings; i++)
121 if (pIfState->pIf->paSettings[i].Core.bAlternateSetting == iAlt)
122 return &pIfState->pIf->paSettings[i];
123 return NULL;
124}
125
126void vusbDevMapEndpoint(PVUSBDEV pDev, PCVUSBDESCENDPOINTEX pEndPtDesc)
127{
128 uint8_t i8Addr = pEndPtDesc->Core.bEndpointAddress & 0xF;
129 PVUSBPIPE pPipe = &pDev->aPipes[i8Addr];
130 LogFlow(("vusbDevMapEndpoint: pDev=%p[%s] pEndPtDesc=%p{.bEndpointAddress=%#x, .bmAttributes=%#x} p=%p stage %s->SETUP\n",
131 pDev, pDev->pUsbIns->pszName, pEndPtDesc, pEndPtDesc->Core.bEndpointAddress, pEndPtDesc->Core.bmAttributes,
132 pPipe, g_apszCtlStates[pPipe->pCtrl ? pPipe->pCtrl->enmStage : 3]));
133
134 pPipe->ReadAheadThread = NIL_RTTHREAD;
135 if ((pEndPtDesc->Core.bmAttributes & 0x3) == 0)
136 {
137 Log(("vusb: map message pipe on address %u\n", i8Addr));
138 pPipe->in = pEndPtDesc;
139 pPipe->out = pEndPtDesc;
140 }
141 else if (pEndPtDesc->Core.bEndpointAddress & 0x80)
142 {
143 Log(("vusb: map input pipe on address %u\n", i8Addr));
144 pPipe->in = pEndPtDesc;
145
146#if defined(RT_OS_LINUX) || defined(RT_OS_SOLARIS)
147 /*
148 * For high-speed isochronous input endpoints, spin off a read-ahead buffering thread.
149 */
150 if ((pEndPtDesc->Core.bmAttributes & 0x03) == 1)
151 vusbReadAheadStart(pDev, pPipe);
152#endif
153 }
154 else
155 {
156 Log(("vusb: map output pipe on address %u\n", i8Addr));
157 pPipe->out = pEndPtDesc;
158 }
159
160 if (pPipe->pCtrl)
161 {
162 vusbMsgFreeExtraData(pPipe->pCtrl);
163 pPipe->pCtrl = NULL;
164 }
165}
166
167static void unmap_endpoint(PVUSBDEV pDev, PCVUSBDESCENDPOINTEX pEndPtDesc)
168{
169 uint8_t EndPt = pEndPtDesc->Core.bEndpointAddress & 0xF;
170 PVUSBPIPE pPipe = &pDev->aPipes[EndPt];
171 LogFlow(("unmap_endpoint: pDev=%p[%s] pEndPtDesc=%p{.bEndpointAddress=%#x, .bmAttributes=%#x} p=%p stage %s->SETUP\n",
172 pDev, pDev->pUsbIns->pszName, pEndPtDesc, pEndPtDesc->Core.bEndpointAddress, pEndPtDesc->Core.bmAttributes,
173 pPipe, g_apszCtlStates[pPipe->pCtrl ? pPipe->pCtrl->enmStage : 3]));
174
175 if ((pEndPtDesc->Core.bmAttributes & 0x3) == 0)
176 {
177 Log(("vusb: unmap MSG pipe from address %u (%#x)\n", EndPt, pEndPtDesc->Core.bEndpointAddress));
178 pPipe->in = NULL;
179 pPipe->out = NULL;
180 }
181 else if (pEndPtDesc->Core.bEndpointAddress & 0x80)
182 {
183 Log(("vusb: unmap IN pipe from address %u (%#x)\n", EndPt, pEndPtDesc->Core.bEndpointAddress));
184 pPipe->in = NULL;
185
186 /* If there was a read-ahead thread associated with this endpoint, tell it to go away. */
187 if (pPipe->pvReadAheadArgs)
188 {
189 Log(("vusb: and tell read-ahead thread for the endpoint to terminate\n"));
190 vusbReadAheadStop(pPipe->pvReadAheadArgs);
191 }
192 }
193 else
194 {
195 Log(("vusb: unmap OUT pipe from address %u (%#x)\n", EndPt, pEndPtDesc->Core.bEndpointAddress));
196 pPipe->out = NULL;
197 }
198
199 if (pPipe->pCtrl)
200 {
201 vusbMsgFreeExtraData(pPipe->pCtrl);
202 pPipe->pCtrl = NULL;
203 }
204}
205
206static void map_interface(PVUSBDEV pDev, PCVUSBDESCINTERFACEEX pIfDesc)
207{
208 LogFlow(("map_interface: pDev=%p[%s] pIfDesc=%p:{.iInterface=%d, .bAlternateSetting=%d}\n",
209 pDev, pDev->pUsbIns->pszName, pIfDesc, pIfDesc->Core.iInterface, pIfDesc->Core.bAlternateSetting));
210
211 for (unsigned i = 0; i < pIfDesc->Core.bNumEndpoints; i++)
212 {
213 if ((pIfDesc->paEndpoints[i].Core.bEndpointAddress & 0xF) == VUSB_PIPE_DEFAULT)
214 Log(("vusb: Endpoint 0x%x on interface %u.%u tried to override the default message pipe!!!\n",
215 pIfDesc->paEndpoints[i].Core.bEndpointAddress, pIfDesc->Core.bInterfaceNumber, pIfDesc->Core.bAlternateSetting));
216 else
217 vusbDevMapEndpoint(pDev, &pIfDesc->paEndpoints[i]);
218 }
219}
220
221bool vusbDevDoSelectConfig(PVUSBDEV pDev, PCVUSBDESCCONFIGEX pCfgDesc)
222{
223 LogFlow(("vusbDevDoSelectConfig: pDev=%p[%s] pCfgDesc=%p:{.iConfiguration=%d}\n",
224 pDev, pDev->pUsbIns->pszName, pCfgDesc, pCfgDesc->Core.iConfiguration));
225
226 /*
227 * Clean up all pipes and interfaces.
228 */
229 unsigned i;
230 for (i = 0; i < VUSB_PIPE_MAX; i++)
231 {
232 if (i != VUSB_PIPE_DEFAULT)
233 {
234 vusbMsgFreeExtraData(pDev->aPipes[i].pCtrl);
235 memset(&pDev->aPipes[i], 0, sizeof(pDev->aPipes[i]));
236 }
237 }
238 memset(pDev->paIfStates, 0, pCfgDesc->Core.bNumInterfaces * sizeof(pDev->paIfStates[0]));
239
240 /*
241 * Map in the default setting for every interface.
242 */
243 for (i = 0; i < pCfgDesc->Core.bNumInterfaces; i++)
244 {
245 PCVUSBINTERFACE pIf;
246 struct vusb_interface_state *pIfState;
247
248 pIf = &pCfgDesc->paIfs[i];
249 pIfState = &pDev->paIfStates[i];
250 pIfState->pIf = pIf;
251
252 /*
253 * Find the 0 setting, if it is not present we just use
254 * the lowest numbered one.
255 */
256 for (uint32_t j = 0; j < pIf->cSettings; j++)
257 {
258 if ( !pIfState->pCurIfDesc
259 || pIf->paSettings[j].Core.bAlternateSetting < pIfState->pCurIfDesc->Core.bAlternateSetting)
260 pIfState->pCurIfDesc = &pIf->paSettings[j];
261 if (pIfState->pCurIfDesc->Core.bAlternateSetting == 0)
262 break;
263 }
264
265 if (pIfState->pCurIfDesc)
266 map_interface(pDev, pIfState->pCurIfDesc);
267 }
268
269 pDev->pCurCfgDesc = pCfgDesc;
270
271 if (pCfgDesc->Core.bmAttributes & 0x40)
272 pDev->u16Status |= (1 << VUSB_DEV_SELF_POWERED);
273 else
274 pDev->u16Status &= ~(1 << VUSB_DEV_SELF_POWERED);
275
276 return true;
277}
278
279/**
280 * Standard device request: SET_CONFIGURATION
281 * @returns success indicator.
282 */
283static bool vusbDevStdReqSetConfig(PVUSBDEV pDev, int EndPt, PVUSBSETUP pSetup, uint8_t *pbBuf, uint32_t *pcbBuf)
284{
285 unsigned iCfg = pSetup->wValue & 0xff;
286
287 if ((pSetup->bmRequestType & VUSB_RECIP_MASK) != VUSB_TO_DEVICE)
288 {
289 Log(("vusb: error: %s: SET_CONFIGURATION - invalid request (dir) !!!\n", pDev->pUsbIns->pszName, iCfg));
290 return false;
291 }
292
293 /*
294 * Check that the device is in a valid state.
295 * (The caller has already checked that it's not being reset.)
296 */
297 const VUSBDEVICESTATE enmState = pDev->enmState;
298 if (enmState == VUSB_DEVICE_STATE_DEFAULT)
299 {
300 LogFlow(("vusbDevStdReqSetConfig: %s: default dev state !!?\n", pDev->pUsbIns->pszName));
301 return false;
302 }
303
304 PCVUSBDESCCONFIGEX pNewCfgDesc = vusbDevFindCfgDesc(pDev, iCfg);
305 if (!pNewCfgDesc)
306 {
307 Log(("vusb: error: %s: config %i not found !!!\n", pDev->pUsbIns->pszName, iCfg));
308 return false;
309 }
310
311 if (iCfg == 0)
312 pDev->enmState = VUSB_DEVICE_STATE_ADDRESS;
313 else
314 pDev->enmState = VUSB_DEVICE_STATE_CONFIGURED;
315 if (pDev->pUsbIns->pReg->pfnUsbSetConfiguration)
316 {
317 int rc = pDev->pUsbIns->pReg->pfnUsbSetConfiguration(pDev->pUsbIns, pNewCfgDesc->Core.bConfigurationValue,
318 pDev->pCurCfgDesc, pDev->paIfStates, pNewCfgDesc);
319 if (RT_FAILURE(rc))
320 {
321 Log(("vusb: error: %s: failed to set config %i (%Rrc) !!!\n", pDev->pUsbIns->pszName, iCfg, rc));
322 return false;
323 }
324 }
325 Log(("vusb: %p[%s]: SET_CONFIGURATION: Selected config %u\n", pDev, pDev->pUsbIns->pszName, iCfg));
326 return vusbDevDoSelectConfig(pDev, pNewCfgDesc);
327}
328
329
330/**
331 * Standard device request: GET_CONFIGURATION
332 * @returns success indicator.
333 */
334static bool vusbDevStdReqGetConfig(PVUSBDEV pDev, int EndPt, PVUSBSETUP pSetup, uint8_t *pbBuf, uint32_t *pcbBuf)
335{
336 if ((pSetup->bmRequestType & VUSB_RECIP_MASK) != VUSB_TO_DEVICE)
337 {
338 Log(("vusb: error: %s: GET_CONFIGURATION - invalid request (dir) !!!\n", pDev->pUsbIns->pszName));
339 return false;
340 }
341
342 /*
343 * Check that the device is in a valid state.
344 * (The caller has already checked that it's not being reset.)
345 */
346 const VUSBDEVICESTATE enmState = pDev->enmState;
347 if ( enmState != VUSB_DEVICE_STATE_CONFIGURED
348 && enmState != VUSB_DEVICE_STATE_ADDRESS)
349 {
350 LogFlow(("vusbDevStdReqGetConfig: error: %s: invalid device state %d!!!\n", pDev->pUsbIns->pszName, enmState));
351 return false;
352 }
353
354 if (*pcbBuf < 1)
355 {
356 LogFlow(("vusbDevStdReqGetConfig: %s: no space for data!\n", pDev->pUsbIns->pszName));
357 return true;
358 }
359
360 uint8_t iCfg;
361 if (pDev->enmState == VUSB_DEVICE_STATE_ADDRESS)
362 iCfg = 0;
363 else
364 iCfg = pDev->pCurCfgDesc->Core.bConfigurationValue;
365
366 *pbBuf = iCfg;
367 *pcbBuf = 1;
368 LogFlow(("vusbDevStdReqGetConfig: %s: returns iCfg=%d\n", pDev->pUsbIns->pszName, iCfg));
369 return true;
370}
371
372/**
373 * Standard device request: GET_INTERFACE
374 * @returns success indicator.
375 */
376static bool vusbDevStdReqGetInterface(PVUSBDEV pDev, int EndPt, PVUSBSETUP pSetup, uint8_t *pbBuf, uint32_t *pcbBuf)
377{
378 if ((pSetup->bmRequestType & VUSB_RECIP_MASK) != VUSB_TO_INTERFACE)
379 {
380 Log(("vusb: error: %s: GET_INTERFACE - invalid request (dir) !!!\n", pDev->pUsbIns->pszName));
381 return false;
382 }
383
384 /*
385 * Check that the device is in a valid state.
386 * (The caller has already checked that it's not being reset.)
387 */
388 const VUSBDEVICESTATE enmState = pDev->enmState;
389 if (enmState != VUSB_DEVICE_STATE_CONFIGURED)
390 {
391 LogFlow(("vusbDevStdReqGetInterface: error: %s: invalid device state %d!!!\n", pDev->pUsbIns->pszName, enmState));
392 return false;
393 }
394
395 if (*pcbBuf < 1)
396 {
397 LogFlow(("vusbDevStdReqGetInterface: %s: no space for data!\n", pDev->pUsbIns->pszName));
398 return true;
399 }
400
401 for (unsigned i = 0; i < pDev->pCurCfgDesc->Core.bNumInterfaces; i++)
402 {
403 PCVUSBDESCINTERFACEEX pIfDesc = pDev->paIfStates[i].pCurIfDesc;
404 if ( pIfDesc
405 && pSetup->wIndex == pIfDesc->Core.bInterfaceNumber)
406 {
407 *pbBuf = pIfDesc->Core.bAlternateSetting;
408 *pcbBuf = 1;
409 Log(("vusb: %s: GET_INTERFACE: %u.%u\n", pDev->pUsbIns->pszName, pIfDesc->Core.bInterfaceNumber, *pbBuf));
410 return true;
411 }
412 }
413
414 Log(("vusb: error: %s: GET_INTERFACE - unknown iface %u !!!\n", pDev->pUsbIns->pszName, pSetup->wIndex));
415 return false;
416}
417
418/**
419 * Standard device request: SET_INTERFACE
420 * @returns success indicator.
421 */
422static bool vusbDevStdReqSetInterface(PVUSBDEV pDev, int EndPt, PVUSBSETUP pSetup, uint8_t *pbBuf, uint32_t *pcbBuf)
423{
424 if ((pSetup->bmRequestType & VUSB_RECIP_MASK) != VUSB_TO_INTERFACE)
425 {
426 Log(("vusb: error: %s: SET_INTERFACE - invalid request (dir) !!!\n", pDev->pUsbIns->pszName));
427 return false;
428 }
429
430 /*
431 * Check that the device is in a valid state.
432 * (The caller has already checked that it's not being reset.)
433 */
434 const VUSBDEVICESTATE enmState = pDev->enmState;
435 if (enmState != VUSB_DEVICE_STATE_CONFIGURED)
436 {
437 LogFlow(("vusbDevStdReqSetInterface: error: %s: invalid device state %d !!!\n", pDev->pUsbIns->pszName, enmState));
438 return false;
439 }
440
441 /*
442 * Find the interface.
443 */
444 uint8_t iIf = pSetup->wIndex;
445 PVUSBINTERFACESTATE pIfState = vusbDevFindIfState(pDev, iIf);
446 if (!pIfState)
447 {
448 LogFlow(("vusbDevStdReqSetInterface: error: %s: couldn't find interface %u !!!\n", pDev->pUsbIns->pszName, iIf));
449 return false;
450 }
451 uint8_t iAlt = pSetup->wValue;
452 PCVUSBDESCINTERFACEEX pIfDesc = vusbDevFindAltIfDesc(pDev, pIfState, iAlt);
453 if (!pIfDesc)
454 {
455 LogFlow(("vusbDevStdReqSetInterface: error: %s: couldn't find alt interface %u.%u !!!\n", pDev->pUsbIns->pszName, iIf, iAlt));
456 return false;
457 }
458
459 if (pDev->pUsbIns->pReg->pfnUsbSetInterface)
460 {
461 int rc = pDev->pUsbIns->pReg->pfnUsbSetInterface(pDev->pUsbIns, iIf, iAlt);
462 if (RT_FAILURE(rc))
463 {
464 LogFlow(("vusbDevStdReqSetInterface: error: %s: couldn't find alt interface %u.%u (%Rrc)\n", pDev->pUsbIns->pszName, iIf, iAlt, rc));
465 return false;
466 }
467 }
468
469 for (unsigned i = 0; i < pIfState->pCurIfDesc->Core.bNumEndpoints; i++)
470 unmap_endpoint(pDev, &pIfState->pCurIfDesc->paEndpoints[i]);
471
472 Log(("vusb: SET_INTERFACE: Selected %u.%u\n", iIf, iAlt));
473
474 map_interface(pDev, pIfDesc);
475 pIfState->pCurIfDesc = pIfDesc;
476
477 return true;
478}
479
480/**
481 * Standard device request: SET_ADDRESS
482 * @returns success indicator.
483 */
484static bool vusbDevStdReqSetAddress(PVUSBDEV pDev, int EndPt, PVUSBSETUP pSetup, uint8_t *pbBuf, uint32_t *pcbBuf)
485{
486 if ((pSetup->bmRequestType & VUSB_RECIP_MASK) != VUSB_TO_DEVICE)
487 {
488 Log(("vusb: error: %s: SET_ADDRESS - invalid request (dir) !!!\n", pDev->pUsbIns->pszName));
489 return false;
490 }
491
492 /*
493 * Check that the device is in a valid state.
494 * (The caller has already checked that it's not being reset.)
495 */
496 const VUSBDEVICESTATE enmState = pDev->enmState;
497 if ( enmState != VUSB_DEVICE_STATE_DEFAULT
498 && enmState != VUSB_DEVICE_STATE_ADDRESS)
499 {
500 LogFlow(("vusbDevStdReqSetAddress: error: %s: invalid device state %d !!!\n", pDev->pUsbIns->pszName, enmState));
501 return false;
502 }
503
504 pDev->u8NewAddress = pSetup->wValue;
505 return true;
506}
507
508/**
509 * Standard device request: CLEAR_FEATURE
510 * @returns success indicator.
511 *
512 * @remark This is only called for VUSB_TO_ENDPOINT && ep == 0 && wValue == ENDPOINT_HALT.
513 * All other cases of CLEAR_FEATURE is handled in the normal async/sync manner.
514 */
515static bool vusbDevStdReqClearFeature(PVUSBDEV pDev, int EndPt, PVUSBSETUP pSetup, uint8_t *pbBuf, uint32_t *pcbBuf)
516{
517 switch (pSetup->bmRequestType & VUSB_RECIP_MASK)
518 {
519 case VUSB_TO_DEVICE:
520 Log(("vusb: ClearFeature: dev(%u): selector=%u\n", pSetup->wIndex, pSetup->wValue));
521 break;
522 case VUSB_TO_INTERFACE:
523 Log(("vusb: ClearFeature: iface(%u): selector=%u\n", pSetup->wIndex, pSetup->wValue));
524 break;
525 case VUSB_TO_ENDPOINT:
526 Log(("vusb: ClearFeature: ep(%u): selector=%u\n", pSetup->wIndex, pSetup->wValue));
527 if ( !EndPt /* Default control pipe only */
528 && pSetup->wValue == 0 /* ENDPOINT_HALT */
529 && pDev->pUsbIns->pReg->pfnUsbClearHaltedEndpoint)
530 {
531 int rc = pDev->pUsbIns->pReg->pfnUsbClearHaltedEndpoint(pDev->pUsbIns, pSetup->wIndex);
532 return RT_SUCCESS(rc);
533 }
534 break;
535 default:
536 AssertMsgFailed(("VUSB_TO_OTHER!\n"));
537 break;
538 }
539
540 AssertMsgFailed(("Invalid safe check !!!\n"));
541 return false;
542}
543
544/**
545 * Standard device request: SET_FEATURE
546 * @returns success indicator.
547 */
548static bool vusbDevStdReqSetFeature(PVUSBDEV pDev, int EndPt, PVUSBSETUP pSetup, uint8_t *pbBuf, uint32_t *pcbBuf)
549{
550 switch (pSetup->bmRequestType & VUSB_RECIP_MASK)
551 {
552 case VUSB_TO_DEVICE:
553 Log(("vusb: SetFeature: dev(%u): selector=%u\n",
554 pSetup->wIndex, pSetup->wValue));
555 break;
556 case VUSB_TO_INTERFACE:
557 Log(("vusb: SetFeature: if(%u): selector=%u\n",
558 pSetup->wIndex, pSetup->wValue));
559 break;
560 case VUSB_TO_ENDPOINT:
561 Log(("vusb: SetFeature: ep(%u): selector=%u\n",
562 pSetup->wIndex, pSetup->wValue));
563 break;
564 default:
565 AssertMsgFailed(("VUSB_TO_OTHER!\n"));
566 return false;
567 }
568 AssertMsgFailed(("This stuff is bogus\n"));
569 return false;
570}
571
572static bool vusbDevStdReqGetStatus(PVUSBDEV pDev, int EndPt, PVUSBSETUP pSetup, uint8_t *pbBuf, uint32_t *pcbBuf)
573{
574 if (*pcbBuf != 2)
575 {
576 LogFlow(("vusbDevStdReqGetStatus: %s: buffer is too small! (%d)\n", pDev->pUsbIns->pszName, *pcbBuf));
577 return false;
578 }
579
580 uint16_t u16Status;
581 switch (pSetup->bmRequestType & VUSB_RECIP_MASK)
582 {
583 case VUSB_TO_DEVICE:
584 u16Status = pDev->u16Status;
585 LogFlow(("vusbDevStdReqGetStatus: %s: device status %#x (%d)\n", pDev->pUsbIns->pszName, u16Status, u16Status));
586 break;
587 case VUSB_TO_INTERFACE:
588 u16Status = 0;
589 LogFlow(("vusbDevStdReqGetStatus: %s: bogus interface status request!!\n", pDev->pUsbIns->pszName));
590 break;
591 case VUSB_TO_ENDPOINT:
592 u16Status = 0;
593 LogFlow(("vusbDevStdReqGetStatus: %s: bogus endpoint status request!!\n", pDev->pUsbIns->pszName));
594 break;
595 default:
596 AssertMsgFailed(("VUSB_TO_OTHER!\n"));
597 return false;
598 }
599
600 *(uint16_t *)pbBuf = u16Status;
601 return true;
602}
603
604
605/**
606 * Finds a cached string.
607 *
608 * @returns Pointer to the cached string if found. NULL if not.
609 * @param paLanguages The languages to search.
610 * @param cLanguages The number of languages in the table.
611 * @param idLang The language ID.
612 * @param iString The string index.
613 */
614static PCPDMUSBDESCCACHESTRING FindCachedString(PCPDMUSBDESCCACHELANG paLanguages, unsigned cLanguages,
615 uint16_t idLang, uint8_t iString)
616{
617 /** @todo binary lookups! */
618 unsigned iCurLang = cLanguages;
619 while (iCurLang-- > 0)
620 if (paLanguages[iCurLang].idLang == idLang)
621 {
622 PCPDMUSBDESCCACHESTRING paStrings = paLanguages[iCurLang].paStrings;
623 unsigned iCurStr = paLanguages[iCurLang].cStrings;
624 while (iCurStr-- > 0)
625 if (paStrings[iCurStr].idx == iString)
626 return &paStrings[iCurStr];
627 break;
628 }
629 return NULL;
630}
631
632
633/** Macro for copying descriptor data. */
634#define COPY_DATA(pbDst, cbLeft, pvSrc, cbSrc) \
635 do { \
636 uint32_t cbSrc_ = cbSrc; \
637 uint32_t cbCopy = RT_MIN(cbLeft, cbSrc_); \
638 memcpy(pbBuf, pvSrc, cbCopy); \
639 cbLeft -= cbCopy; \
640 if (!cbLeft) \
641 return; \
642 pbBuf += cbCopy; \
643 } while (0)
644
645/**
646 * Internal function for reading the language IDs.
647 */
648static void ReadCachedStringDesc(PCPDMUSBDESCCACHESTRING pString, uint8_t *pbBuf, uint32_t *pcbBuf)
649{
650 uint32_t cbLeft = *pcbBuf;
651
652 RTUTF16 wsz[128]; /* 128-1 => bLength=0xff */
653 PRTUTF16 pwsz = wsz;
654 size_t cwc;
655 int rc = RTStrToUtf16Ex(pString->psz, RT_ELEMENTS(wsz) - 1, &pwsz, RT_ELEMENTS(wsz), &cwc);
656 if (RT_FAILURE(rc))
657 {
658 AssertRC(rc);
659 wsz[0] = 'e';
660 wsz[1] = 'r';
661 wsz[2] = 'r';
662 cwc = 3;
663 }
664
665 VUSBDESCSTRING StringDesc;
666 StringDesc.bLength = sizeof(StringDesc) + cwc * sizeof(RTUTF16);
667 StringDesc.bDescriptorType = VUSB_DT_STRING;
668 COPY_DATA(pbBuf, cbLeft, &StringDesc, sizeof(StringDesc));
669 COPY_DATA(pbBuf, cbLeft, wsz, cwc * sizeof(RTUTF16));
670
671 /* updated the size of the output buffer. */
672 *pcbBuf -= cbLeft;
673}
674
675
676/**
677 * Internal function for reading the language IDs.
678 */
679static void ReadCachedLangIdDesc(PCPDMUSBDESCCACHELANG paLanguages, unsigned cLanguages,
680 uint8_t *pbBuf, uint32_t *pcbBuf)
681{
682 uint32_t cbLeft = *pcbBuf;
683
684 VUSBDESCLANGID LangIdDesc;
685 size_t cbDesc = sizeof(LangIdDesc) + cLanguages * sizeof(paLanguages[0].idLang);
686 LangIdDesc.bLength = RT_MIN(0xff, cbDesc);
687 LangIdDesc.bDescriptorType = VUSB_DT_STRING;
688 COPY_DATA(pbBuf, cbLeft, &LangIdDesc, sizeof(LangIdDesc));
689
690 unsigned iLanguage = cLanguages;
691 while (iLanguage-- > 0)
692 COPY_DATA(pbBuf, cbLeft, &paLanguages[iLanguage].idLang, sizeof(paLanguages[iLanguage].idLang));
693
694 /* updated the size of the output buffer. */
695 *pcbBuf -= cbLeft;
696}
697
698
699/**
700 * Internal function which performs a descriptor read on the cached descriptors.
701 */
702static void ReadCachedConfigDesc(PCVUSBDESCCONFIGEX pCfgDesc, uint8_t *pbBuf, uint32_t *pcbBuf)
703{
704 uint32_t cbLeft = *pcbBuf;
705
706/** @todo See @bugref{2693} */
707 /*
708 * Make a copy of the config descriptor and calculate the wTotalLength field.
709 */
710 VUSBDESCCONFIG CfgDesc;
711 memcpy(&CfgDesc, pCfgDesc, VUSB_DT_CONFIG_MIN_LEN);
712 uint32_t cbTotal = pCfgDesc->Core.bLength;
713 for (unsigned i = 0; i < pCfgDesc->Core.bNumInterfaces; i++)
714 {
715 PCVUSBINTERFACE pIf = &pCfgDesc->paIfs[i];
716 for (uint32_t j = 0; j < pIf->cSettings; j++)
717 {
718 cbTotal += pIf->paSettings[j].cbIAD;
719 cbTotal += pIf->paSettings[j].Core.bLength;
720 cbTotal += pIf->paSettings[j].cbClass;
721 for (unsigned k = 0; k < pIf->paSettings[j].Core.bNumEndpoints; k++)
722 {
723 cbTotal += pIf->paSettings[j].paEndpoints[k].Core.bLength;
724 cbTotal += pIf->paSettings[j].paEndpoints[k].cbClass;
725 }
726 }
727 }
728 CfgDesc.wTotalLength = RT_H2LE_U16(cbTotal);
729
730 /*
731 * Copy the config descriptor
732 */
733 COPY_DATA(pbBuf, cbLeft, &CfgDesc, VUSB_DT_CONFIG_MIN_LEN);
734 COPY_DATA(pbBuf, cbLeft, pCfgDesc->pvMore, pCfgDesc->Core.bLength - VUSB_DT_CONFIG_MIN_LEN);
735
736 /*
737 * Copy out all the interfaces for this configuration
738 */
739 for (unsigned i = 0; i < pCfgDesc->Core.bNumInterfaces; i++)
740 {
741 PCVUSBINTERFACE pIf = &pCfgDesc->paIfs[i];
742 for (uint32_t j = 0; j < pIf->cSettings; j++)
743 {
744 PCVUSBDESCINTERFACEEX pIfDesc = &pIf->paSettings[j];
745
746 COPY_DATA(pbBuf, cbLeft, pIfDesc->pIAD, pIfDesc->cbIAD);
747 COPY_DATA(pbBuf, cbLeft, pIfDesc, VUSB_DT_INTERFACE_MIN_LEN);
748 COPY_DATA(pbBuf, cbLeft, pIfDesc->pvMore, pIfDesc->Core.bLength - VUSB_DT_INTERFACE_MIN_LEN);
749 COPY_DATA(pbBuf, cbLeft, pIfDesc->pvClass, pIfDesc->cbClass);
750
751 /*
752 * Copy out all the endpoints for this interface
753 */
754 for (unsigned k = 0; k < pIfDesc->Core.bNumEndpoints; k++)
755 {
756 VUSBDESCENDPOINT EndPtDesc;
757 memcpy(&EndPtDesc, &pIfDesc->paEndpoints[k], VUSB_DT_ENDPOINT_MIN_LEN);
758 EndPtDesc.wMaxPacketSize = RT_H2LE_U16(EndPtDesc.wMaxPacketSize);
759
760 COPY_DATA(pbBuf, cbLeft, &EndPtDesc, VUSB_DT_ENDPOINT_MIN_LEN);
761 COPY_DATA(pbBuf, cbLeft, pIfDesc->paEndpoints[k].pvMore, EndPtDesc.bLength - VUSB_DT_ENDPOINT_MIN_LEN);
762 COPY_DATA(pbBuf, cbLeft, pIfDesc->paEndpoints[k].pvClass, pIfDesc->paEndpoints[k].cbClass);
763 }
764 }
765 }
766
767 /* updated the size of the output buffer. */
768 *pcbBuf -= cbLeft;
769}
770
771/**
772 * Internal function which performs a descriptor read on the cached descriptors.
773 */
774static void ReadCachedDeviceDesc(PCVUSBDESCDEVICE pDevDesc, uint8_t *pbBuf, uint32_t *pcbBuf)
775{
776 uint32_t cbLeft = *pcbBuf;
777
778 /*
779 * Duplicate the device description and update some fields we keep in cpu type.
780 */
781 Assert(sizeof(VUSBDESCDEVICE) == 18);
782 VUSBDESCDEVICE DevDesc = *pDevDesc;
783 DevDesc.bcdUSB = RT_H2LE_U16(DevDesc.bcdUSB);
784 DevDesc.idVendor = RT_H2LE_U16(DevDesc.idVendor);
785 DevDesc.idProduct = RT_H2LE_U16(DevDesc.idProduct);
786 DevDesc.bcdDevice = RT_H2LE_U16(DevDesc.bcdDevice);
787
788 COPY_DATA(pbBuf, cbLeft, &DevDesc, sizeof(DevDesc));
789 COPY_DATA(pbBuf, cbLeft, pDevDesc + 1, pDevDesc->bLength - sizeof(DevDesc));
790
791 /* updated the size of the output buffer. */
792 *pcbBuf -= cbLeft;
793}
794
795#undef COPY_DATA
796
797/**
798 * Standard device request: GET_DESCRIPTOR
799 * @returns success indicator.
800 * @remark not really used yet as we consider GET_DESCRIPTOR 'safe'.
801 */
802static bool vusbDevStdReqGetDescriptor(PVUSBDEV pDev, int EndPt, PVUSBSETUP pSetup, uint8_t *pbBuf, uint32_t *pcbBuf)
803{
804 if ((pSetup->bmRequestType & VUSB_RECIP_MASK) == VUSB_TO_DEVICE)
805 {
806 switch (pSetup->wValue >> 8)
807 {
808 case VUSB_DT_DEVICE:
809 ReadCachedDeviceDesc(pDev->pDescCache->pDevice, pbBuf, pcbBuf);
810 LogFlow(("vusbDevStdReqGetDescriptor: %s: %u bytes of device descriptors\n", pDev->pUsbIns->pszName, *pcbBuf));
811 return true;
812
813 case VUSB_DT_CONFIG:
814 {
815 unsigned int iIndex = (pSetup->wValue & 0xff);
816 if (iIndex >= pDev->pDescCache->pDevice->bNumConfigurations)
817 {
818 LogFlow(("vusbDevStdReqGetDescriptor: %s: iIndex=%p >= bNumConfigurations=%d !!!\n",
819 pDev->pUsbIns->pszName, iIndex, pDev->pDescCache->pDevice->bNumConfigurations));
820 return false;
821 }
822 ReadCachedConfigDesc(&pDev->pDescCache->paConfigs[iIndex], pbBuf, pcbBuf);
823 LogFlow(("vusbDevStdReqGetDescriptor: %s: %u bytes of config descriptors\n", pDev->pUsbIns->pszName, *pcbBuf));
824 return true;
825 }
826
827 case VUSB_DT_STRING:
828 {
829 if (pSetup->wIndex == 0)
830 {
831 ReadCachedLangIdDesc(pDev->pDescCache->paLanguages, pDev->pDescCache->cLanguages, pbBuf, pcbBuf);
832 LogFlow(("vusbDevStdReqGetDescriptor: %s: %u bytes of language ID (string) descriptors\n", pDev->pUsbIns->pszName, *pcbBuf));
833 return true;
834 }
835 PCPDMUSBDESCCACHESTRING pString;
836 pString = FindCachedString(pDev->pDescCache->paLanguages, pDev->pDescCache->cLanguages,
837 pSetup->wIndex, pSetup->wValue & 0xff);
838 if (pString)
839 {
840 ReadCachedStringDesc(pString, pbBuf, pcbBuf);
841 LogFlow(("vusbDevStdReqGetDescriptor: %s: %u bytes of string descriptors \"%s\"\n",
842 pDev->pUsbIns->pszName, *pcbBuf, pString->psz));
843 return true;
844 }
845 break;
846 }
847
848 default:
849 break;
850 }
851 }
852 Log(("vusb: %s: warning: unknown descriptor: type=%u descidx=%u lang=%u len=%u!!!\n",
853 pDev->pUsbIns->pszName, pSetup->wValue >> 8, pSetup->wValue & 0xff, pSetup->wIndex, pSetup->wLength));
854 return false;
855}
856
857
858/**
859 * Service the standard USB requests.
860 *
861 * Devices may call this from controlmsg() if you want vusb core to handle your standard
862 * request, it's not necessary - you could handle them manually
863 *
864 * @param pDev The device.
865 * @param EndPoint The endpoint.
866 * @param pSetup Pointer to the setup request structure.
867 * @param pvBuf Buffer?
868 * @param pcbBuf ?
869 */
870bool vusbDevStandardRequest(PVUSBDEV pDev, int EndPoint, PVUSBSETUP pSetup, void *pvBuf, uint32_t *pcbBuf)
871{
872 static bool (* const s_apfnStdReq[VUSB_REQ_MAX])(PVUSBDEV, int, PVUSBSETUP, uint8_t *, uint32_t *) =
873 {
874 vusbDevStdReqGetStatus,
875 vusbDevStdReqClearFeature,
876 NULL,
877 vusbDevStdReqSetFeature,
878 NULL,
879 vusbDevStdReqSetAddress,
880 vusbDevStdReqGetDescriptor,
881 NULL,
882 vusbDevStdReqGetConfig,
883 vusbDevStdReqSetConfig,
884 vusbDevStdReqGetInterface,
885 vusbDevStdReqSetInterface,
886 NULL /* for iso */
887 };
888
889 /*
890 * Check that the device is in a valid state.
891 */
892 const VUSBDEVICESTATE enmState = pDev->enmState;
893 VUSBDEV_ASSERT_VALID_STATE(enmState);
894 if (enmState == VUSB_DEVICE_STATE_RESET)
895 {
896 LogRel(("VUSB: %s: standard control message ignored, the device is resetting\n", pDev->pUsbIns->pszName));
897 return false;
898 }
899
900 /*
901 * Do the request if it's one we want to deal with.
902 */
903 if ( pSetup->bRequest >= VUSB_REQ_MAX
904 || !s_apfnStdReq[pSetup->bRequest])
905 {
906 Log(("vusb: warning: standard req not implemented: message %u: val=%u idx=%u len=%u !!!\n",
907 pSetup->bRequest, pSetup->wValue, pSetup->wIndex, pSetup->wLength));
908 return false;
909 }
910
911 return s_apfnStdReq[pSetup->bRequest](pDev, EndPoint, pSetup, (uint8_t *)pvBuf, pcbBuf);
912}
913
914
915/**
916 * Add a device to the address hash
917 */
918static void vusbDevAddressHash(PVUSBDEV pDev)
919{
920 if (pDev->u8Address == VUSB_INVALID_ADDRESS)
921 return;
922 uint8_t u8Hash = vusbHashAddress(pDev->u8Address);
923 pDev->pNextHash = pDev->pHub->pRootHub->apAddrHash[u8Hash];
924 pDev->pHub->pRootHub->apAddrHash[u8Hash] = pDev;
925}
926
927/**
928 * Remove a device from the address hash
929 */
930static void vusbDevAddressUnHash(PVUSBDEV pDev)
931{
932 if (pDev->u8Address == VUSB_INVALID_ADDRESS)
933 return;
934
935 uint8_t u8Hash = vusbHashAddress(pDev->u8Address);
936 pDev->u8Address = VUSB_INVALID_ADDRESS;
937 pDev->u8NewAddress = VUSB_INVALID_ADDRESS;
938
939 PVUSBDEV pCur = pDev->pHub->pRootHub->apAddrHash[u8Hash];
940 if (pCur == pDev)
941 {
942 /* special case, we're at the head */
943 pDev->pHub->pRootHub->apAddrHash[u8Hash] = pDev->pNextHash;
944 pDev->pNextHash = NULL;
945 }
946 else
947 {
948 /* search the list */
949 PVUSBDEV pPrev;
950 for (pPrev = pCur, pCur = pCur->pNextHash;
951 pCur;
952 pPrev = pCur, pCur = pCur->pNextHash)
953 {
954 if (pCur == pDev)
955 {
956 pPrev->pNextHash = pCur->pNextHash;
957 pDev->pNextHash = NULL;
958 break;
959 }
960 }
961 }
962}
963
964/**
965 * Sets the address of a device.
966 *
967 * Called by status_completion() and vusbDevResetWorker().
968 */
969void vusbDevSetAddress(PVUSBDEV pDev, uint8_t u8Address)
970{
971 LogFlow(("vusbDevSetAddress: pDev=%p[%s]/%i u8Address=%#x\n",
972 pDev, pDev->pUsbIns->pszName, pDev->i16Port, u8Address));
973
974 /*
975 * Check that the device is in a valid state.
976 */
977 const VUSBDEVICESTATE enmState = pDev->enmState;
978 VUSBDEV_ASSERT_VALID_STATE(enmState);
979 if ( enmState == VUSB_DEVICE_STATE_ATTACHED
980 || enmState == VUSB_DEVICE_STATE_DETACHED)
981 {
982 LogFlow(("vusbDevSetAddress: %s: fails because %d < POWERED\n", pDev->pUsbIns->pszName, pDev->enmState));
983 return;
984 }
985 if (enmState == VUSB_DEVICE_STATE_RESET)
986 {
987 LogRel(("VUSB: %s: set address ignored, the device is resetting\n", pDev->pUsbIns->pszName));
988 return;
989 }
990
991 /*
992 * Ok, get on with it.
993 */
994 if (pDev->u8Address == u8Address)
995 return;
996
997 PVUSBROOTHUB pRh = vusbDevGetRh(pDev);
998 AssertPtrReturnVoid(pRh);
999 if (pDev->u8Address == VUSB_DEFAULT_ADDRESS)
1000 pRh->pDefaultAddress = NULL;
1001
1002 vusbDevAddressUnHash(pDev);
1003
1004 if (u8Address == VUSB_DEFAULT_ADDRESS)
1005 {
1006 if (pRh->pDefaultAddress != NULL)
1007 {
1008 vusbDevAddressUnHash(pRh->pDefaultAddress);
1009 pRh->pDefaultAddress->enmState = VUSB_DEVICE_STATE_POWERED;
1010 Log(("2 DEFAULT ADDRS\n"));
1011 }
1012
1013 pRh->pDefaultAddress = pDev;
1014 pDev->enmState = VUSB_DEVICE_STATE_DEFAULT;
1015 }
1016 else
1017 pDev->enmState = VUSB_DEVICE_STATE_ADDRESS;
1018
1019 pDev->u8Address = u8Address;
1020 vusbDevAddressHash(pDev);
1021
1022 Log(("vusb: %p[%s]/%i: Assigned address %u\n",
1023 pDev, pDev->pUsbIns->pszName, pDev->i16Port, u8Address));
1024}
1025
1026
1027/**
1028 * Cancels and completes (with CRC failure) all async URBs pending
1029 * on a device. This is typically done as part of a reset and
1030 * before detaching a device.
1031 *
1032 * @param fDetaching If set, we will unconditionally unlink (and leak)
1033 * any URBs which isn't reaped.
1034 */
1035static void vusbDevCancelAllUrbs(PVUSBDEV pDev, bool fDetaching)
1036{
1037 PVUSBROOTHUB pRh = vusbDevGetRh(pDev);
1038 AssertPtrReturnVoid(pRh);
1039
1040 /*
1041 * Iterate the URBs and cancel them.
1042 */
1043 PVUSBURB pUrb = pRh->pAsyncUrbHead;
1044 while (pUrb)
1045 {
1046 PVUSBURB pNext = pUrb->VUsb.pNext;
1047 if (pUrb->VUsb.pDev == pDev)
1048 {
1049 LogFlow(("%s: vusbDevCancelAllUrbs: CANCELING URB\n", pUrb->pszDesc));
1050 vusbUrbCancel(pUrb, CANCELMODE_FAIL);
1051 }
1052 pUrb = pNext;
1053 }
1054
1055 /*
1056 * Reap any URBs which became ripe during cancel now.
1057 */
1058 unsigned cReaped;
1059 do
1060 {
1061 cReaped = 0;
1062 pUrb = pRh->pAsyncUrbHead;
1063 while (pUrb)
1064 {
1065 PVUSBURB pNext = pUrb->VUsb.pNext;
1066 if (pUrb->VUsb.pDev == pDev)
1067 {
1068 PVUSBURB pRipe = NULL;
1069 if (pUrb->enmState == VUSBURBSTATE_REAPED)
1070 pRipe = pUrb;
1071 else if (pUrb->enmState == VUSBURBSTATE_CANCELLED)
1072#ifdef RT_OS_WINDOWS /** @todo Windows doesn't do cancelling, thus this kludge to prevent really bad
1073 * things from happening if we leave a pending URB behinds. */
1074 pRipe = pDev->pUsbIns->pReg->pfnUrbReap(pDev->pUsbIns, fDetaching ? 1500 : 0 /*ms*/);
1075#else
1076 pRipe = pDev->pUsbIns->pReg->pfnUrbReap(pDev->pUsbIns, fDetaching ? 10 : 0 /*ms*/);
1077#endif
1078 else
1079 AssertMsgFailed(("pUrb=%p enmState=%d\n", pUrb, pUrb->enmState));
1080 if (pRipe)
1081 {
1082 if (pRipe == pNext)
1083 pNext = pNext->VUsb.pNext;
1084 vusbUrbRipe(pRipe);
1085 cReaped++;
1086 }
1087 }
1088 pUrb = pNext;
1089 }
1090 } while (cReaped > 0);
1091
1092 /*
1093 * If we're detaching, we'll have to orphan any leftover URBs.
1094 */
1095 if (fDetaching)
1096 {
1097 pUrb = pRh->pAsyncUrbHead;
1098 while (pUrb)
1099 {
1100 PVUSBURB pNext = pUrb->VUsb.pNext;
1101 if (pUrb->VUsb.pDev == pDev)
1102 {
1103 AssertMsgFailed(("%s: Leaking left over URB! state=%d pDev=%p[%s]\n",
1104 pUrb->pszDesc, pUrb->enmState, pDev, pDev->pUsbIns->pszName));
1105 vusbUrbUnlink(pUrb);
1106 /* Unlink isn't enough, because boundary timer and detaching will try to reap it.
1107 * It was tested with MSD & iphone attachment to vSMP guest, if
1108 * it breaks anything, please add comment here, why we should unlink only.
1109 */
1110 pUrb->VUsb.pfnFree(pUrb);
1111 }
1112 pUrb = pNext;
1113 }
1114 }
1115}
1116
1117
1118static DECLCALLBACK(int) vusbDevUrbIoThread(RTTHREAD hThread, void *pvUser)
1119{
1120 PVUSBDEV pDev = (PVUSBDEV)pvUser;
1121
1122 /* Notify the starter that we are up and running. */
1123 RTThreadUserSignal(hThread);
1124
1125 LogFlowFunc(("Entering work loop\n"));
1126
1127 while (!ASMAtomicReadBool(&pDev->fTerminate))
1128 {
1129 if (pDev->enmState != VUSB_DEVICE_STATE_RESET)
1130 vusbUrbDoReapAsyncDev(pDev, RT_INDEFINITE_WAIT);
1131
1132 /* Woken up or there is an URB to queue. */
1133 PRTQUEUEATOMICITEM pHead = RTQueueAtomicRemoveAll(&pDev->QueueUrb);
1134 while (pHead)
1135 {
1136 PVUSBURB pUrb = RT_FROM_MEMBER(pHead, VUSBURB, Dev.QueueItem);
1137
1138 pHead = pHead->pNext;
1139
1140 LogFlow(("%s: Queuing URB\n", pUrb->pszDesc));
1141 int rc = pUrb->pUsbIns->pReg->pfnUrbQueue(pUrb->pUsbIns, pUrb);
1142 if (RT_FAILURE(rc))
1143 {
1144 LogFlow(("%s: Queuing URB failed with %Rrc\n", pUrb->pszDesc, rc));
1145
1146 /*
1147 * The device was detached, so we fail everything.
1148 * (We should really detach and destroy the device, but we'll have to wait till Main reacts.)
1149 */
1150 if (rc == VERR_VUSB_DEVICE_NOT_ATTACHED)
1151 rc = vusbUrbSubmitHardError(pUrb);
1152
1153 /*
1154 * We don't increment error count if async URBs are in flight, in
1155 * this case we just assume we need to throttle back, this also
1156 * makes sure we don't halt bulk endpoints at the wrong time.
1157 */
1158 else if ( RT_FAILURE(rc)
1159 && !pDev->aPipes[pUrb->EndPt].async
1160 /* && pUrb->enmType == VUSBXFERTYPE_BULK ?? */
1161 && !vusbUrbErrorRh(pUrb))
1162 {
1163 /* don't retry it anymore. */
1164 pUrb->enmState = VUSBURBSTATE_REAPED;
1165 pUrb->enmStatus = VUSBSTATUS_CRC;
1166 vusbUrbCompletionRh(pUrb);
1167 }
1168 }
1169 }
1170 }
1171
1172 return VINF_SUCCESS;
1173}
1174
1175int vusbDevUrbIoThreadWakeup(PVUSBDEV pDev)
1176{
1177 ASMAtomicXchgBool(&pDev->fWokenUp, true);
1178 return pDev->pUsbIns->pReg->pfnWakeup(pDev->pUsbIns);
1179}
1180
1181/**
1182 * Create the URB I/O thread.
1183 *
1184 * @returns VBox status code.
1185 * @param pDev The VUSB device.
1186 */
1187int vusbDevUrbIoThreadCreate(PVUSBDEV pDev)
1188{
1189 int rc = VINF_SUCCESS;
1190
1191 ASMAtomicXchgBool(&pDev->fTerminate, false);
1192 rc = RTThreadCreateF(&pDev->hUrbIoThread, vusbDevUrbIoThread, pDev, 0, RTTHREADTYPE_IO,
1193 RTTHREADFLAGS_WAITABLE, "USBDevIo-%d", pDev->i16Port);
1194 if (RT_SUCCESS(rc))
1195 {
1196 /* Wait for it to become active. */
1197 rc = RTThreadUserWait(pDev->hUrbIoThread, RT_INDEFINITE_WAIT);
1198 }
1199
1200 return rc;
1201}
1202
1203/**
1204 * Destro the URB I/O thread.
1205 *
1206 * @returns VBox status code.
1207 * @param pDev The VUSB device.
1208 */
1209int vusbDevUrbIoThreadDestroy(PVUSBDEV pDev)
1210{
1211 int rc = VINF_SUCCESS;
1212 int rcThread = VINF_SUCCESS;
1213
1214 ASMAtomicXchgBool(&pDev->fTerminate, true);
1215 vusbDevUrbIoThreadWakeup(pDev);
1216
1217 rc = RTThreadWait(pDev->hUrbIoThread, RT_INDEFINITE_WAIT, &rcThread);
1218 if (RT_SUCCESS(rc))
1219 rc = rcThread;
1220
1221 return rc;
1222}
1223
1224
1225/**
1226 * Detaches a device from the hub it's attached to.
1227 *
1228 * @returns VBox status code.
1229 * @param pDev The device to detach.
1230 *
1231 * @remark This can be called in any state but reset.
1232 */
1233int vusbDevDetach(PVUSBDEV pDev)
1234{
1235 LogFlow(("vusbDevDetach: pDev=%p[%s] enmState=%#x\n", pDev, pDev->pUsbIns->pszName, pDev->enmState));
1236 VUSBDEV_ASSERT_VALID_STATE(pDev->enmState);
1237 Assert(pDev->enmState != VUSB_DEVICE_STATE_RESET);
1238
1239 vusbDevCancelAllUrbs(pDev, true);
1240 vusbDevAddressUnHash(pDev);
1241
1242 PVUSBROOTHUB pRh = vusbDevGetRh(pDev);
1243 if (!pRh)
1244 AssertMsgFailedReturn(("Not attached!\n"), VERR_VUSB_DEVICE_NOT_ATTACHED);
1245 if (pRh->pDefaultAddress == pDev)
1246 pRh->pDefaultAddress = NULL;
1247
1248 pDev->pHub->pOps->pfnDetach(pDev->pHub, pDev);
1249 pDev->i16Port = -1;
1250 pDev->enmState = VUSB_DEVICE_STATE_DETACHED;
1251 pDev->pHub = NULL;
1252
1253 /* Remove the configuration */
1254 pDev->pCurCfgDesc = NULL;
1255 for (unsigned i = 0; i < VUSB_PIPE_MAX; i++)
1256 vusbMsgFreeExtraData(pDev->aPipes[i].pCtrl);
1257 memset(pDev->aPipes, 0, sizeof(pDev->aPipes));
1258 return VINF_SUCCESS;
1259}
1260
1261
1262/**
1263 * Destroys a device, detaching it from the hub if necessary.
1264 *
1265 * @param pDev The device.
1266 * @thread EMT
1267 */
1268void vusbDevDestroy(PVUSBDEV pDev)
1269{
1270 LogFlow(("vusbDevDestroy: pDev=%p[%s] enmState=%d\n", pDev, pDev->pUsbIns->pszName, pDev->enmState));
1271
1272 /*
1273 * Deal with pending async reset.
1274 */
1275 if (pDev->enmState == VUSB_DEVICE_STATE_RESET)
1276 {
1277 Assert(pDev->pvResetArgs && pDev->hResetThread != NIL_RTTHREAD);
1278 int rc = RTThreadWait(pDev->hResetThread, 5000, NULL);
1279 AssertRC(rc);
1280 if (RT_SUCCESS(rc))
1281 {
1282 PVUSBRESETARGS pArgs = (PVUSBRESETARGS)pDev->pvResetArgs;
1283 Assert(pArgs->pDev == pDev);
1284 RTMemTmpFree(pArgs);
1285
1286 pDev->hResetThread = NIL_RTTHREAD;
1287 pDev->pvResetArgs = NULL;
1288 pDev->enmState = VUSB_DEVICE_STATE_DEFAULT; /* anything but reset */
1289 }
1290 }
1291
1292 /* Destroy I/O thread. */
1293 vusbDevUrbIoThreadDestroy(pDev);
1294
1295 /*
1296 * Detach and free resources.
1297 */
1298 if (pDev->pHub)
1299 vusbDevDetach(pDev);
1300 RTMemFree(pDev->paIfStates);
1301 pDev->enmState = VUSB_DEVICE_STATE_DESTROYED;
1302 TMR3TimerDestroy(pDev->pResetTimer);
1303}
1304
1305
1306/* -=-=-=-=-=- VUSBIDEVICE methods -=-=-=-=-=- */
1307
1308
1309/**
1310 * Perform the actual reset.
1311 *
1312 * @thread EMT or a VUSB reset thread.
1313 */
1314static int vusbDevResetWorker(PVUSBDEV pDev, bool fResetOnLinux)
1315{
1316 int rc = VINF_SUCCESS;
1317
1318 if (pDev->pUsbIns->pReg->pfnUsbReset)
1319 rc = pDev->pUsbIns->pReg->pfnUsbReset(pDev->pUsbIns, fResetOnLinux);
1320
1321 LogFlow(("vusbDevResetWorker: %s: returns %Rrc\n", pDev->pUsbIns->pszName, rc));
1322 return rc;
1323}
1324
1325
1326/**
1327 * The actual reset has been done, do completion on EMT.
1328 *
1329 * There are several things we have to do now, like set default
1330 * config and address, and cleanup the state of control pipes.
1331 *
1332 * It's possible that the device has a delayed destroy request
1333 * pending when we get here. This can happen for async resetting.
1334 * We deal with it here, since we're now executing on the EMT
1335 * thread and the destruction will be properly serialized now.
1336 *
1337 * @param pDev The device that is being reset.
1338 * @param rc The vusbDevResetWorker return code.
1339 * @param pfnDone The done callback specified by the caller of vusbDevReset().
1340 * @param pvUser The user argument for the callback.
1341 */
1342static void vusbDevResetDone(PVUSBDEV pDev, int rc, PFNVUSBRESETDONE pfnDone, void *pvUser)
1343{
1344 VUSBDEV_ASSERT_VALID_STATE(pDev->enmState);
1345 Assert(pDev->enmState == VUSB_DEVICE_STATE_RESET);
1346
1347 /*
1348 * Do control pipe cleanup regardless of state and result.
1349 */
1350 for (unsigned i = 0; i < VUSB_PIPE_MAX; i++)
1351 if (pDev->aPipes[i].pCtrl)
1352 vusbMsgResetExtraData(pDev->aPipes[i].pCtrl);
1353
1354 /*
1355 * Switch to the default state.
1356 */
1357 pDev->enmState = VUSB_DEVICE_STATE_DEFAULT;
1358 pDev->u16Status = 0;
1359 vusbDevDoSelectConfig(pDev, &g_Config0);
1360 if (!vusbDevIsRh(pDev))
1361 vusbDevSetAddress(pDev, VUSB_DEFAULT_ADDRESS);
1362 if (pfnDone)
1363 pfnDone(&pDev->IDevice, rc, pvUser);
1364}
1365
1366
1367/**
1368 * Timer callback for doing reset completion.
1369 *
1370 * @param pUsbIns The USB device instance.
1371 * @param pTimer The timer instance.
1372 * @param pvUser The VUSB device data.
1373 * @thread EMT
1374 */
1375static DECLCALLBACK(void) vusbDevResetDoneTimer(PPDMUSBINS pUsbIns, PTMTIMER pTimer, void *pvUser)
1376{
1377 PVUSBDEV pDev = (PVUSBDEV)pvUser;
1378 PVUSBRESETARGS pArgs = (PVUSBRESETARGS)pDev->pvResetArgs;
1379 AssertPtr(pArgs); Assert(pArgs->pDev == pDev); Assert(pDev->pUsbIns == pUsbIns);
1380
1381 /*
1382 * Release the thread and update the device structure.
1383 */
1384 int rc = RTThreadWait(pDev->hResetThread, 2, NULL);
1385 AssertRC(rc);
1386 pDev->hResetThread = NIL_RTTHREAD;
1387 pDev->pvResetArgs = NULL;
1388
1389 /*
1390 * Reset-done processing and cleanup.
1391 */
1392 vusbDevResetDone(pArgs->pDev, pArgs->rc, pArgs->pfnDone, pArgs->pvUser);
1393
1394 RTMemTmpFree(pArgs);
1395}
1396
1397
1398/**
1399 * Thread function for performing an async reset.
1400 *
1401 * This will pass the argument packet back to EMT upon completion
1402 * by means of a one shot timer.
1403 *
1404 * @returns whatever vusbDevResetWorker() returns.
1405 * @param Thread This thread.
1406 * @param pvUser Pointer to a VUSBRESETARGS structure.
1407 */
1408static DECLCALLBACK(int) vusbDevResetThread(RTTHREAD Thread, void *pvUser)
1409{
1410 PVUSBRESETARGS pArgs = (PVUSBRESETARGS)pvUser;
1411 PVUSBDEV pDev = pArgs->pDev;
1412 LogFlow(("vusb: reset thread started\n"));
1413
1414 /*
1415 * Tell EMT that we're in flow and then perform the reset.
1416 */
1417 uint64_t u64EndTS = TMTimerGet(pDev->pResetTimer) + TMTimerFromMilli(pDev->pResetTimer, 10);
1418 RTThreadUserSignal(Thread);
1419
1420 int rc = pArgs->rc = vusbDevResetWorker(pDev, pArgs->fResetOnLinux);
1421
1422 /*
1423 * We use a timer to communicate the result back to EMT.
1424 * This avoids suspend + poweroff issues, and it should give
1425 * us more accurate scheduling than making this thread sleep.
1426 */
1427 int rc2 = TMTimerSet(pDev->pResetTimer, u64EndTS);
1428 AssertReleaseRC(rc2);
1429
1430 LogFlow(("vusb: reset thread exiting, rc=%Rrc\n", rc));
1431 return rc;
1432}
1433
1434
1435/**
1436 * Resets a device.
1437 *
1438 * Since a device reset shall take at least 10ms from the guest point of view,
1439 * it must be performed asynchronously. We create a thread which performs this
1440 * operation and ensures it will take at least 10ms.
1441 *
1442 * At times - like init - a synchronous reset is required, this can be done
1443 * by passing NULL for pfnDone.
1444 *
1445 * While the device is being reset it is in the VUSB_DEVICE_STATE_RESET state.
1446 * On completion it will be in the VUSB_DEVICE_STATE_DEFAULT state if successful,
1447 * or in the VUSB_DEVICE_STATE_DETACHED state if the rest failed.
1448 *
1449 * @returns VBox status code.
1450 *
1451 * @param pDev Pointer to the VUSB device interface.
1452 * @param fResetOnLinux Whether it's safe to reset the device(s) on a linux
1453 * host system. See discussion of logical reconnects elsewhere.
1454 * @param pfnDone Pointer to the completion routine. If NULL a synchronous
1455 * reset is preformed not respecting the 10ms.
1456 * @param pVM Pointer to the VM handle for performing the done function
1457 * on the EMT thread.
1458 * @thread EMT
1459 */
1460DECLCALLBACK(int) vusbDevReset(PVUSBIDEVICE pDevice, bool fResetOnLinux, PFNVUSBRESETDONE pfnDone, void *pvUser, PVM pVM)
1461{
1462 PVUSBDEV pDev = (PVUSBDEV)pDevice;
1463 Assert(!pfnDone || pVM);
1464 LogFlow(("vusb: reset: [%s]/%i\n", pDev->pUsbIns->pszName, pDev->i16Port));
1465
1466 /*
1467 * Only one reset operation at a time.
1468 */
1469 const VUSBDEVICESTATE enmState = pDev->enmState;
1470 VUSBDEV_ASSERT_VALID_STATE(enmState);
1471 if (enmState == VUSB_DEVICE_STATE_RESET)
1472 {
1473 LogRel(("VUSB: %s: reset request is ignored, the device is already resetting!\n", pDev->pUsbIns->pszName));
1474 return VERR_VUSB_DEVICE_IS_RESETTING;
1475 }
1476 pDev->enmState = VUSB_DEVICE_STATE_RESET;
1477
1478 /*
1479 * First, cancel all async URBs.
1480 */
1481 vusbDevCancelAllUrbs(pDev, false);
1482
1483 /* Async or sync? */
1484 if (pfnDone)
1485 {
1486 /*
1487 * Async fashion.
1488 */
1489 PVUSBRESETARGS pArgs = (PVUSBRESETARGS)RTMemTmpAlloc(sizeof(*pArgs));
1490 if (pArgs)
1491 {
1492 pDev->pvResetArgs = pArgs;
1493 pArgs->pDev = pDev;
1494 pArgs->fResetOnLinux = fResetOnLinux;
1495 pArgs->rc = VERR_INTERNAL_ERROR;
1496 pArgs->pfnDone = pfnDone;
1497 pArgs->pvUser = pvUser;
1498 int rc = RTThreadCreate(&pDev->hResetThread, vusbDevResetThread, pArgs, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "USBRESET");
1499 if (RT_SUCCESS(rc))
1500 {
1501 /* give the thread a chance to get started. */
1502 RTThreadUserWait(pDev->hResetThread, 2);
1503 return rc;
1504 }
1505
1506 pDev->pvResetArgs = NULL;
1507 pDev->hResetThread = NIL_RTTHREAD;
1508 RTMemTmpFree(pArgs);
1509 }
1510 /* fall back to sync on failure */
1511 }
1512
1513 /*
1514 * Sync fashion.
1515 */
1516 int rc = vusbDevResetWorker(pDev, fResetOnLinux);
1517 vusbDevResetDone(pDev, rc, pfnDone, pvUser);
1518 return rc;
1519}
1520
1521
1522/**
1523 * Powers on the device.
1524 *
1525 * @returns VBox status code.
1526 * @param pInterface Pointer to the device interface structure.
1527 */
1528DECLCALLBACK(int) vusbDevPowerOn(PVUSBIDEVICE pInterface)
1529{
1530 PVUSBDEV pDev = (PVUSBDEV)pInterface;
1531 LogFlow(("vusbDevPowerOn: pDev=%p[%s]\n", pDev, pDev->pUsbIns->pszName));
1532
1533 /*
1534 * Check that the device is in a valid state.
1535 */
1536 const VUSBDEVICESTATE enmState = pDev->enmState;
1537 VUSBDEV_ASSERT_VALID_STATE(enmState);
1538 if (enmState == VUSB_DEVICE_STATE_DETACHED)
1539 {
1540 Log(("vusb: warning: attempt to power on detached device %p[%s]\n", pDev, pDev->pUsbIns->pszName));
1541 return VERR_VUSB_DEVICE_NOT_ATTACHED;
1542 }
1543 if (enmState == VUSB_DEVICE_STATE_RESET)
1544 {
1545 LogRel(("VUSB: %s: power on ignored, the device is resetting!\n", pDev->pUsbIns->pszName));
1546 return VERR_VUSB_DEVICE_IS_RESETTING;
1547 }
1548
1549 /*
1550 * Do the job.
1551 */
1552 if (enmState == VUSB_DEVICE_STATE_ATTACHED)
1553 pDev->enmState = VUSB_DEVICE_STATE_POWERED;
1554
1555 return VINF_SUCCESS;
1556}
1557
1558
1559/**
1560 * Powers off the device.
1561 *
1562 * @returns VBox status code.
1563 * @param pInterface Pointer to the device interface structure.
1564 */
1565DECLCALLBACK(int) vusbDevPowerOff(PVUSBIDEVICE pInterface)
1566{
1567 PVUSBDEV pDev = (PVUSBDEV)pInterface;
1568 LogFlow(("vusbDevPowerOff: pDev=%p[%s]\n", pDev, pDev->pUsbIns->pszName));
1569
1570 /*
1571 * Check that the device is in a valid state.
1572 */
1573 const VUSBDEVICESTATE enmState = pDev->enmState;
1574 VUSBDEV_ASSERT_VALID_STATE(enmState);
1575 if (enmState == VUSB_DEVICE_STATE_DETACHED)
1576 {
1577 Log(("vusb: warning: attempt to power off detached device %p[%s]\n", pDev, pDev->pUsbIns->pszName));
1578 return VERR_VUSB_DEVICE_NOT_ATTACHED;
1579 }
1580 if (enmState == VUSB_DEVICE_STATE_RESET)
1581 {
1582 LogRel(("VUSB: %s: power off ignored, the device is resetting!\n", pDev->pUsbIns->pszName));
1583 return VERR_VUSB_DEVICE_IS_RESETTING;
1584 }
1585
1586 /*
1587 * If it's a root hub, we will have to cancel all URBs and reap them.
1588 */
1589 if (vusbDevIsRh(pDev))
1590 {
1591 PVUSBROOTHUB pRh = (PVUSBROOTHUB)pDev;
1592 VUSBIRhCancelAllUrbs(&pRh->IRhConnector);
1593 VUSBIRhReapAsyncUrbs(&pRh->IRhConnector, 0);
1594 }
1595
1596 pDev->enmState = VUSB_DEVICE_STATE_ATTACHED;
1597
1598 return VINF_SUCCESS;
1599}
1600
1601
1602/**
1603 * Get the state of the device.
1604 *
1605 * @returns Device state.
1606 * @param pInterface Pointer to the device interface structure.
1607 */
1608DECLCALLBACK(VUSBDEVICESTATE) vusbDevGetState(PVUSBIDEVICE pInterface)
1609{
1610 return ((PVUSBDEV)pInterface)->enmState;
1611}
1612
1613
1614/**
1615 * @interface_method_impl{VUSBIDEVICE,pfnIsEmulated}
1616 */
1617DECLCALLBACK(bool) vusbDevIsEmulated(PVUSBIDEVICE pInterface)
1618{
1619 PVUSBDEV pDev = (PVUSBDEV)pInterface;
1620 bool fEmulated = !!(pDev->pUsbIns->pReg->fFlags & PDM_USBREG_EMULATED_DEVICE);
1621
1622 LogFlowFunc(("pInterface=%p\n", pInterface));
1623
1624 LogFlowFunc(("returns %RTbool\n", fEmulated));
1625 return fEmulated;
1626}
1627
1628
1629/**
1630 * The maximum number of interfaces the device can have in all of it's configuration.
1631 *
1632 * @returns Number of interfaces.
1633 * @param pDev The device.
1634 */
1635size_t vusbDevMaxInterfaces(PVUSBDEV pDev)
1636{
1637 uint8_t cMax = 0;
1638 unsigned i = pDev->pDescCache->pDevice->bNumConfigurations;
1639 while (i-- > 0)
1640 {
1641 if (pDev->pDescCache->paConfigs[i].Core.bNumInterfaces > cMax)
1642 cMax = pDev->pDescCache->paConfigs[i].Core.bNumInterfaces;
1643 }
1644
1645 return cMax;
1646}
1647
1648
1649/**
1650 * Initialize a new VUSB device.
1651 *
1652 * @returns VBox status code.
1653 * @param pDev The VUSB device to initialize.
1654 * @param pUsbIns Pointer to the PDM USB Device instance.
1655 */
1656int vusbDevInit(PVUSBDEV pDev, PPDMUSBINS pUsbIns)
1657{
1658 /*
1659 * Initialize the device data members.
1660 * (All that are Non-Zero at least.)
1661 */
1662 Assert(!pDev->IDevice.pfnReset);
1663 pDev->IDevice.pfnReset = vusbDevReset;
1664 Assert(!pDev->IDevice.pfnPowerOn);
1665 pDev->IDevice.pfnPowerOn = vusbDevPowerOn;
1666 Assert(!pDev->IDevice.pfnPowerOff);
1667 pDev->IDevice.pfnPowerOff = vusbDevPowerOff;
1668 Assert(!pDev->IDevice.pfnGetState);
1669 pDev->IDevice.pfnGetState = vusbDevGetState;
1670 Assert(!pDev->IDevice.pfnIsEmulated);
1671 pDev->IDevice.pfnIsEmulated = vusbDevIsEmulated;
1672 pDev->pUsbIns = pUsbIns;
1673 pDev->pNext = NULL;
1674 pDev->pNextHash = NULL;
1675 pDev->pHub = NULL;
1676 pDev->enmState = VUSB_DEVICE_STATE_DETACHED;
1677 pDev->u8Address = VUSB_INVALID_ADDRESS;
1678 pDev->u8NewAddress = VUSB_INVALID_ADDRESS;
1679 pDev->i16Port = -1;
1680 pDev->u16Status = 0;
1681 pDev->pDescCache = NULL;
1682 pDev->pCurCfgDesc = NULL;
1683 pDev->paIfStates = NULL;
1684 memset(&pDev->aPipes[0], 0, sizeof(pDev->aPipes));
1685 pDev->hResetThread = NIL_RTTHREAD;
1686 pDev->pvResetArgs = NULL;
1687 pDev->pResetTimer = NULL;
1688 RTQueueAtomicInit(&pDev->QueueUrb);
1689
1690 /*
1691 * Create the reset timer.
1692 */
1693 int rc = PDMUsbHlpTMTimerCreate(pUsbIns, TMCLOCK_VIRTUAL, vusbDevResetDoneTimer, pDev, 0 /*fFlags*/,
1694 "USB Device Reset Timer", &pDev->pResetTimer);
1695 AssertRCReturn(rc, rc);
1696
1697 /*
1698 * Get the descriptor cache from the device. (shall cannot fail)
1699 */
1700 pDev->pDescCache = pUsbIns->pReg->pfnUsbGetDescriptorCache(pUsbIns);
1701 Assert(pDev->pDescCache);
1702#ifdef VBOX_STRICT
1703 if (pDev->pDescCache->fUseCachedStringsDescriptors)
1704 {
1705 int32_t iPrevId = -1;
1706 for (unsigned iLang = 0; iLang < pDev->pDescCache->cLanguages; iLang++)
1707 {
1708 Assert((int32_t)pDev->pDescCache->paLanguages[iLang].idLang > iPrevId);
1709 iPrevId = pDev->pDescCache->paLanguages[iLang].idLang;
1710
1711 int32_t idxPrevStr = -1;
1712 PCPDMUSBDESCCACHESTRING paStrings = pDev->pDescCache->paLanguages[iLang].paStrings;
1713 unsigned cStrings = pDev->pDescCache->paLanguages[iLang].cStrings;
1714 for (unsigned iStr = 0; iStr < cStrings; iStr++)
1715 {
1716 Assert((int32_t)paStrings[iStr].idx > idxPrevStr);
1717 idxPrevStr = paStrings[iStr].idx;
1718 size_t cch = strlen(paStrings[iStr].psz);
1719 Assert(cch <= 127);
1720 }
1721 }
1722 }
1723#endif
1724
1725 /*
1726 * Allocate memory for the interface states.
1727 */
1728 size_t cbIface = vusbDevMaxInterfaces(pDev) * sizeof(*pDev->paIfStates);
1729 pDev->paIfStates = (PVUSBINTERFACESTATE)RTMemAllocZ(cbIface);
1730 AssertMsgReturn(pDev->paIfStates, ("RTMemAllocZ(%d) failed\n", cbIface), VERR_NO_MEMORY);
1731
1732 rc = vusbDevUrbIoThreadCreate(pDev);
1733 AssertRCReturn(rc, rc);
1734
1735 return VINF_SUCCESS;
1736}
1737
1738/*
1739 * Local Variables:
1740 * mode: c
1741 * c-file-style: "bsd"
1742 * c-basic-offset: 4
1743 * tab-width: 4
1744 * indent-tabs-mode: s
1745 * End:
1746 */
1747
Note: See TracBrowser for help on using the repository browser.

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