VirtualBox

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

Last change on this file since 83298 was 82968, checked in by vboxsync, 5 years ago

Copyright year updates by scm.

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