VirtualBox

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

Last change on this file since 45761 was 45755, checked in by vboxsync, 12 years ago

VBox/USB: fix in common USB code for device detachment.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 52.3 KB
Line 
1/* $Id: VUSBDevice.cpp 45755 2013-04-26 04:04:44Z 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 if (pDev->u8Address == VUSB_DEFAULT_ADDRESS)
999 pRh->pDefaultAddress = NULL;
1000
1001 vusbDevAddressUnHash(pDev);
1002
1003 if (u8Address == VUSB_DEFAULT_ADDRESS)
1004 {
1005 if (pRh->pDefaultAddress != NULL)
1006 {
1007 vusbDevAddressUnHash(pRh->pDefaultAddress);
1008 pRh->pDefaultAddress->enmState = VUSB_DEVICE_STATE_POWERED;
1009 Log(("2 DEFAULT ADDRS\n"));
1010 }
1011
1012 pRh->pDefaultAddress = pDev;
1013 pDev->enmState = VUSB_DEVICE_STATE_DEFAULT;
1014 }
1015 else
1016 pDev->enmState = VUSB_DEVICE_STATE_ADDRESS;
1017
1018 pDev->u8Address = u8Address;
1019 vusbDevAddressHash(pDev);
1020
1021 Log(("vusb: %p[%s]/%i: Assigned address %u\n",
1022 pDev, pDev->pUsbIns->pszName, pDev->i16Port, u8Address));
1023}
1024
1025
1026/**
1027 * Cancels and completes (with CRC failure) all async URBs pending
1028 * on a device. This is typically done as part of a reset and
1029 * before detaching a device.
1030 *
1031 * @param fDetaching If set, we will unconditionally unlink (and leak)
1032 * any URBs which isn't reaped.
1033 */
1034static void vusbDevCancelAllUrbs(PVUSBDEV pDev, bool fDetaching)
1035{
1036 PVUSBROOTHUB pRh = vusbDevGetRh(pDev);
1037
1038 /*
1039 * Iterate the URBs and cancel them.
1040 */
1041 PVUSBURB pUrb = pRh->pAsyncUrbHead;
1042 while (pUrb)
1043 {
1044 PVUSBURB pNext = pUrb->VUsb.pNext;
1045 if (pUrb->VUsb.pDev == pDev)
1046 {
1047 LogFlow(("%s: vusbDevCancelAllUrbs: CANCELING URB\n", pUrb->pszDesc));
1048 vusbUrbCancel(pUrb, CANCELMODE_FAIL);
1049 }
1050 pUrb = pNext;
1051 }
1052
1053 /*
1054 * Reap any URBs which became ripe during cancel now.
1055 */
1056 unsigned cReaped;
1057 do
1058 {
1059 cReaped = 0;
1060 pUrb = pRh->pAsyncUrbHead;
1061 while (pUrb)
1062 {
1063 PVUSBURB pNext = pUrb->VUsb.pNext;
1064 if (pUrb->VUsb.pDev == pDev)
1065 {
1066 PVUSBURB pRipe = NULL;
1067 if (pUrb->enmState == VUSBURBSTATE_REAPED)
1068 pRipe = pUrb;
1069 else if (pUrb->enmState == VUSBURBSTATE_CANCELLED)
1070#ifdef RT_OS_WINDOWS /** @todo Windows doesn't do cancelling, thus this kludge to prevent really bad
1071 * things from happening if we leave a pending URB behinds. */
1072 pRipe = pDev->pUsbIns->pReg->pfnUrbReap(pDev->pUsbIns, fDetaching ? 1500 : 0 /*ms*/);
1073#else
1074 pRipe = pDev->pUsbIns->pReg->pfnUrbReap(pDev->pUsbIns, fDetaching ? 10 : 0 /*ms*/);
1075#endif
1076 else
1077 AssertMsgFailed(("pUrb=%p enmState=%d\n", pUrb, pUrb->enmState));
1078 if (pRipe)
1079 {
1080 if (pRipe == pNext)
1081 pNext = pNext->VUsb.pNext;
1082 vusbUrbRipe(pRipe);
1083 cReaped++;
1084 }
1085 }
1086 pUrb = pNext;
1087 }
1088 } while (cReaped > 0);
1089
1090 /*
1091 * If we're detaching, we'll have to orphan any leftover URBs.
1092 */
1093 if (fDetaching)
1094 {
1095 pUrb = pRh->pAsyncUrbHead;
1096 while (pUrb)
1097 {
1098 PVUSBURB pNext = pUrb->VUsb.pNext;
1099 if (pUrb->VUsb.pDev == pDev)
1100 {
1101 AssertMsgFailed(("%s: Leaking left over URB! state=%d pDev=%p[%s]\n",
1102 pUrb->pszDesc, pUrb->enmState, pDev, pDev->pUsbIns->pszName));
1103 vusbUrbUnlink(pUrb);
1104 /* Unlink isn't enough, because boundary timer and detaching will try to reap it.
1105 * It was tested with MSD & iphone attachment to vSMP guest, if
1106 * it breaks anything, please add comment here, why we should unlink only.
1107 */
1108 pUrb->VUsb.pfnFree(pUrb);
1109 }
1110 pUrb = pNext;
1111 }
1112 }
1113}
1114
1115
1116/**
1117 * Detaches a device from the hub it's attached to.
1118 *
1119 * @returns VBox status code.
1120 * @param pDev The device to detach.
1121 *
1122 * @remark This can be called in any state but reset.
1123 */
1124int vusbDevDetach(PVUSBDEV pDev)
1125{
1126 LogFlow(("vusbDevDetach: pDev=%p[%s] enmState=%#x\n", pDev, pDev->pUsbIns->pszName, pDev->enmState));
1127 VUSBDEV_ASSERT_VALID_STATE(pDev->enmState);
1128 Assert(pDev->enmState != VUSB_DEVICE_STATE_RESET);
1129
1130 vusbDevCancelAllUrbs(pDev, true);
1131 vusbDevAddressUnHash(pDev);
1132
1133 PVUSBROOTHUB pRh = vusbDevGetRh(pDev);
1134 if (!pRh)
1135 AssertMsgFailedReturn(("Not attached!\n"), VERR_VUSB_DEVICE_NOT_ATTACHED);
1136 if (pRh->pDefaultAddress == pDev)
1137 pRh->pDefaultAddress = NULL;
1138
1139 pDev->pHub->pOps->pfnDetach(pDev->pHub, pDev);
1140 pDev->i16Port = -1;
1141 pDev->enmState = VUSB_DEVICE_STATE_DETACHED;
1142 pDev->pHub = NULL;
1143
1144 /* Remove the configuration */
1145 pDev->pCurCfgDesc = NULL;
1146 for (unsigned i = 0; i < VUSB_PIPE_MAX; i++)
1147 vusbMsgFreeExtraData(pDev->aPipes[i].pCtrl);
1148 memset(pDev->aPipes, 0, sizeof(pDev->aPipes));
1149 return VINF_SUCCESS;
1150}
1151
1152
1153/**
1154 * Destroys a device, detaching it from the hub if necessary.
1155 *
1156 * @param pDev The device.
1157 * @thread EMT
1158 */
1159void vusbDevDestroy(PVUSBDEV pDev)
1160{
1161 LogFlow(("vusbDevDestroy: pDev=%p[%s] enmState=%d\n", pDev, pDev->pUsbIns->pszName, pDev->enmState));
1162
1163 /*
1164 * Deal with pending async reset.
1165 */
1166 if (pDev->enmState == VUSB_DEVICE_STATE_RESET)
1167 {
1168 Assert(pDev->pvResetArgs && pDev->hResetThread != NIL_RTTHREAD);
1169 int rc = RTThreadWait(pDev->hResetThread, 5000, NULL);
1170 AssertRC(rc);
1171 if (RT_SUCCESS(rc))
1172 {
1173 PVUSBRESETARGS pArgs = (PVUSBRESETARGS)pDev->pvResetArgs;
1174 Assert(pArgs->pDev == pDev);
1175 RTMemTmpFree(pArgs);
1176
1177 pDev->hResetThread = NIL_RTTHREAD;
1178 pDev->pvResetArgs = NULL;
1179 pDev->enmState = VUSB_DEVICE_STATE_DEFAULT; /* anything but reset */
1180 }
1181 }
1182
1183 /*
1184 * Detach and free resources.
1185 */
1186 if (pDev->pHub)
1187 vusbDevDetach(pDev);
1188 RTMemFree(pDev->paIfStates);
1189 pDev->enmState = VUSB_DEVICE_STATE_DESTROYED;
1190 TMR3TimerDestroy(pDev->pResetTimer);
1191}
1192
1193
1194/* -=-=-=-=-=- VUSBIDEVICE methods -=-=-=-=-=- */
1195
1196
1197/**
1198 * Perform the actual reset.
1199 *
1200 * @thread EMT or a VUSB reset thread.
1201 */
1202static int vusbDevResetWorker(PVUSBDEV pDev, bool fResetOnLinux)
1203{
1204 int rc = VINF_SUCCESS;
1205
1206 if (pDev->pUsbIns->pReg->pfnUsbReset)
1207 rc = pDev->pUsbIns->pReg->pfnUsbReset(pDev->pUsbIns, fResetOnLinux);
1208
1209 LogFlow(("vusbDevResetWorker: %s: returns %Rrc\n", pDev->pUsbIns->pszName, rc));
1210 return rc;
1211}
1212
1213
1214/**
1215 * The actual reset has been done, do completion on EMT.
1216 *
1217 * There are several things we have to do now, like set default
1218 * config and address, and cleanup the state of control pipes.
1219 *
1220 * It's possible that the device has a delayed destroy request
1221 * pending when we get here. This can happen for async resetting.
1222 * We deal with it here, since we're now executing on the EMT
1223 * thread and the destruction will be properly serialized now.
1224 *
1225 * @param pDev The device that is being reset.
1226 * @param rc The vusbDevResetWorker return code.
1227 * @param pfnDone The done callback specified by the caller of vusbDevReset().
1228 * @param pvUser The user argument for the callback.
1229 */
1230static void vusbDevResetDone(PVUSBDEV pDev, int rc, PFNVUSBRESETDONE pfnDone, void *pvUser)
1231{
1232 VUSBDEV_ASSERT_VALID_STATE(pDev->enmState);
1233 Assert(pDev->enmState == VUSB_DEVICE_STATE_RESET);
1234
1235 /*
1236 * Do control pipe cleanup regardless of state and result.
1237 */
1238 for (unsigned i = 0; i < VUSB_PIPE_MAX; i++)
1239 if (pDev->aPipes[i].pCtrl)
1240 vusbMsgResetExtraData(pDev->aPipes[i].pCtrl);
1241
1242 /*
1243 * Switch to the default state.
1244 */
1245 pDev->enmState = VUSB_DEVICE_STATE_DEFAULT;
1246 pDev->u16Status = 0;
1247 vusbDevDoSelectConfig(pDev, &g_Config0);
1248 if (!vusbDevIsRh(pDev))
1249 vusbDevSetAddress(pDev, VUSB_DEFAULT_ADDRESS);
1250 if (pfnDone)
1251 pfnDone(&pDev->IDevice, rc, pvUser);
1252}
1253
1254
1255/**
1256 * Timer callback for doing reset completion.
1257 *
1258 * @param pUsbIns The USB device instance.
1259 * @param pTimer The timer instance.
1260 * @param pvUser The VUSB device data.
1261 * @thread EMT
1262 */
1263static DECLCALLBACK(void) vusbDevResetDoneTimer(PPDMUSBINS pUsbIns, PTMTIMER pTimer, void *pvUser)
1264{
1265 PVUSBDEV pDev = (PVUSBDEV)pvUser;
1266 PVUSBRESETARGS pArgs = (PVUSBRESETARGS)pDev->pvResetArgs;
1267 AssertPtr(pArgs); Assert(pArgs->pDev == pDev); Assert(pDev->pUsbIns == pUsbIns);
1268
1269 /*
1270 * Release the thread and update the device structure.
1271 */
1272 int rc = RTThreadWait(pDev->hResetThread, 2, NULL);
1273 AssertRC(rc);
1274 pDev->hResetThread = NIL_RTTHREAD;
1275 pDev->pvResetArgs = NULL;
1276
1277 /*
1278 * Reset-done processing and cleanup.
1279 */
1280 vusbDevResetDone(pArgs->pDev, pArgs->rc, pArgs->pfnDone, pArgs->pvUser);
1281
1282 RTMemTmpFree(pArgs);
1283}
1284
1285
1286/**
1287 * Thread function for performing an async reset.
1288 *
1289 * This will pass the argument packet back to EMT upon completion
1290 * by means of a one shot timer.
1291 *
1292 * @returns whatever vusbDevResetWorker() returns.
1293 * @param Thread This thread.
1294 * @param pvUser Pointer to a VUSBRESETARGS structure.
1295 */
1296static DECLCALLBACK(int) vusbDevResetThread(RTTHREAD Thread, void *pvUser)
1297{
1298 PVUSBRESETARGS pArgs = (PVUSBRESETARGS)pvUser;
1299 PVUSBDEV pDev = pArgs->pDev;
1300 LogFlow(("vusb: reset thread started\n"));
1301
1302 /*
1303 * Tell EMT that we're in flow and then perform the reset.
1304 */
1305 uint64_t u64EndTS = TMTimerGet(pDev->pResetTimer) + TMTimerFromMilli(pDev->pResetTimer, 10);
1306 RTThreadUserSignal(Thread);
1307
1308 int rc = pArgs->rc = vusbDevResetWorker(pDev, pArgs->fResetOnLinux);
1309
1310 /*
1311 * We use a timer to communicate the result back to EMT.
1312 * This avoids suspend + poweroff issues, and it should give
1313 * us more accurate scheduling than making this thread sleep.
1314 */
1315 int rc2 = TMTimerSet(pDev->pResetTimer, u64EndTS);
1316 AssertReleaseRC(rc2);
1317
1318 LogFlow(("vusb: reset thread exiting, rc=%Rrc\n", rc));
1319 return rc;
1320}
1321
1322
1323/**
1324 * Resets a device.
1325 *
1326 * Since a device reset shall take at least 10ms from the guest point of view,
1327 * it must be performed asynchronously. We create a thread which performs this
1328 * operation and ensures it will take at least 10ms.
1329 *
1330 * At times - like init - a synchronous reset is required, this can be done
1331 * by passing NULL for pfnDone.
1332 *
1333 * While the device is being reset it is in the VUSB_DEVICE_STATE_RESET state.
1334 * On completion it will be in the VUSB_DEVICE_STATE_DEFAULT state if successful,
1335 * or in the VUSB_DEVICE_STATE_DETACHED state if the rest failed.
1336 *
1337 * @returns VBox status code.
1338 *
1339 * @param pDev Pointer to the VUSB device interface.
1340 * @param fResetOnLinux Whether it's safe to reset the device(s) on a linux
1341 * host system. See discussion of logical reconnects elsewhere.
1342 * @param pfnDone Pointer to the completion routine. If NULL a synchronous
1343 * reset is preformed not respecting the 10ms.
1344 * @param pVM Pointer to the VM handle for performing the done function
1345 * on the EMT thread.
1346 * @thread EMT
1347 */
1348DECLCALLBACK(int) vusbDevReset(PVUSBIDEVICE pDevice, bool fResetOnLinux, PFNVUSBRESETDONE pfnDone, void *pvUser, PVM pVM)
1349{
1350 PVUSBDEV pDev = (PVUSBDEV)pDevice;
1351 Assert(!pfnDone || pVM);
1352 LogFlow(("vusb: reset: [%s]/%i\n", pDev->pUsbIns->pszName, pDev->i16Port));
1353
1354 /*
1355 * Only one reset operation at a time.
1356 */
1357 const VUSBDEVICESTATE enmState = pDev->enmState;
1358 VUSBDEV_ASSERT_VALID_STATE(enmState);
1359 if (enmState == VUSB_DEVICE_STATE_RESET)
1360 {
1361 LogRel(("VUSB: %s: reset request is ignored, the device is already resetting!\n", pDev->pUsbIns->pszName));
1362 return VERR_VUSB_DEVICE_IS_RESETTING;
1363 }
1364 pDev->enmState = VUSB_DEVICE_STATE_RESET;
1365
1366 /*
1367 * First, cancel all async URBs.
1368 */
1369 vusbDevCancelAllUrbs(pDev, false);
1370
1371 /* Async or sync? */
1372 if (pfnDone)
1373 {
1374 /*
1375 * Async fashion.
1376 */
1377 PVUSBRESETARGS pArgs = (PVUSBRESETARGS)RTMemTmpAlloc(sizeof(*pArgs));
1378 if (pArgs)
1379 {
1380 pDev->pvResetArgs = pArgs;
1381 pArgs->pDev = pDev;
1382 pArgs->fResetOnLinux = fResetOnLinux;
1383 pArgs->rc = VERR_INTERNAL_ERROR;
1384 pArgs->pfnDone = pfnDone;
1385 pArgs->pvUser = pvUser;
1386 int rc = RTThreadCreate(&pDev->hResetThread, vusbDevResetThread, pArgs, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "USBRESET");
1387 if (RT_SUCCESS(rc))
1388 {
1389 /* give the thread a chance to get started. */
1390 RTThreadUserWait(pDev->hResetThread, 2);
1391 return rc;
1392 }
1393
1394 pDev->pvResetArgs = NULL;
1395 pDev->hResetThread = NIL_RTTHREAD;
1396 RTMemTmpFree(pArgs);
1397 }
1398 /* fall back to sync on failure */
1399 }
1400
1401 /*
1402 * Sync fashion.
1403 */
1404 int rc = vusbDevResetWorker(pDev, fResetOnLinux);
1405 vusbDevResetDone(pDev, rc, pfnDone, pvUser);
1406 return rc;
1407}
1408
1409
1410/**
1411 * Powers on the device.
1412 *
1413 * @returns VBox status code.
1414 * @param pInterface Pointer to the device interface structure.
1415 */
1416DECLCALLBACK(int) vusbDevPowerOn(PVUSBIDEVICE pInterface)
1417{
1418 PVUSBDEV pDev = (PVUSBDEV)pInterface;
1419 LogFlow(("vusbDevPowerOn: pDev=%p[%s]\n", pDev, pDev->pUsbIns->pszName));
1420
1421 /*
1422 * Check that the device is in a valid state.
1423 */
1424 const VUSBDEVICESTATE enmState = pDev->enmState;
1425 VUSBDEV_ASSERT_VALID_STATE(enmState);
1426 if (enmState == VUSB_DEVICE_STATE_DETACHED)
1427 {
1428 Log(("vusb: warning: attempt to power on detached device %p[%s]\n", pDev, pDev->pUsbIns->pszName));
1429 return VERR_VUSB_DEVICE_NOT_ATTACHED;
1430 }
1431 if (enmState == VUSB_DEVICE_STATE_RESET)
1432 {
1433 LogRel(("VUSB: %s: power on ignored, the device is resetting!\n", pDev->pUsbIns->pszName));
1434 return VERR_VUSB_DEVICE_IS_RESETTING;
1435 }
1436
1437 /*
1438 * Do the job.
1439 */
1440 if (enmState == VUSB_DEVICE_STATE_ATTACHED)
1441 pDev->enmState = VUSB_DEVICE_STATE_POWERED;
1442
1443 return VINF_SUCCESS;
1444}
1445
1446
1447/**
1448 * Powers off the device.
1449 *
1450 * @returns VBox status code.
1451 * @param pInterface Pointer to the device interface structure.
1452 */
1453DECLCALLBACK(int) vusbDevPowerOff(PVUSBIDEVICE pInterface)
1454{
1455 PVUSBDEV pDev = (PVUSBDEV)pInterface;
1456 LogFlow(("vusbDevPowerOff: pDev=%p[%s]\n", pDev, pDev->pUsbIns->pszName));
1457
1458 /*
1459 * Check that the device is in a valid state.
1460 */
1461 const VUSBDEVICESTATE enmState = pDev->enmState;
1462 VUSBDEV_ASSERT_VALID_STATE(enmState);
1463 if (enmState == VUSB_DEVICE_STATE_DETACHED)
1464 {
1465 Log(("vusb: warning: attempt to power off detached device %p[%s]\n", pDev, pDev->pUsbIns->pszName));
1466 return VERR_VUSB_DEVICE_NOT_ATTACHED;
1467 }
1468 if (enmState == VUSB_DEVICE_STATE_RESET)
1469 {
1470 LogRel(("VUSB: %s: power off ignored, the device is resetting!\n", pDev->pUsbIns->pszName));
1471 return VERR_VUSB_DEVICE_IS_RESETTING;
1472 }
1473
1474 /*
1475 * If it's a root hub, we will have to cancel all URBs and reap them.
1476 */
1477 if (vusbDevIsRh(pDev))
1478 {
1479 PVUSBROOTHUB pRh = (PVUSBROOTHUB)pDev;
1480 VUSBIRhCancelAllUrbs(&pRh->IRhConnector);
1481 VUSBIRhReapAsyncUrbs(&pRh->IRhConnector, 0);
1482 }
1483
1484 pDev->enmState = VUSB_DEVICE_STATE_ATTACHED;
1485
1486 return VINF_SUCCESS;
1487}
1488
1489
1490/**
1491 * Get the state of the device.
1492 *
1493 * @returns Device state.
1494 * @param pInterface Pointer to the device interface structure.
1495 */
1496DECLCALLBACK(VUSBDEVICESTATE) vusbDevGetState(PVUSBIDEVICE pInterface)
1497{
1498 return ((PVUSBDEV)pInterface)->enmState;
1499}
1500
1501
1502/**
1503 * The maximum number of interfaces the device can have in all of it's configuration.
1504 *
1505 * @returns Number of interfaces.
1506 * @param pDev The device.
1507 */
1508size_t vusbDevMaxInterfaces(PVUSBDEV pDev)
1509{
1510 uint8_t cMax = 0;
1511 unsigned i = pDev->pDescCache->pDevice->bNumConfigurations;
1512 while (i-- > 0)
1513 {
1514 if (pDev->pDescCache->paConfigs[i].Core.bNumInterfaces > cMax)
1515 cMax = pDev->pDescCache->paConfigs[i].Core.bNumInterfaces;
1516 }
1517
1518 return cMax;
1519}
1520
1521
1522/**
1523 * Initialize a new VUSB device.
1524 *
1525 * @returns VBox status code.
1526 * @param pDev The VUSB device to initialize.
1527 * @param pUsbIns Pointer to the PDM USB Device instance.
1528 */
1529int vusbDevInit(PVUSBDEV pDev, PPDMUSBINS pUsbIns)
1530{
1531 /*
1532 * Initialize the device data members.
1533 * (All that are Non-Zero at least.)
1534 */
1535 Assert(!pDev->IDevice.pfnReset);
1536 pDev->IDevice.pfnReset = vusbDevReset;
1537 Assert(!pDev->IDevice.pfnPowerOn);
1538 pDev->IDevice.pfnPowerOn = vusbDevPowerOn;
1539 Assert(!pDev->IDevice.pfnPowerOff);
1540 pDev->IDevice.pfnPowerOff = vusbDevPowerOff;
1541 Assert(!pDev->IDevice.pfnGetState);
1542 pDev->IDevice.pfnGetState = vusbDevGetState;
1543 pDev->pUsbIns = pUsbIns;
1544 pDev->pNext = NULL;
1545 pDev->pNextHash = NULL;
1546 pDev->pHub = NULL;
1547 pDev->enmState = VUSB_DEVICE_STATE_DETACHED;
1548 pDev->u8Address = VUSB_INVALID_ADDRESS;
1549 pDev->u8NewAddress = VUSB_INVALID_ADDRESS;
1550 pDev->i16Port = -1;
1551 pDev->u16Status = 0;
1552 pDev->pDescCache = NULL;
1553 pDev->pCurCfgDesc = NULL;
1554 pDev->paIfStates = NULL;
1555 memset(&pDev->aPipes[0], 0, sizeof(pDev->aPipes));
1556 pDev->hResetThread = NIL_RTTHREAD;
1557 pDev->pvResetArgs = NULL;
1558 pDev->pResetTimer = NULL;
1559
1560 /*
1561 * Create the reset timer.
1562 */
1563 int rc = PDMUsbHlpTMTimerCreate(pUsbIns, TMCLOCK_VIRTUAL, vusbDevResetDoneTimer, pDev, 0 /*fFlags*/,
1564 "USB Device Reset Timer", &pDev->pResetTimer);
1565 AssertRCReturn(rc, rc);
1566
1567 /*
1568 * Get the descriptor cache from the device. (shall cannot fail)
1569 */
1570 pDev->pDescCache = pUsbIns->pReg->pfnUsbGetDescriptorCache(pUsbIns);
1571 Assert(pDev->pDescCache);
1572#ifdef VBOX_STRICT
1573 if (pDev->pDescCache->fUseCachedStringsDescriptors)
1574 {
1575 int32_t iPrevId = -1;
1576 for (unsigned iLang = 0; iLang < pDev->pDescCache->cLanguages; iLang++)
1577 {
1578 Assert((int32_t)pDev->pDescCache->paLanguages[iLang].idLang > iPrevId);
1579 iPrevId = pDev->pDescCache->paLanguages[iLang].idLang;
1580
1581 int32_t idxPrevStr = -1;
1582 PCPDMUSBDESCCACHESTRING paStrings = pDev->pDescCache->paLanguages[iLang].paStrings;
1583 unsigned cStrings = pDev->pDescCache->paLanguages[iLang].cStrings;
1584 for (unsigned iStr = 0; iStr < cStrings; iStr++)
1585 {
1586 Assert((int32_t)paStrings[iStr].idx > idxPrevStr);
1587 idxPrevStr = paStrings[iStr].idx;
1588 size_t cch = strlen(paStrings[iStr].psz);
1589 Assert(cch <= 127);
1590 }
1591 }
1592 }
1593#endif
1594
1595 /*
1596 * Allocate memory for the interface states.
1597 */
1598 size_t cbIface = vusbDevMaxInterfaces(pDev) * sizeof(*pDev->paIfStates);
1599 pDev->paIfStates = (PVUSBINTERFACESTATE)RTMemAllocZ(cbIface);
1600 AssertMsgReturn(pDev->paIfStates, ("RTMemAllocZ(%d) failed\n", cbIface), VERR_NO_MEMORY);
1601
1602 return VINF_SUCCESS;
1603}
1604
1605/*
1606 * Local Variables:
1607 * mode: c
1608 * c-file-style: "bsd"
1609 * c-basic-offset: 4
1610 * tab-width: 4
1611 * indent-tabs-mode: s
1612 * End:
1613 */
1614
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