VirtualBox

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

Last change on this file since 49498 was 49117, checked in by vboxsync, 11 years ago

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