VUSBDevice.cpp@ 104821

Last change on this file since 104821 was 100517, checked in by vboxsync, 16 months ago
VUSB: Explicitly ignore any high bits of a USB address which is a 7-bit quantity (see bugref:10433).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 62.7 KB

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

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

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

Download in other formats: