VUSBDevice.cpp@ 52379

Last change on this file since 52379 was 52301, checked in by vboxsync, 10 years ago
USB: Move the URB cancellation work to the per device I/O thread, fix a deadlock
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 56.7 KB

Line
1	/* $Id: VUSBDevice.cpp 52301 2014-08-06 17:12:53Z 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	*/
48	typedef struct vusb_reset_args
49	{
50	/** Pointer to the device which is being reset. */
51	PVUSBDEV pDev;
52	/** The reset return code. */
53	int rc;
54	/** Pointer to the completion callback. */
55	PFNVUSBRESETDONE pfnDone;
56	/** User argument to pfnDone. */
57	void *pvUser;
58	} VUSBRESETARGS, *PVUSBRESETARGS;
59
60
61	/*******************************************************************************
62	* Global Variables *
63	*******************************************************************************/
64	/** Default message pipe. */
65	const VUSBDESCENDPOINTEX g_Endpoint0 =
66	{
67	{
68	/* .bLength = */ VUSB_DT_ENDPOINT_MIN_LEN,
69	/* .bDescriptorType = */ VUSB_DT_ENDPOINT,
70	/* .bEndpointAddress = */ 0,
71	/* .bmAttributes = */ 0,
72	/* .wMaxPacketSize = */ 64,
73	/* .bInterval = */ 0
74	},
75	NULL
76	};
77
78	/** Default configuration. */
79	const VUSBDESCCONFIGEX g_Config0 =
80	{
81	{
82	/* .bLength = */ VUSB_DT_CONFIG_MIN_LEN,
83	/* .bDescriptorType = */ VUSB_DT_CONFIG,
84	/* .WTotalLength = / 0, / (auto-calculated) */
85	/* .bNumInterfaces = */ 0,
86	/* .bConfigurationValue =*/ 0,
87	/* .iConfiguration = */ 0,
88	/* .bmAttributes = */ 0x80,
89	/* .MaxPower = */ 14
90	},
91	NULL,
92	NULL
93	};
94
95
96
97	static PCVUSBDESCCONFIGEX vusbDevFindCfgDesc(PVUSBDEV pDev, int iCfg)
98	{
99	if (iCfg == 0)
100	return &g_Config0;
101
102	for (unsigned i = 0; i < pDev->pDescCache->pDevice->bNumConfigurations; i++)
103	if (pDev->pDescCache->paConfigs[i].Core.bConfigurationValue == iCfg)
104	return &pDev->pDescCache->paConfigs[i];
105	return NULL;
106	}
107
108	static PVUSBINTERFACESTATE vusbDevFindIfState(PVUSBDEV pDev, int iIf)
109	{
110	for (unsigned i = 0; i < pDev->pCurCfgDesc->Core.bNumInterfaces; i++)
111	if (pDev->paIfStates[i].pIf->paSettings[0].Core.bInterfaceNumber == iIf)
112	return &pDev->paIfStates[i];
113	return NULL;
114	}
115
116	static PCVUSBDESCINTERFACEEX vusbDevFindAltIfDesc(PVUSBDEV pDev, PCVUSBINTERFACESTATE pIfState, int iAlt)
117	{
118	for (uint32_t i = 0; i < pIfState->pIf->cSettings; i++)
119	if (pIfState->pIf->paSettings[i].Core.bAlternateSetting == iAlt)
120	return &pIfState->pIf->paSettings[i];
121	return NULL;
122	}
123
124	void vusbDevMapEndpoint(PVUSBDEV pDev, PCVUSBDESCENDPOINTEX pEndPtDesc)
125	{
126	uint8_t i8Addr = pEndPtDesc->Core.bEndpointAddress & 0xF;
127	PVUSBPIPE pPipe = &pDev->aPipes[i8Addr];
128	LogFlow(("vusbDevMapEndpoint: pDev=%p[%s] pEndPtDesc=%p{.bEndpointAddress=%#x, .bmAttributes=%#x} p=%p stage %s->SETUP\n",
129	pDev, pDev->pUsbIns->pszName, pEndPtDesc, pEndPtDesc->Core.bEndpointAddress, pEndPtDesc->Core.bmAttributes,
130	pPipe, g_apszCtlStates[pPipe->pCtrl ? pPipe->pCtrl->enmStage : 3]));
131
132	if ((pEndPtDesc->Core.bmAttributes & 0x3) == 0)
133	{
134	Log(("vusb: map message pipe on address %u\n", i8Addr));
135	pPipe->in = pEndPtDesc;
136	pPipe->out = pEndPtDesc;
137	}
138	else if (pEndPtDesc->Core.bEndpointAddress & 0x80)
139	{
140	Log(("vusb: map input pipe on address %u\n", i8Addr));
141	pPipe->in = pEndPtDesc;
142
143	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_SOLARIS) \|\| defined(RT_OS_DARWIN)
144	/*
145	* For high-speed isochronous input endpoints, spin off a read-ahead buffering thread.
146	*/
147	if ((pEndPtDesc->Core.bmAttributes & 0x03) == 1)
148	pPipe->hReadAhead = vusbReadAheadStart(pDev, pPipe);
149	#endif
150	}
151	else
152	{
153	Log(("vusb: map output pipe on address %u\n", i8Addr));
154	pPipe->out = pEndPtDesc;
155	}
156
157	if (pPipe->pCtrl)
158	{
159	vusbMsgFreeExtraData(pPipe->pCtrl);
160	pPipe->pCtrl = NULL;
161	}
162	}
163
164	static void unmap_endpoint(PVUSBDEV pDev, PCVUSBDESCENDPOINTEX pEndPtDesc)
165	{
166	uint8_t EndPt = pEndPtDesc->Core.bEndpointAddress & 0xF;
167	PVUSBPIPE pPipe = &pDev->aPipes[EndPt];
168	LogFlow(("unmap_endpoint: pDev=%p[%s] pEndPtDesc=%p{.bEndpointAddress=%#x, .bmAttributes=%#x} p=%p stage %s->SETUP\n",
169	pDev, pDev->pUsbIns->pszName, pEndPtDesc, pEndPtDesc->Core.bEndpointAddress, pEndPtDesc->Core.bmAttributes,
170	pPipe, g_apszCtlStates[pPipe->pCtrl ? pPipe->pCtrl->enmStage : 3]));
171
172	if ((pEndPtDesc->Core.bmAttributes & 0x3) == 0)
173	{
174	Log(("vusb: unmap MSG pipe from address %u (%#x)\n", EndPt, pEndPtDesc->Core.bEndpointAddress));
175	pPipe->in = NULL;
176	pPipe->out = NULL;
177	}
178	else if (pEndPtDesc->Core.bEndpointAddress & 0x80)
179	{
180	Log(("vusb: unmap IN pipe from address %u (%#x)\n", EndPt, pEndPtDesc->Core.bEndpointAddress));
181	pPipe->in = NULL;
182
183	/* If there was a read-ahead thread associated with this endpoint, tell it to go away. */
184	if (pPipe->hReadAhead)
185	{
186	Log(("vusb: and tell read-ahead thread for the endpoint to terminate\n"));
187	vusbReadAheadStop(pPipe->hReadAhead);
188	pPipe->hReadAhead = NULL;
189	}
190	}
191	else
192	{
193	Log(("vusb: unmap OUT pipe from address %u (%#x)\n", EndPt, pEndPtDesc->Core.bEndpointAddress));
194	pPipe->out = NULL;
195	}
196
197	if (pPipe->pCtrl)
198	{
199	vusbMsgFreeExtraData(pPipe->pCtrl);
200	pPipe->pCtrl = NULL;
201	}
202	}
203
204	static void map_interface(PVUSBDEV pDev, PCVUSBDESCINTERFACEEX pIfDesc)
205	{
206	LogFlow(("map_interface: pDev=%p[%s] pIfDesc=%p:{.iInterface=%d, .bAlternateSetting=%d}\n",
207	pDev, pDev->pUsbIns->pszName, pIfDesc, pIfDesc->Core.iInterface, pIfDesc->Core.bAlternateSetting));
208
209	for (unsigned i = 0; i < pIfDesc->Core.bNumEndpoints; i++)
210	{
211	if ((pIfDesc->paEndpoints[i].Core.bEndpointAddress & 0xF) == VUSB_PIPE_DEFAULT)
212	Log(("vusb: Endpoint 0x%x on interface %u.%u tried to override the default message pipe!!!\n",
213	pIfDesc->paEndpoints[i].Core.bEndpointAddress, pIfDesc->Core.bInterfaceNumber, pIfDesc->Core.bAlternateSetting));
214	else
215	vusbDevMapEndpoint(pDev, &pIfDesc->paEndpoints[i]);
216	}
217	}
218
219	bool vusbDevDoSelectConfig(PVUSBDEV pDev, PCVUSBDESCCONFIGEX pCfgDesc)
220	{
221	LogFlow(("vusbDevDoSelectConfig: pDev=%p[%s] pCfgDesc=%p:{.iConfiguration=%d}\n",
222	pDev, pDev->pUsbIns->pszName, pCfgDesc, pCfgDesc->Core.iConfiguration));
223
224	/*
225	* Clean up all pipes and interfaces.
226	*/
227	unsigned i;
228	for (i = 0; i < VUSB_PIPE_MAX; i++)
229	{
230	if (i != VUSB_PIPE_DEFAULT)
231	{
232	vusbMsgFreeExtraData(pDev->aPipes[i].pCtrl);
233	memset(&pDev->aPipes[i], 0, sizeof(pDev->aPipes[i]));
234	}
235	}
236	memset(pDev->paIfStates, 0, pCfgDesc->Core.bNumInterfaces * sizeof(pDev->paIfStates[0]));
237
238	/*
239	* Map in the default setting for every interface.
240	*/
241	for (i = 0; i < pCfgDesc->Core.bNumInterfaces; i++)
242	{
243	PCVUSBINTERFACE pIf;
244	struct vusb_interface_state *pIfState;
245
246	pIf = &pCfgDesc->paIfs[i];
247	pIfState = &pDev->paIfStates[i];
248	pIfState->pIf = pIf;
249
250	/*
251	* Find the 0 setting, if it is not present we just use
252	* the lowest numbered one.
253	*/
254	for (uint32_t j = 0; j < pIf->cSettings; j++)
255	{
256	if ( !pIfState->pCurIfDesc
257	\|\| pIf->paSettings[j].Core.bAlternateSetting < pIfState->pCurIfDesc->Core.bAlternateSetting)
258	pIfState->pCurIfDesc = &pIf->paSettings[j];
259	if (pIfState->pCurIfDesc->Core.bAlternateSetting == 0)
260	break;
261	}
262
263	if (pIfState->pCurIfDesc)
264	map_interface(pDev, pIfState->pCurIfDesc);
265	}
266
267	pDev->pCurCfgDesc = pCfgDesc;
268
269	if (pCfgDesc->Core.bmAttributes & 0x40)
270	pDev->u16Status \|= (1 << VUSB_DEV_SELF_POWERED);
271	else
272	pDev->u16Status &= ~(1 << VUSB_DEV_SELF_POWERED);
273
274	return true;
275	}
276
277	/**
278	* Standard device request: SET_CONFIGURATION
279	* @returns success indicator.
280	*/
281	static bool vusbDevStdReqSetConfig(PVUSBDEV pDev, int EndPt, PVUSBSETUP pSetup, uint8_t pbBuf, uint32_t pcbBuf)
282	{
283	unsigned iCfg = pSetup->wValue & 0xff;
284
285	if ((pSetup->bmRequestType & VUSB_RECIP_MASK) != VUSB_TO_DEVICE)
286	{
287	Log(("vusb: error: %s: SET_CONFIGURATION - invalid request (dir) !!!\n", pDev->pUsbIns->pszName, iCfg));
288	return false;
289	}
290
291	/*
292	* Check that the device is in a valid state.
293	* (The caller has already checked that it's not being reset.)
294	*/
295	const VUSBDEVICESTATE enmState = pDev->enmState;
296	if (enmState == VUSB_DEVICE_STATE_DEFAULT)
297	{
298	LogFlow(("vusbDevStdReqSetConfig: %s: default dev state !!?\n", pDev->pUsbIns->pszName));
299	return false;
300	}
301
302	PCVUSBDESCCONFIGEX pNewCfgDesc = vusbDevFindCfgDesc(pDev, iCfg);
303	if (!pNewCfgDesc)
304	{
305	Log(("vusb: error: %s: config %i not found !!!\n", pDev->pUsbIns->pszName, iCfg));
306	return false;
307	}
308
309	if (iCfg == 0)
310	pDev->enmState = VUSB_DEVICE_STATE_ADDRESS;
311	else
312	pDev->enmState = VUSB_DEVICE_STATE_CONFIGURED;
313	if (pDev->pUsbIns->pReg->pfnUsbSetConfiguration)
314	{
315	int rc = vusbDevIoThreadExecSync(pDev, (PFNRT)pDev->pUsbIns->pReg->pfnUsbSetConfiguration, 5,
316	pDev->pUsbIns, pNewCfgDesc->Core.bConfigurationValue,
317	pDev->pCurCfgDesc, pDev->paIfStates, pNewCfgDesc);
318	if (RT_FAILURE(rc))
319	{
320	Log(("vusb: error: %s: failed to set config %i (%Rrc) !!!\n", pDev->pUsbIns->pszName, iCfg, rc));
321	return false;
322	}
323	}
324	Log(("vusb: %p[%s]: SET_CONFIGURATION: Selected config %u\n", pDev, pDev->pUsbIns->pszName, iCfg));
325	return vusbDevDoSelectConfig(pDev, pNewCfgDesc);
326	}
327
328
329	/**
330	* Standard device request: GET_CONFIGURATION
331	* @returns success indicator.
332	*/
333	static bool vusbDevStdReqGetConfig(PVUSBDEV pDev, int EndPt, PVUSBSETUP pSetup, uint8_t pbBuf, uint32_t pcbBuf)
334	{
335	if ((pSetup->bmRequestType & VUSB_RECIP_MASK) != VUSB_TO_DEVICE)
336	{
337	Log(("vusb: error: %s: GET_CONFIGURATION - invalid request (dir) !!!\n", pDev->pUsbIns->pszName));
338	return false;
339	}
340
341	/*
342	* Check that the device is in a valid state.
343	* (The caller has already checked that it's not being reset.)
344	*/
345	const VUSBDEVICESTATE enmState = pDev->enmState;
346	if ( enmState != VUSB_DEVICE_STATE_CONFIGURED
347	&& enmState != VUSB_DEVICE_STATE_ADDRESS)
348	{
349	LogFlow(("vusbDevStdReqGetConfig: error: %s: invalid device state %d!!!\n", pDev->pUsbIns->pszName, enmState));
350	return false;
351	}
352
353	if (*pcbBuf < 1)
354	{
355	LogFlow(("vusbDevStdReqGetConfig: %s: no space for data!\n", pDev->pUsbIns->pszName));
356	return true;
357	}
358
359	uint8_t iCfg;
360	if (pDev->enmState == VUSB_DEVICE_STATE_ADDRESS)
361	iCfg = 0;
362	else
363	iCfg = pDev->pCurCfgDesc->Core.bConfigurationValue;
364
365	*pbBuf = iCfg;
366	*pcbBuf = 1;
367	LogFlow(("vusbDevStdReqGetConfig: %s: returns iCfg=%d\n", pDev->pUsbIns->pszName, iCfg));
368	return true;
369	}
370
371	/**
372	* Standard device request: GET_INTERFACE
373	* @returns success indicator.
374	*/
375	static bool vusbDevStdReqGetInterface(PVUSBDEV pDev, int EndPt, PVUSBSETUP pSetup, uint8_t pbBuf, uint32_t pcbBuf)
376	{
377	if ((pSetup->bmRequestType & VUSB_RECIP_MASK) != VUSB_TO_INTERFACE)
378	{
379	Log(("vusb: error: %s: GET_INTERFACE - invalid request (dir) !!!\n", pDev->pUsbIns->pszName));
380	return false;
381	}
382
383	/*
384	* Check that the device is in a valid state.
385	* (The caller has already checked that it's not being reset.)
386	*/
387	const VUSBDEVICESTATE enmState = pDev->enmState;
388	if (enmState != VUSB_DEVICE_STATE_CONFIGURED)
389	{
390	LogFlow(("vusbDevStdReqGetInterface: error: %s: invalid device state %d!!!\n", pDev->pUsbIns->pszName, enmState));
391	return false;
392	}
393
394	if (*pcbBuf < 1)
395	{
396	LogFlow(("vusbDevStdReqGetInterface: %s: no space for data!\n", pDev->pUsbIns->pszName));
397	return true;
398	}
399
400	for (unsigned i = 0; i < pDev->pCurCfgDesc->Core.bNumInterfaces; i++)
401	{
402	PCVUSBDESCINTERFACEEX pIfDesc = pDev->paIfStates[i].pCurIfDesc;
403	if ( pIfDesc
404	&& pSetup->wIndex == pIfDesc->Core.bInterfaceNumber)
405	{
406	*pbBuf = pIfDesc->Core.bAlternateSetting;
407	*pcbBuf = 1;
408	Log(("vusb: %s: GET_INTERFACE: %u.%u\n", pDev->pUsbIns->pszName, pIfDesc->Core.bInterfaceNumber, *pbBuf));
409	return true;
410	}
411	}
412
413	Log(("vusb: error: %s: GET_INTERFACE - unknown iface %u !!!\n", pDev->pUsbIns->pszName, pSetup->wIndex));
414	return false;
415	}
416
417	/**
418	* Standard device request: SET_INTERFACE
419	* @returns success indicator.
420	*/
421	static bool vusbDevStdReqSetInterface(PVUSBDEV pDev, int EndPt, PVUSBSETUP pSetup, uint8_t pbBuf, uint32_t pcbBuf)
422	{
423	if ((pSetup->bmRequestType & VUSB_RECIP_MASK) != VUSB_TO_INTERFACE)
424	{
425	Log(("vusb: error: %s: SET_INTERFACE - invalid request (dir) !!!\n", pDev->pUsbIns->pszName));
426	return false;
427	}
428
429	/*
430	* Check that the device is in a valid state.
431	* (The caller has already checked that it's not being reset.)
432	*/
433	const VUSBDEVICESTATE enmState = pDev->enmState;
434	if (enmState != VUSB_DEVICE_STATE_CONFIGURED)
435	{
436	LogFlow(("vusbDevStdReqSetInterface: error: %s: invalid device state %d !!!\n", pDev->pUsbIns->pszName, enmState));
437	return false;
438	}
439
440	/*
441	* Find the interface.
442	*/
443	uint8_t iIf = pSetup->wIndex;
444	PVUSBINTERFACESTATE pIfState = vusbDevFindIfState(pDev, iIf);
445	if (!pIfState)
446	{
447	LogFlow(("vusbDevStdReqSetInterface: error: %s: couldn't find interface %u !!!\n", pDev->pUsbIns->pszName, iIf));
448	return false;
449	}
450	uint8_t iAlt = pSetup->wValue;
451	PCVUSBDESCINTERFACEEX pIfDesc = vusbDevFindAltIfDesc(pDev, pIfState, iAlt);
452	if (!pIfDesc)
453	{
454	LogFlow(("vusbDevStdReqSetInterface: error: %s: couldn't find alt interface %u.%u !!!\n", pDev->pUsbIns->pszName, iIf, iAlt));
455	return false;
456	}
457
458	if (pDev->pUsbIns->pReg->pfnUsbSetInterface)
459	{
460	int rc = vusbDevIoThreadExecSync(pDev, (PFNRT)pDev->pUsbIns->pReg->pfnUsbSetInterface, 3, pDev->pUsbIns, iIf, iAlt);
461	if (RT_FAILURE(rc))
462	{
463	LogFlow(("vusbDevStdReqSetInterface: error: %s: couldn't find alt interface %u.%u (%Rrc)\n", pDev->pUsbIns->pszName, iIf, iAlt, rc));
464	return false;
465	}
466	}
467
468	for (unsigned i = 0; i < pIfState->pCurIfDesc->Core.bNumEndpoints; i++)
469	unmap_endpoint(pDev, &pIfState->pCurIfDesc->paEndpoints[i]);
470
471	Log(("vusb: SET_INTERFACE: Selected %u.%u\n", iIf, iAlt));
472
473	map_interface(pDev, pIfDesc);
474	pIfState->pCurIfDesc = pIfDesc;
475
476	return true;
477	}
478
479	/**
480	* Standard device request: SET_ADDRESS
481	* @returns success indicator.
482	*/
483	static bool vusbDevStdReqSetAddress(PVUSBDEV pDev, int EndPt, PVUSBSETUP pSetup, uint8_t pbBuf, uint32_t pcbBuf)
484	{
485	if ((pSetup->bmRequestType & VUSB_RECIP_MASK) != VUSB_TO_DEVICE)
486	{
487	Log(("vusb: error: %s: SET_ADDRESS - invalid request (dir) !!!\n", pDev->pUsbIns->pszName));
488	return false;
489	}
490
491	/*
492	* Check that the device is in a valid state.
493	* (The caller has already checked that it's not being reset.)
494	*/
495	const VUSBDEVICESTATE enmState = pDev->enmState;
496	if ( enmState != VUSB_DEVICE_STATE_DEFAULT
497	&& enmState != VUSB_DEVICE_STATE_ADDRESS)
498	{
499	LogFlow(("vusbDevStdReqSetAddress: error: %s: invalid device state %d !!!\n", pDev->pUsbIns->pszName, enmState));
500	return false;
501	}
502
503	pDev->u8NewAddress = pSetup->wValue;
504	return true;
505	}
506
507	/**
508	* Standard device request: CLEAR_FEATURE
509	* @returns success indicator.
510	*
511	* @remark This is only called for VUSB_TO_ENDPOINT && ep == 0 && wValue == ENDPOINT_HALT.
512	* All other cases of CLEAR_FEATURE is handled in the normal async/sync manner.
513	*/
514	static bool vusbDevStdReqClearFeature(PVUSBDEV pDev, int EndPt, PVUSBSETUP pSetup, uint8_t pbBuf, uint32_t pcbBuf)
515	{
516	switch (pSetup->bmRequestType & VUSB_RECIP_MASK)
517	{
518	case VUSB_TO_DEVICE:
519	Log(("vusb: ClearFeature: dev(%u): selector=%u\n", pSetup->wIndex, pSetup->wValue));
520	break;
521	case VUSB_TO_INTERFACE:
522	Log(("vusb: ClearFeature: iface(%u): selector=%u\n", pSetup->wIndex, pSetup->wValue));
523	break;
524	case VUSB_TO_ENDPOINT:
525	Log(("vusb: ClearFeature: ep(%u): selector=%u\n", pSetup->wIndex, pSetup->wValue));
526	if ( !EndPt /* Default control pipe only */
527	&& pSetup->wValue == 0 /* ENDPOINT_HALT */
528	&& pDev->pUsbIns->pReg->pfnUsbClearHaltedEndpoint)
529	{
530	int rc = vusbDevIoThreadExecSync(pDev, (PFNRT)pDev->pUsbIns->pReg->pfnUsbClearHaltedEndpoint,
531	2, 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	*/
548	static 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
572	static 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	*/
614	static 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	*/
648	static 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	*/
679	static 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	*/
702	static 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	*/
774	static 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	*/
802	static 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	*/
870	bool 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	*/
918	static 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	*/
930	static 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	*/
969	void 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	static DECLCALLBACK(int) vusbDevCancelAllUrbsWorker(PVUSBDEV pDev, bool fDetaching)
1028	{
1029	/*
1030	* Iterate the URBs and cancel them.
1031	*/
1032	PVUSBURB pUrb = pDev->pAsyncUrbHead;
1033	while (pUrb)
1034	{
1035	PVUSBURB pNext = pUrb->VUsb.pNext;
1036
1037	Assert(pUrb->VUsb.pDev == pDev);
1038
1039	LogFlow(("%s: vusbDevCancelAllUrbs: CANCELING URB\n", pUrb->pszDesc));
1040	vusbUrbCancelWorker(pUrb, CANCELMODE_FAIL);
1041	pUrb = pNext;
1042	}
1043
1044	/*
1045	* Reap any URBs which became ripe during cancel now.
1046	*/
1047	unsigned cReaped;
1048	do
1049	{
1050	cReaped = 0;
1051	pUrb = pDev->pAsyncUrbHead;
1052	while (pUrb)
1053	{
1054	PVUSBURB pNext = pUrb->VUsb.pNext;
1055	Assert(pUrb->VUsb.pDev == pDev);
1056
1057	PVUSBURB pRipe = NULL;
1058	if (pUrb->enmState == VUSBURBSTATE_REAPED)
1059	pRipe = pUrb;
1060	else if (pUrb->enmState == VUSBURBSTATE_CANCELLED)
1061	#ifdef RT_OS_WINDOWS /** @todo Windows doesn't do cancelling, thus this kludge to prevent really bad
1062	* things from happening if we leave a pending URB behinds. */
1063	pRipe = pDev->pUsbIns->pReg->pfnUrbReap(pDev->pUsbIns, fDetaching ? 1500 : 0 /ms/);
1064	#else
1065	pRipe = pDev->pUsbIns->pReg->pfnUrbReap(pDev->pUsbIns, fDetaching ? 10 : 0 /ms/);
1066	#endif
1067	else
1068	AssertMsgFailed(("pUrb=%p enmState=%d\n", pUrb, pUrb->enmState));
1069	if (pRipe)
1070	{
1071	if (pRipe == pNext)
1072	pNext = pNext->VUsb.pNext;
1073	vusbUrbRipe(pRipe);
1074	cReaped++;
1075	}
1076
1077	pUrb = pNext;
1078	}
1079	} while (cReaped > 0);
1080
1081	/*
1082	* If we're detaching, we'll have to orphan any leftover URBs.
1083	*/
1084	if (fDetaching)
1085	{
1086	pUrb = pDev->pAsyncUrbHead;
1087	while (pUrb)
1088	{
1089	PVUSBURB pNext = pUrb->VUsb.pNext;
1090	Assert(pUrb->VUsb.pDev == pDev);
1091
1092	AssertMsgFailed(("%s: Leaking left over URB! state=%d pDev=%p[%s]\n",
1093	pUrb->pszDesc, pUrb->enmState, pDev, pDev->pUsbIns->pszName));
1094	vusbUrbUnlink(pUrb);
1095	/* Unlink isn't enough, because boundary timer and detaching will try to reap it.
1096	* It was tested with MSD & iphone attachment to vSMP guest, if
1097	* it breaks anything, please add comment here, why we should unlink only.
1098	*/
1099	pUrb->VUsb.pfnFree(pUrb);
1100	pUrb = pNext;
1101	}
1102	}
1103
1104	return VINF_SUCCESS;
1105	}
1106
1107	/**
1108	* Cancels and completes (with CRC failure) all async URBs pending
1109	* on a device. This is typically done as part of a reset and
1110	* before detaching a device.
1111	*
1112	* @param fDetaching If set, we will unconditionally unlink (and leak)
1113	* any URBs which isn't reaped.
1114	*/
1115	static void vusbDevCancelAllUrbs(PVUSBDEV pDev, bool fDetaching)
1116	{
1117	int rc = vusbDevIoThreadExecSync(pDev, (PFNRT)vusbDevCancelAllUrbsWorker, 2, pDev, fDetaching);
1118	AssertRC(rc);
1119	}
1120
1121
1122	static DECLCALLBACK(int) vusbDevUrbIoThread(RTTHREAD hThread, void *pvUser)
1123	{
1124	PVUSBDEV pDev = (PVUSBDEV)pvUser;
1125
1126	/* Notify the starter that we are up and running. */
1127	RTThreadUserSignal(hThread);
1128
1129	LogFlowFunc(("Entering work loop\n"));
1130
1131	while (!ASMAtomicReadBool(&pDev->fTerminate))
1132	{
1133	if (pDev->enmState != VUSB_DEVICE_STATE_RESET)
1134	vusbUrbDoReapAsyncDev(pDev, RT_INDEFINITE_WAIT);
1135
1136	/* Process any URBs waiting to be cancelled first. */
1137	int rc = RTReqQueueProcess(pDev->hReqQueueSync, 0); /* Don't wait if there is nothing to do. */
1138	Assert(RT_SUCCESS(rc) \|\| rc == VERR_TIMEOUT);
1139	}
1140
1141	return VINF_SUCCESS;
1142	}
1143
1144	int vusbDevUrbIoThreadWakeup(PVUSBDEV pDev)
1145	{
1146	ASMAtomicXchgBool(&pDev->fWokenUp, true);
1147	return pDev->pUsbIns->pReg->pfnWakeup(pDev->pUsbIns);
1148	}
1149
1150	/**
1151	* Create the URB I/O thread.
1152	*
1153	* @returns VBox status code.
1154	* @param pDev The VUSB device.
1155	*/
1156	int vusbDevUrbIoThreadCreate(PVUSBDEV pDev)
1157	{
1158	int rc = VINF_SUCCESS;
1159
1160	ASMAtomicXchgBool(&pDev->fTerminate, false);
1161	rc = RTThreadCreateF(&pDev->hUrbIoThread, vusbDevUrbIoThread, pDev, 0, RTTHREADTYPE_IO,
1162	RTTHREADFLAGS_WAITABLE, "USBDevIo-%d", pDev->i16Port);
1163	if (RT_SUCCESS(rc))
1164	{
1165	/* Wait for it to become active. */
1166	rc = RTThreadUserWait(pDev->hUrbIoThread, RT_INDEFINITE_WAIT);
1167	}
1168
1169	return rc;
1170	}
1171
1172	/**
1173	* Destro the URB I/O thread.
1174	*
1175	* @returns VBox status code.
1176	* @param pDev The VUSB device.
1177	*/
1178	int vusbDevUrbIoThreadDestroy(PVUSBDEV pDev)
1179	{
1180	int rc = VINF_SUCCESS;
1181	int rcThread = VINF_SUCCESS;
1182
1183	ASMAtomicXchgBool(&pDev->fTerminate, true);
1184	vusbDevUrbIoThreadWakeup(pDev);
1185
1186	rc = RTThreadWait(pDev->hUrbIoThread, RT_INDEFINITE_WAIT, &rcThread);
1187	if (RT_SUCCESS(rc))
1188	rc = rcThread;
1189
1190	pDev->hUrbIoThread = NIL_RTTHREAD;
1191
1192	return rc;
1193	}
1194
1195
1196	/**
1197	* Detaches a device from the hub it's attached to.
1198	*
1199	* @returns VBox status code.
1200	* @param pDev The device to detach.
1201	*
1202	* @remark This can be called in any state but reset.
1203	*/
1204	int vusbDevDetach(PVUSBDEV pDev)
1205	{
1206	LogFlow(("vusbDevDetach: pDev=%p[%s] enmState=%#x\n", pDev, pDev->pUsbIns->pszName, pDev->enmState));
1207	VUSBDEV_ASSERT_VALID_STATE(pDev->enmState);
1208	Assert(pDev->enmState != VUSB_DEVICE_STATE_RESET);
1209
1210	vusbDevCancelAllUrbs(pDev, true);
1211	vusbDevAddressUnHash(pDev);
1212
1213	PVUSBROOTHUB pRh = vusbDevGetRh(pDev);
1214	if (!pRh)
1215	AssertMsgFailedReturn(("Not attached!\n"), VERR_VUSB_DEVICE_NOT_ATTACHED);
1216	if (pRh->pDefaultAddress == pDev)
1217	pRh->pDefaultAddress = NULL;
1218
1219	pDev->pHub->pOps->pfnDetach(pDev->pHub, pDev);
1220	pDev->i16Port = -1;
1221	pDev->enmState = VUSB_DEVICE_STATE_DETACHED;
1222	pDev->pHub = NULL;
1223
1224	/* Remove the configuration */
1225	pDev->pCurCfgDesc = NULL;
1226	for (unsigned i = 0; i < VUSB_PIPE_MAX; i++)
1227	vusbMsgFreeExtraData(pDev->aPipes[i].pCtrl);
1228	memset(pDev->aPipes, 0, sizeof(pDev->aPipes));
1229	return VINF_SUCCESS;
1230	}
1231
1232
1233	/**
1234	* Destroys a device, detaching it from the hub if necessary.
1235	*
1236	* @param pDev The device.
1237	* @thread EMT
1238	*/
1239	void vusbDevDestroy(PVUSBDEV pDev)
1240	{
1241	LogFlow(("vusbDevDestroy: pDev=%p[%s] enmState=%d\n", pDev, pDev->pUsbIns->pszName, pDev->enmState));
1242
1243	/*
1244	* Deal with pending async reset.
1245	*/
1246	if (pDev->enmState == VUSB_DEVICE_STATE_RESET)
1247	pDev->enmState = VUSB_DEVICE_STATE_DEFAULT; /* anything but reset */
1248
1249	/*
1250	* Detach and free resources.
1251	*/
1252	if (pDev->pHub)
1253	vusbDevDetach(pDev);
1254	RTMemFree(pDev->paIfStates);
1255	TMR3TimerDestroy(pDev->pResetTimer);
1256	pDev->pResetTimer = NULL;
1257
1258	/*
1259	* Destroy I/O thread and request queue last because they might still be used
1260	* when cancelling URBs.
1261	*/
1262	vusbDevUrbIoThreadDestroy(pDev);
1263
1264	int rc = RTReqQueueDestroy(pDev->hReqQueueSync);
1265	AssertRC(rc);
1266
1267	RTCritSectDelete(&pDev->CritSectAsyncUrbs);
1268	pDev->enmState = VUSB_DEVICE_STATE_DESTROYED;
1269	}
1270
1271
1272	/* -=-=-=-=-=- VUSBIDEVICE methods -=-=-=-=-=- */
1273
1274
1275	/**
1276	* The actual reset has been done, do completion on EMT.
1277	*
1278	* There are several things we have to do now, like set default
1279	* config and address, and cleanup the state of control pipes.
1280	*
1281	* It's possible that the device has a delayed destroy request
1282	* pending when we get here. This can happen for async resetting.
1283	* We deal with it here, since we're now executing on the EMT
1284	* thread and the destruction will be properly serialized now.
1285	*
1286	* @param pDev The device that is being reset.
1287	* @param rc The vusbDevResetWorker return code.
1288	* @param pfnDone The done callback specified by the caller of vusbDevReset().
1289	* @param pvUser The user argument for the callback.
1290	*/
1291	static void vusbDevResetDone(PVUSBDEV pDev, int rc, PFNVUSBRESETDONE pfnDone, void *pvUser)
1292	{
1293	VUSBDEV_ASSERT_VALID_STATE(pDev->enmState);
1294	Assert(pDev->enmState == VUSB_DEVICE_STATE_RESET);
1295
1296	/*
1297	* Do control pipe cleanup regardless of state and result.
1298	*/
1299	for (unsigned i = 0; i < VUSB_PIPE_MAX; i++)
1300	if (pDev->aPipes[i].pCtrl)
1301	vusbMsgResetExtraData(pDev->aPipes[i].pCtrl);
1302
1303	/*
1304	* Switch to the default state.
1305	*/
1306	pDev->enmState = VUSB_DEVICE_STATE_DEFAULT;
1307	pDev->u16Status = 0;
1308	vusbDevDoSelectConfig(pDev, &g_Config0);
1309	if (!vusbDevIsRh(pDev))
1310	vusbDevSetAddress(pDev, VUSB_DEFAULT_ADDRESS);
1311	if (pfnDone)
1312	pfnDone(&pDev->IDevice, rc, pvUser);
1313	}
1314
1315
1316	/**
1317	* Timer callback for doing reset completion.
1318	*
1319	* @param pUsbIns The USB device instance.
1320	* @param pTimer The timer instance.
1321	* @param pvUser The VUSB device data.
1322	* @thread EMT
1323	*/
1324	static DECLCALLBACK(void) vusbDevResetDoneTimer(PPDMUSBINS pUsbIns, PTMTIMER pTimer, void *pvUser)
1325	{
1326	PVUSBDEV pDev = (PVUSBDEV)pvUser;
1327	PVUSBRESETARGS pArgs = (PVUSBRESETARGS)pDev->pvArgs;
1328	Assert(pDev->pUsbIns == pUsbIns);
1329
1330	/*
1331	* Reset-done processing and cleanup.
1332	*/
1333	vusbDevResetDone(pDev, pArgs->rc, pArgs->pfnDone, pArgs->pvUser);
1334	pDev->pvArgs = NULL;
1335	RTMemFree(pArgs);
1336	}
1337
1338
1339	/**
1340	* Perform the actual reset.
1341	*
1342	* @thread EMT or a VUSB reset thread.
1343	*/
1344	static int vusbDevResetWorker(PVUSBDEV pDev, bool fResetOnLinux, bool fUseTimer, PVUSBRESETARGS pArgs)
1345	{
1346	int rc = VINF_SUCCESS;
1347	uint64_t u64EndTS = TMTimerGet(pDev->pResetTimer) + TMTimerFromMilli(pDev->pResetTimer, 10);
1348
1349	if (pDev->pUsbIns->pReg->pfnUsbReset)
1350	rc = pDev->pUsbIns->pReg->pfnUsbReset(pDev->pUsbIns, fResetOnLinux);
1351
1352	if (fUseTimer)
1353	{
1354	/*
1355	* We use a timer to communicate the result back to EMT.
1356	* This avoids suspend + poweroff issues, and it should give
1357	* us more accurate scheduling than making this thread sleep.
1358	*/
1359	int rc2 = TMTimerSet(pDev->pResetTimer, u64EndTS);
1360	AssertReleaseRC(rc2);
1361	}
1362
1363	if (pArgs)
1364	{
1365	pArgs->rc = rc;
1366	rc = VINF_SUCCESS;
1367	}
1368
1369	LogFlow(("vusbDevResetWorker: %s: returns %Rrc\n", pDev->pUsbIns->pszName, rc));
1370	return rc;
1371	}
1372
1373
1374	/**
1375	* Resets a device.
1376	*
1377	* Since a device reset shall take at least 10ms from the guest point of view,
1378	* it must be performed asynchronously. We create a thread which performs this
1379	* operation and ensures it will take at least 10ms.
1380	*
1381	* At times - like init - a synchronous reset is required, this can be done
1382	* by passing NULL for pfnDone.
1383	*
1384	* While the device is being reset it is in the VUSB_DEVICE_STATE_RESET state.
1385	* On completion it will be in the VUSB_DEVICE_STATE_DEFAULT state if successful,
1386	* or in the VUSB_DEVICE_STATE_DETACHED state if the rest failed.
1387	*
1388	* @returns VBox status code.
1389	*
1390	* @param pDev Pointer to the VUSB device interface.
1391	* @param fResetOnLinux Whether it's safe to reset the device(s) on a linux
1392	* host system. See discussion of logical reconnects elsewhere.
1393	* @param pfnDone Pointer to the completion routine. If NULL a synchronous
1394	* reset is preformed not respecting the 10ms.
1395	* @param pVM Pointer to the VM handle for performing the done function
1396	* on the EMT thread.
1397	* @thread EMT
1398	*/
1399	DECLCALLBACK(int) vusbDevReset(PVUSBIDEVICE pDevice, bool fResetOnLinux, PFNVUSBRESETDONE pfnDone, void *pvUser, PVM pVM)
1400	{
1401	PVUSBDEV pDev = (PVUSBDEV)pDevice;
1402	Assert(!pfnDone \|\| pVM);
1403	LogFlow(("vusb: reset: [%s]/%i\n", pDev->pUsbIns->pszName, pDev->i16Port));
1404
1405	/*
1406	* Only one reset operation at a time.
1407	*/
1408	const VUSBDEVICESTATE enmState = pDev->enmState;
1409	VUSBDEV_ASSERT_VALID_STATE(enmState);
1410	if (enmState == VUSB_DEVICE_STATE_RESET)
1411	{
1412	LogRel(("VUSB: %s: reset request is ignored, the device is already resetting!\n", pDev->pUsbIns->pszName));
1413	return VERR_VUSB_DEVICE_IS_RESETTING;
1414	}
1415	pDev->enmState = VUSB_DEVICE_STATE_RESET;
1416
1417	/*
1418	* First, cancel all async URBs.
1419	*/
1420	vusbDevCancelAllUrbs(pDev, false);
1421
1422	/* Async or sync? */
1423	if (pfnDone)
1424	{
1425	/*
1426	* Async fashion.
1427	*/
1428	PVUSBRESETARGS pArgs = (PVUSBRESETARGS)RTMemTmpAlloc(sizeof(*pArgs));
1429	if (pArgs)
1430	{
1431	pArgs->pDev = pDev;
1432	pArgs->pfnDone = pfnDone;
1433	pArgs->pvUser = pvUser;
1434	pArgs->rc = VINF_SUCCESS;
1435	pDev->pvArgs = pArgs;
1436	int rc = vusbDevIoThreadExec(pDev, 0 /* fFlags */, (PFNRT)vusbDevResetWorker, 4, pDev, fResetOnLinux, true, pArgs);
1437	if (RT_SUCCESS(rc))
1438	return rc;
1439
1440	RTMemTmpFree(pArgs);
1441	}
1442	/* fall back to sync on failure */
1443	}
1444
1445	/*
1446	* Sync fashion.
1447	*/
1448	int rc = vusbDevResetWorker(pDev, fResetOnLinux, false, NULL);
1449	vusbDevResetDone(pDev, rc, pfnDone, pvUser);
1450	return rc;
1451	}
1452
1453
1454	/**
1455	* Powers on the device.
1456	*
1457	* @returns VBox status code.
1458	* @param pInterface Pointer to the device interface structure.
1459	*/
1460	DECLCALLBACK(int) vusbDevPowerOn(PVUSBIDEVICE pInterface)
1461	{
1462	PVUSBDEV pDev = (PVUSBDEV)pInterface;
1463	LogFlow(("vusbDevPowerOn: pDev=%p[%s]\n", pDev, pDev->pUsbIns->pszName));
1464
1465	/*
1466	* Check that the device is in a valid state.
1467	*/
1468	const VUSBDEVICESTATE enmState = pDev->enmState;
1469	VUSBDEV_ASSERT_VALID_STATE(enmState);
1470	if (enmState == VUSB_DEVICE_STATE_DETACHED)
1471	{
1472	Log(("vusb: warning: attempt to power on detached device %p[%s]\n", pDev, pDev->pUsbIns->pszName));
1473	return VERR_VUSB_DEVICE_NOT_ATTACHED;
1474	}
1475	if (enmState == VUSB_DEVICE_STATE_RESET)
1476	{
1477	LogRel(("VUSB: %s: power on ignored, the device is resetting!\n", pDev->pUsbIns->pszName));
1478	return VERR_VUSB_DEVICE_IS_RESETTING;
1479	}
1480
1481	/*
1482	* Do the job.
1483	*/
1484	if (enmState == VUSB_DEVICE_STATE_ATTACHED)
1485	pDev->enmState = VUSB_DEVICE_STATE_POWERED;
1486
1487	return VINF_SUCCESS;
1488	}
1489
1490
1491	/**
1492	* Powers off the device.
1493	*
1494	* @returns VBox status code.
1495	* @param pInterface Pointer to the device interface structure.
1496	*/
1497	DECLCALLBACK(int) vusbDevPowerOff(PVUSBIDEVICE pInterface)
1498	{
1499	PVUSBDEV pDev = (PVUSBDEV)pInterface;
1500	LogFlow(("vusbDevPowerOff: pDev=%p[%s]\n", pDev, pDev->pUsbIns->pszName));
1501
1502	/*
1503	* Check that the device is in a valid state.
1504	*/
1505	const VUSBDEVICESTATE enmState = pDev->enmState;
1506	VUSBDEV_ASSERT_VALID_STATE(enmState);
1507	if (enmState == VUSB_DEVICE_STATE_DETACHED)
1508	{
1509	Log(("vusb: warning: attempt to power off detached device %p[%s]\n", pDev, pDev->pUsbIns->pszName));
1510	return VERR_VUSB_DEVICE_NOT_ATTACHED;
1511	}
1512	if (enmState == VUSB_DEVICE_STATE_RESET)
1513	{
1514	LogRel(("VUSB: %s: power off ignored, the device is resetting!\n", pDev->pUsbIns->pszName));
1515	return VERR_VUSB_DEVICE_IS_RESETTING;
1516	}
1517
1518	/*
1519	* If it's a root hub, we will have to cancel all URBs and reap them.
1520	*/
1521	if (vusbDevIsRh(pDev))
1522	{
1523	PVUSBROOTHUB pRh = (PVUSBROOTHUB)pDev;
1524	VUSBIRhCancelAllUrbs(&pRh->IRhConnector);
1525	VUSBIRhReapAsyncUrbs(&pRh->IRhConnector, pInterface, 0);
1526	}
1527
1528	pDev->enmState = VUSB_DEVICE_STATE_ATTACHED;
1529
1530	return VINF_SUCCESS;
1531	}
1532
1533
1534	/**
1535	* Get the state of the device.
1536	*
1537	* @returns Device state.
1538	* @param pInterface Pointer to the device interface structure.
1539	*/
1540	DECLCALLBACK(VUSBDEVICESTATE) vusbDevGetState(PVUSBIDEVICE pInterface)
1541	{
1542	return ((PVUSBDEV)pInterface)->enmState;
1543	}
1544
1545
1546	/**
1547	* @interface_method_impl{VUSBIDEVICE,pfnIsEmulated}
1548	*/
1549	DECLCALLBACK(bool) vusbDevIsEmulated(PVUSBIDEVICE pInterface)
1550	{
1551	PVUSBDEV pDev = (PVUSBDEV)pInterface;
1552	bool fEmulated = !!(pDev->pUsbIns->pReg->fFlags & PDM_USBREG_EMULATED_DEVICE);
1553
1554	LogFlowFunc(("pInterface=%p\n", pInterface));
1555
1556	LogFlowFunc(("returns %RTbool\n", fEmulated));
1557	return fEmulated;
1558	}
1559
1560
1561	/**
1562	* The maximum number of interfaces the device can have in all of it's configuration.
1563	*
1564	* @returns Number of interfaces.
1565	* @param pDev The device.
1566	*/
1567	size_t vusbDevMaxInterfaces(PVUSBDEV pDev)
1568	{
1569	uint8_t cMax = 0;
1570	unsigned i = pDev->pDescCache->pDevice->bNumConfigurations;
1571	while (i-- > 0)
1572	{
1573	if (pDev->pDescCache->paConfigs[i].Core.bNumInterfaces > cMax)
1574	cMax = pDev->pDescCache->paConfigs[i].Core.bNumInterfaces;
1575	}
1576
1577	return cMax;
1578	}
1579
1580
1581	/**
1582	* Executes a given function on the I/O thread.
1583	*
1584	* @returns IPRT status code.
1585	* @param pDev The USB device instance data.
1586	* @param fFlags Combination of VUSB_DEV_IO_THREAD_EXEC_FLAGS_*
1587	* @param pfnFunction The function to execute.
1588	* @param cArgs Number of arguments to the function.
1589	* @param Args The parameter list.
1590	*
1591	* @remarks See remarks on RTReqQueueCallV
1592	*/
1593	DECLHIDDEN(int) vusbDevIoThreadExecV(PVUSBDEV pDev, uint32_t fFlags, PFNRT pfnFunction, unsigned cArgs, va_list Args)
1594	{
1595	int rc = VINF_SUCCESS;
1596	PRTREQ hReq = NULL;
1597
1598	Assert(pDev->hUrbIoThread != NIL_RTTHREAD);
1599	if (RT_LIKELY(pDev->hUrbIoThread != NIL_RTTHREAD))
1600	{
1601	uint32_t fReqFlags = RTREQFLAGS_IPRT_STATUS;
1602
1603	if (!(fFlags & VUSB_DEV_IO_THREAD_EXEC_FLAGS_SYNC))
1604	fReqFlags \|= RTREQFLAGS_NO_WAIT;
1605
1606	rc = RTReqQueueCallV(pDev->hReqQueueSync, &hReq, 0 /* cMillies */, fReqFlags, pfnFunction, cArgs, Args);
1607	Assert(RT_SUCCESS(rc) \|\| rc == VERR_TIMEOUT);
1608	vusbDevUrbIoThreadWakeup(pDev);
1609
1610	if (fFlags & VUSB_DEV_IO_THREAD_EXEC_FLAGS_SYNC)
1611	{
1612	rc = RTReqWait(hReq, RT_INDEFINITE_WAIT);
1613	AssertRC(rc);
1614	}
1615	}
1616	else
1617	rc = VERR_INVALID_STATE;
1618
1619	return rc;
1620	}
1621
1622
1623	/**
1624	* Executes a given function on the I/O thread.
1625	*
1626	* @returns IPRT status code.
1627	* @param pDev The USB device instance data.
1628	* @param fFlags Combination of VUSB_DEV_IO_THREAD_EXEC_FLAGS_*
1629	* @param pfnFunction The function to execute.
1630	* @param cArgs Number of arguments to the function.
1631	* @param ... The parameter list.
1632	*
1633	* @remarks See remarks on RTReqQueueCallV
1634	*/
1635	DECLHIDDEN(int) vusbDevIoThreadExec(PVUSBDEV pDev, uint32_t fFlags, PFNRT pfnFunction, unsigned cArgs, ...)
1636	{
1637	int rc = VINF_SUCCESS;
1638	va_list va;
1639
1640	va_start(va, cArgs);
1641	rc = vusbDevIoThreadExecV(pDev, fFlags, pfnFunction, cArgs, va);
1642	va_end(va);
1643	return rc;
1644	}
1645
1646
1647	/**
1648	* Executes a given function synchronously on the I/O thread waiting for it to complete.
1649	*
1650	* @returns IPRT status code.
1651	* @param pDev The USB device instance data
1652	* @param pfnFunction The function to execute.
1653	* @param cArgs Number of arguments to the function.
1654	* @param ... The parameter list.
1655	*
1656	* @remarks See remarks on RTReqQueueCallV
1657	*/
1658	DECLHIDDEN(int) vusbDevIoThreadExecSync(PVUSBDEV pDev, PFNRT pfnFunction, unsigned cArgs, ...)
1659	{
1660	int rc = VINF_SUCCESS;
1661	va_list va;
1662
1663	va_start(va, cArgs);
1664	rc = vusbDevIoThreadExecV(pDev, VUSB_DEV_IO_THREAD_EXEC_FLAGS_SYNC, pfnFunction, cArgs, va);
1665	va_end(va);
1666	return rc;
1667	}
1668
1669
1670	static DECLCALLBACK(int) vusbDevGetDescriptorCacheWorker(PPDMUSBINS pUsbIns, PCPDMUSBDESCCACHE *ppDescCache)
1671	{
1672	*ppDescCache = pUsbIns->pReg->pfnUsbGetDescriptorCache(pUsbIns);
1673	return VINF_SUCCESS;
1674	}
1675
1676	/**
1677	* Initialize a new VUSB device.
1678	*
1679	* @returns VBox status code.
1680	* @param pDev The VUSB device to initialize.
1681	* @param pUsbIns Pointer to the PDM USB Device instance.
1682	*/
1683	int vusbDevInit(PVUSBDEV pDev, PPDMUSBINS pUsbIns)
1684	{
1685	/*
1686	* Initialize the device data members.
1687	* (All that are Non-Zero at least.)
1688	*/
1689	Assert(!pDev->IDevice.pfnReset);
1690	Assert(!pDev->IDevice.pfnPowerOn);
1691	Assert(!pDev->IDevice.pfnPowerOff);
1692	Assert(!pDev->IDevice.pfnGetState);
1693	Assert(!pDev->IDevice.pfnIsEmulated);
1694
1695	pDev->IDevice.pfnReset = vusbDevReset;
1696	pDev->IDevice.pfnPowerOn = vusbDevPowerOn;
1697	pDev->IDevice.pfnPowerOff = vusbDevPowerOff;
1698	pDev->IDevice.pfnGetState = vusbDevGetState;
1699	pDev->IDevice.pfnIsEmulated = vusbDevIsEmulated;
1700	pDev->pUsbIns = pUsbIns;
1701	pDev->pNext = NULL;
1702	pDev->pNextHash = NULL;
1703	pDev->pHub = NULL;
1704	pDev->enmState = VUSB_DEVICE_STATE_DETACHED;
1705	pDev->u8Address = VUSB_INVALID_ADDRESS;
1706	pDev->u8NewAddress = VUSB_INVALID_ADDRESS;
1707	pDev->i16Port = -1;
1708	pDev->u16Status = 0;
1709	pDev->pDescCache = NULL;
1710	pDev->pCurCfgDesc = NULL;
1711	pDev->paIfStates = NULL;
1712	memset(&pDev->aPipes[0], 0, sizeof(pDev->aPipes));
1713	pDev->pResetTimer = NULL;
1714
1715	int rc = RTCritSectInit(&pDev->CritSectAsyncUrbs);
1716	AssertRCReturn(rc, rc);
1717
1718	/* Setup request queue executing synchronous tasks on the I/O thread. */
1719	rc = RTReqQueueCreate(&pDev->hReqQueueSync);
1720	AssertRCReturn(rc, rc);
1721
1722	/* Create I/O thread. */
1723	rc = vusbDevUrbIoThreadCreate(pDev);
1724	AssertRCReturn(rc, rc);
1725
1726	/*
1727	* Create the reset timer.
1728	*/
1729	rc = PDMUsbHlpTMTimerCreate(pDev->pUsbIns, TMCLOCK_VIRTUAL, vusbDevResetDoneTimer, pDev, 0 /fFlags/,
1730	"USB Device Reset Timer", &pDev->pResetTimer);
1731	AssertRCReturn(rc, rc);
1732
1733	/*
1734	* Get the descriptor cache from the device. (shall cannot fail)
1735	*/
1736	rc = vusbDevIoThreadExecSync(pDev, (PFNRT)vusbDevGetDescriptorCacheWorker, 2, pUsbIns, &pDev->pDescCache);
1737	AssertRC(rc);
1738	AssertPtr(pDev->pDescCache);
1739	#ifdef VBOX_STRICT
1740	if (pDev->pDescCache->fUseCachedStringsDescriptors)
1741	{
1742	int32_t iPrevId = -1;
1743	for (unsigned iLang = 0; iLang < pDev->pDescCache->cLanguages; iLang++)
1744	{
1745	Assert((int32_t)pDev->pDescCache->paLanguages[iLang].idLang > iPrevId);
1746	iPrevId = pDev->pDescCache->paLanguages[iLang].idLang;
1747
1748	int32_t idxPrevStr = -1;
1749	PCPDMUSBDESCCACHESTRING paStrings = pDev->pDescCache->paLanguages[iLang].paStrings;
1750	unsigned cStrings = pDev->pDescCache->paLanguages[iLang].cStrings;
1751	for (unsigned iStr = 0; iStr < cStrings; iStr++)
1752	{
1753	Assert((int32_t)paStrings[iStr].idx > idxPrevStr);
1754	idxPrevStr = paStrings[iStr].idx;
1755	size_t cch = strlen(paStrings[iStr].psz);
1756	Assert(cch <= 127);
1757	}
1758	}
1759	}
1760	#endif
1761
1762	/*
1763	* Allocate memory for the interface states.
1764	*/
1765	size_t cbIface = vusbDevMaxInterfaces(pDev) * sizeof(*pDev->paIfStates);
1766	pDev->paIfStates = (PVUSBINTERFACESTATE)RTMemAllocZ(cbIface);
1767	AssertMsgReturn(pDev->paIfStates, ("RTMemAllocZ(%d) failed\n", cbIface), VERR_NO_MEMORY);
1768
1769	return VINF_SUCCESS;
1770	}
1771
1772	/*
1773	* Local Variables:
1774	* mode: c
1775	* c-file-style: "bsd"
1776	* c-basic-offset: 4
1777	* tab-width: 4
1778	* indent-tabs-mode: s
1779	* End:
1780	*/
1781

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: