USBProxyDevice.cpp@ 42401

Last change on this file since 42401 was 40282, checked in by vboxsync, 13 years ago
: gcc-4.7: ~0 => ~0U in initializers (warning: narrowing conversion of `-1' from` int' to `unsigned int' inside { } is ill-formed in C++11 [-Wnarrowing]*)
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 37.2 KB

Line
1	/* $Id: USBProxyDevice.cpp 40282 2012-02-28 21:02:40Z vboxsync $ */
2	/** @file
3	* USBProxy - USB device proxy.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 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_USBPROXY
23	#include <VBox/usb.h>
24	#include <VBox/usbfilter.h>
25	#include <VBox/vmm/pdm.h>
26	#include <VBox/err.h>
27	#include <iprt/alloc.h>
28	#include <iprt/string.h>
29	#include <VBox/log.h>
30	#include <iprt/assert.h>
31	#include "USBProxyDevice.h"
32	#include "VUSBInternal.h"
33	#include "VBoxDD.h"
34
35
36	/*******************************************************************************
37	* Global Variables *
38	*******************************************************************************/
39	/** A dummy name used early during the construction phase to avoid log crashes. */
40	static char g_szDummyName[] = "proxy xxxx:yyyy";
41
42
43
44	/* Synchronously obtain a standard USB descriptor for a device, used in order
45	* to grab configuration descriptors when we first add the device
46	*/
47	static void *GetStdDescSync(PUSBPROXYDEV pProxyDev, uint8_t iDescType, uint8_t iIdx, uint16_t LangId, uint16_t cbHint)
48	{
49	LogFlow(("GetStdDescSync: pProxyDev=%s\n", pProxyDev->pUsbIns->pszName));
50	for (;;)
51	{
52	/*
53	* Setup a MSG URB, queue and reap it.
54	*/
55	VUSBURB Urb;
56	AssertCompile(RT_SIZEOFMEMB(VUSBURB, abData) >= _4K);
57	Urb.u32Magic = VUSBURB_MAGIC;
58	Urb.enmState = VUSBURBSTATE_IN_FLIGHT;
59	Urb.pszDesc = (char*)"URB sync";
60	memset(&Urb.VUsb, 0, sizeof(Urb.VUsb));
61	memset(&Urb.Hci, 0, sizeof(Urb.Hci));
62	Urb.Dev.pvPrivate = NULL;
63	Urb.Dev.pNext = NULL;
64	Urb.pUsbIns = pProxyDev->pUsbIns;
65	Urb.DstAddress = 0;
66	Urb.EndPt = 0;
67	Urb.enmType = VUSBXFERTYPE_MSG;
68	Urb.enmDir = VUSBDIRECTION_IN;
69	Urb.fShortNotOk = false;
70	Urb.enmStatus = VUSBSTATUS_INVALID;
71	cbHint = RT_MIN(cbHint, sizeof(Urb.abData) - sizeof(VUSBSETUP));
72	Urb.cbData = cbHint + sizeof(VUSBSETUP);
73
74	PVUSBSETUP pSetup = (PVUSBSETUP)Urb.abData;
75	pSetup->bmRequestType = VUSB_DIR_TO_HOST \| VUSB_REQ_STANDARD \| VUSB_TO_DEVICE;
76	pSetup->bRequest = VUSB_REQ_GET_DESCRIPTOR;
77	pSetup->wValue = (iDescType << 8) \| iIdx;
78	pSetup->wIndex = LangId;
79	pSetup->wLength = cbHint;
80
81	if (!pProxyDev->pOps->pfnUrbQueue(&Urb))
82	break;
83
84	/* Don't wait forever, it's just a simple request that should
85	return immediately. Since we're executing in the EMT thread
86	it's important not to get stuck here. (Some of the builtin
87	iMac devices may not refuse respond for instance.) */
88	PVUSBURB pUrbReaped = pProxyDev->pOps->pfnUrbReap(pProxyDev, 10000 /* ms */);
89	if (!pUrbReaped)
90	{
91	pProxyDev->pOps->pfnUrbCancel(&Urb);
92	pUrbReaped = pProxyDev->pOps->pfnUrbReap(pProxyDev, RT_INDEFINITE_WAIT);
93	}
94	if (pUrbReaped != &Urb)
95	{
96	Log(("GetStdDescSync: pfnUrbReap failed, pUrbReaped=%p\n", pUrbReaped));
97	break;
98	}
99
100	if (Urb.enmStatus != VUSBSTATUS_OK)
101	{
102	Log(("GetStdDescSync: Urb.enmStatus=%d\n", Urb.enmStatus));
103	break;
104	}
105
106	/*
107	* Check the length, config descriptors have total_length field
108	*/
109	uint8_t pbDesc = (uint8_t )(pSetup + 1);
110	uint32_t cbDesc;
111	if (iDescType == VUSB_DT_CONFIG)
112	{
113	if (Urb.cbData < sizeof(VUSBSETUP) + 4)
114	{
115	Log(("GetStdDescSync: Urb.cbData=%#x (min 4)\n", Urb.cbData));
116	break;
117	}
118	cbDesc = RT_LE2H_U16(((uint16_t *)pbDesc)[1]);
119	}
120	else
121	{
122	if (Urb.cbData < sizeof(VUSBSETUP) + 1)
123	{
124	Log(("GetStdDescSync: Urb.cbData=%#x (min 1)\n", Urb.cbData));
125	break;
126	}
127	cbDesc = ((uint8_t *)pbDesc)[0];
128	}
129
130	Log(("GetStdDescSync: got Urb.cbData=%u, cbDesc=%u cbHint=%u\n", Urb.cbData, cbDesc, cbHint));
131
132	if ( Urb.cbData == cbHint + sizeof(VUSBSETUP)
133	&& cbDesc > Urb.cbData - sizeof(VUSBSETUP))
134	{
135	cbHint = cbDesc;
136	if (cbHint > sizeof(Urb.abData))
137	{
138	AssertMsgFailed(("cbHint=%u\n", cbHint));
139	break;
140	}
141	continue;
142	}
143	Assert(cbDesc <= Urb.cbData - sizeof(VUSBSETUP));
144	#ifdef LOG_ENABLED
145	vusbUrbTrace(&Urb, "GetStdDescSync", true);
146	#endif
147
148	/*
149	* Fine, we got everything return a heap duplicate of the descriptor.
150	*/
151	return RTMemDup(pbDesc, cbDesc);
152	}
153	return NULL;
154	}
155
156	/**
157	* Frees a descriptor returned by GetStdDescSync().
158	*/
159	static void free_desc(void *pvDesc)
160	{
161	RTMemFree(pvDesc);
162	}
163
164	/**
165	* Get and a device descriptor and byteswap it appropriately.
166	*/
167	static bool usbProxyGetDeviceDesc(PUSBPROXYDEV pProxyDev, PVUSBDESCDEVICE pOut)
168	{
169	/*
170	* Get the descriptor from the device.
171	*/
172	PVUSBDESCDEVICE pIn = (PVUSBDESCDEVICE)GetStdDescSync(pProxyDev, VUSB_DT_DEVICE, 0, 0, VUSB_DT_DEVICE_MIN_LEN);
173	if (!pIn)
174	{
175	Log(("usbProxyGetDeviceDesc: pProxyDev=%s: GetStdDescSync failed\n", pProxyDev->pUsbIns->pszName));
176	return false;
177	}
178	if (pIn->bLength < VUSB_DT_DEVICE_MIN_LEN)
179	{
180	Log(("usb-proxy: pProxyDev=%s: Corrupted device descriptor. bLength=%d\n", pProxyDev->pUsbIns->pszName, pIn->bLength));
181	return false;
182	}
183
184	/*
185	* Convert it.
186	*/
187	pOut->bLength = VUSB_DT_DEVICE_MIN_LEN;
188	pOut->bDescriptorType = VUSB_DT_DEVICE;
189	pOut->bcdUSB = RT_LE2H_U16(pIn->bcdUSB);
190	pOut->bDeviceClass = pIn->bDeviceClass;
191	pOut->bDeviceSubClass = pIn->bDeviceSubClass;
192	pOut->bDeviceProtocol = pIn->bDeviceProtocol;
193	pOut->bMaxPacketSize0 = pIn->bMaxPacketSize0;
194	pOut->idVendor = RT_LE2H_U16(pIn->idVendor);
195	pOut->idProduct = RT_LE2H_U16(pIn->idProduct);
196	pOut->bcdDevice = RT_LE2H_U16(pIn->bcdDevice);
197	pOut->iManufacturer = pIn->iManufacturer;
198	pOut->iProduct = pIn->iProduct;
199	pOut->iSerialNumber = pIn->iSerialNumber;
200	pOut->bNumConfigurations = pIn->bNumConfigurations;
201
202	free_desc(pIn);
203	return true;
204	}
205
206	/**
207	* Count the numbers and types of each kind of descriptor that we need to
208	* copy out of the config descriptor
209	*/
210	struct desc_counts
211	{
212	size_t num_ed, num_id, num_if;
213	/** bitmap (128 bits) */
214	uint32_t idmap[4];
215	};
216
217	static int count_descriptors(struct desc_counts cnt, uint8_t buf, size_t len)
218	{
219	PVUSBDESCCONFIG cfg;
220	uint8_t tmp, end;
221	uint32_t i, x;
222
223	memset(cnt, 0, sizeof(*cnt));
224
225	end = buf + len;
226
227	cfg = (PVUSBDESCCONFIG)buf;
228	if ( cfg->bLength < VUSB_DT_CONFIG_MIN_LEN )
229	return 0;
230	if ( cfg->bLength > len )
231	return 0;
232
233	for (tmp = buf + cfg->bLength; ((tmp + 1) < end) && tmp; tmp += tmp)
234	{
235	uint8_t type;
236	uint32_t ifnum;
237	PVUSBDESCINTERFACE id;
238	PVUSBDESCENDPOINT ed;
239
240	type = *(tmp + 1);
241
242	switch ( type ) {
243	case VUSB_DT_INTERFACE:
244	id = (PVUSBDESCINTERFACE)tmp;
245	if ( id->bLength < VUSB_DT_INTERFACE_MIN_LEN )
246	return 0;
247	cnt->num_id++;
248	ifnum = id->bInterfaceNumber;
249	cnt->idmap[ifnum >> 6] \|= (1 << (ifnum & 0x1f));
250	break;
251	case VUSB_DT_ENDPOINT:
252	ed = (PVUSBDESCENDPOINT)tmp;
253	if ( ed->bLength < VUSB_DT_ENDPOINT_MIN_LEN )
254	return 0;
255	cnt->num_ed++;
256	break;
257	default:
258	break;
259	}
260	}
261
262	/* count interfaces */
263	for(i=0; i < RT_ELEMENTS(cnt->idmap); i++)
264	for(x=1; x; x<<=1)
265	if ( cnt->idmap[i] & x )
266	cnt->num_if++;
267
268	return 1;
269	}
270
271	/* Given the pointer to an interface or endpoint descriptor, find any following
272	* non-standard (vendor or class) descriptors.
273	*/
274	static const void collect_stray_bits(uint8_t this_desc, uint8_t end, uint16_t cbExtra)
275	{
276	uint8_t tmp, buf;
277	uint8_t type;
278
279	Assert((this_desc + 1) == VUSB_DT_INTERFACE \|\| (this_desc + 1) == VUSB_DT_ENDPOINT);
280	buf = this_desc;
281
282	/* Skip the current interface/endpoint descriptor. */
283	buf += (uint8_t )buf;
284
285	/* Loop until we find another descriptor we understand. */
286	for (tmp = buf; ((tmp + 1) < end) && tmp; tmp += tmp)
287	{
288	type = *(tmp + 1);
289	if (type == VUSB_DT_INTERFACE \|\| type == VUSB_DT_ENDPOINT)
290	break;
291	}
292	*cbExtra = tmp - buf;
293	if (*cbExtra)
294	return buf;
295	else
296	return NULL;
297	}
298
299	/* Setup a vusb_interface structure given some preallocated structures
300	* to use, (we counted them already)
301	*/
302	static int copy_interface(PVUSBINTERFACE pIf, uint8_t ifnum,
303	PVUSBDESCINTERFACEEX id, PVUSBDESCENDPOINTEX ed,
304	uint8_t *buf, size_t len)
305	{
306	PVUSBDESCINTERFACEEX cur_if = NULL;
307	uint32_t altmap[4] = {0,};
308	uint8_t tmp, end = buf + len;
309	uint8_t *orig_desc = buf;
310	uint8_t alt;
311	int state;
312	size_t num_ep = 0;
313
314	buf += (uint8_t )buf;
315
316	pIf->cSettings = 0;
317	pIf->paSettings = NULL;
318
319	for (tmp = buf, state = 0; ((tmp + 1) < end) && tmp; tmp += tmp)
320	{
321	uint8_t type;
322	PVUSBDESCINTERFACE ifd;
323	PVUSBDESCENDPOINT epd;
324	PVUSBDESCENDPOINTEX cur_ep;
325
326	type = tmp[1];
327
328	switch ( type ) {
329	case VUSB_DT_INTERFACE:
330	state = 0;
331	ifd = (PVUSBDESCINTERFACE)tmp;
332
333	/* Ignoring this interface */
334	if ( ifd->bInterfaceNumber != ifnum )
335	break;
336
337	/* Check we didn't see this alternate setting already
338	* because that will break stuff
339	*/
340	alt = ifd->bAlternateSetting;
341	if ( altmap[alt >> 6] & (1 << (alt & 0x1f)) )
342	return 0;
343	altmap[alt >> 6] \|= (1 << (alt & 0x1f));
344
345	cur_if = *id;
346	(*id)++;
347	if ( pIf->cSettings == 0 )
348	pIf->paSettings = cur_if;
349
350	memcpy(cur_if, ifd, sizeof(cur_if->Core));
351
352	/* Point to additional interface descriptor bytes, if any. */
353	AssertCompile(sizeof(cur_if->Core) == VUSB_DT_INTERFACE_MIN_LEN);
354	if (cur_if->Core.bLength - VUSB_DT_INTERFACE_MIN_LEN > 0)
355	cur_if->pvMore = tmp + VUSB_DT_INTERFACE_MIN_LEN;
356	else
357	cur_if->pvMore = NULL;
358
359	cur_if->pvClass = collect_stray_bits(tmp, end, &cur_if->cbClass);
360
361	pIf->cSettings++;
362
363	state = 1;
364	num_ep = 0;
365	break;
366	case VUSB_DT_ENDPOINT:
367	if ( state == 0 )
368	break;
369
370	epd = (PVUSBDESCENDPOINT)tmp;
371
372	cur_ep = *ed;
373	(*ed)++;
374
375	if ( num_ep == 0 )
376	cur_if->paEndpoints = cur_ep;
377
378	if ( num_ep > cur_if->Core.bNumEndpoints )
379	return 0;
380
381	memcpy(cur_ep, epd, sizeof(cur_ep->Core));
382
383	/* Point to additional endpoint descriptor bytes, if any. */
384	AssertCompile(sizeof(cur_ep->Core) == VUSB_DT_ENDPOINT_MIN_LEN);
385	if (cur_ep->Core.bLength - VUSB_DT_ENDPOINT_MIN_LEN > 0)
386	cur_ep->pvMore = tmp + VUSB_DT_ENDPOINT_MIN_LEN;
387	else
388	cur_ep->pvMore = NULL;
389
390	cur_ep->pvClass = collect_stray_bits(tmp, end, &cur_ep->cbClass);
391
392	cur_ep->Core.wMaxPacketSize = RT_LE2H_U16(cur_ep->Core.wMaxPacketSize);
393
394	num_ep++;
395	break;
396	default:
397	/* Skip unknown descriptors. */
398	break;
399	}
400	}
401
402	return 1;
403	}
404
405	/**
406	* Copy all of a devices config descriptors, this is needed so that the USB
407	* core layer knows all about how to map the different functions on to the
408	* virtual USB bus.
409	*/
410	static bool copy_config(PUSBPROXYDEV pProxyDev, uint8_t idx, PVUSBDESCCONFIGEX out)
411	{
412	PVUSBDESCCONFIG cfg;
413	PVUSBINTERFACE pIf;
414	PVUSBDESCINTERFACEEX ifd;
415	PVUSBDESCENDPOINTEX epd;
416	struct desc_counts cnt;
417	void *descs;
418	size_t tot_len;
419	size_t cbIface;
420	uint32_t i, x;
421
422	descs = GetStdDescSync(pProxyDev, VUSB_DT_CONFIG, idx, 0, VUSB_DT_CONFIG_MIN_LEN);
423	if ( descs == NULL ) {
424	Log(("copy_config: GetStdDescSync failed\n"));
425	return false;
426	}
427
428	cfg = (PVUSBDESCCONFIG)descs;
429	tot_len = RT_LE2H_U16(cfg->wTotalLength);
430
431	if ( !count_descriptors(&cnt, (uint8_t *)descs, tot_len) ) {
432	Log(("copy_config: count_descriptors failed\n"));
433	goto err;
434	}
435
436	if ( cfg->bNumInterfaces != cnt.num_if )
437	Log(("usb-proxy: config%u: bNumInterfaces %u != %u\n",
438	idx, cfg->bNumInterfaces, cnt.num_if));
439
440	Log(("usb-proxy: config%u: %u bytes id=%u ed=%u if=%u\n",
441	idx, tot_len, cnt.num_id, cnt.num_ed, cnt.num_if));
442
443	cbIface = cnt.num_if * sizeof(VUSBINTERFACE)
444	+ cnt.num_id * sizeof(VUSBDESCINTERFACEEX)
445	+ cnt.num_ed * sizeof(VUSBDESCENDPOINTEX);
446	out->paIfs = (PCVUSBINTERFACE)RTMemAllocZ(cbIface);
447	if ( out->paIfs == NULL ) {
448	free_desc(descs);
449	return false;
450	}
451
452	/* Stash a pointer to the raw config descriptor; we may need bits of it later. */
453	out->pvOriginal = descs;
454
455	pIf = (PVUSBINTERFACE)out->paIfs;
456	ifd = (PVUSBDESCINTERFACEEX)&pIf[cnt.num_if];
457	epd = (PVUSBDESCENDPOINTEX)&ifd[cnt.num_id];
458
459	out->Core.bLength = cfg->bLength;
460	out->Core.bDescriptorType = cfg->bDescriptorType;
461	out->Core.wTotalLength = 0; /* Auto Calculated */
462	out->Core.bNumInterfaces = (uint8_t)cnt.num_if;
463	out->Core.bConfigurationValue = cfg->bConfigurationValue;
464	out->Core.iConfiguration = cfg->iConfiguration;
465	out->Core.bmAttributes = cfg->bmAttributes;
466	out->Core.MaxPower = cfg->MaxPower;
467
468	for(i=0; i < 4; i++)
469	for(x=0; x < 32; x++)
470	if ( cnt.idmap[i] & (1 << x) )
471	if ( !copy_interface(pIf++, (i << 6) \| x, &ifd, &epd, (uint8_t *)out->pvOriginal, tot_len) ) {
472	Log(("copy_interface(%d,,) failed\n", pIf - 1));
473	goto err;
474	}
475
476	return true;
477	err:
478	Log(("usb-proxy: config%u: Corrupted configuration descriptor\n", idx));
479	free_desc(descs);
480	return false;
481	}
482
483
484	/**
485	* Edit out masked interface descriptors.
486	*
487	* @param pProxyDev The proxy device
488	*/
489	static void usbProxyDevEditOutMaskedIfs(PUSBPROXYDEV pProxyDev)
490	{
491	unsigned cRemoved = 0;
492
493	PVUSBDESCCONFIGEX paCfgs = pProxyDev->paCfgDescs;
494	for (unsigned iCfg = 0; iCfg < pProxyDev->DevDesc.bNumConfigurations; iCfg++)
495	{
496	PVUSBINTERFACE paIfs = (PVUSBINTERFACE)paCfgs[iCfg].paIfs;
497	for (unsigned iIf = 0; iIf < paCfgs[iCfg].Core.bNumInterfaces; iIf++)
498	for (uint32_t iAlt = 0; iAlt < paIfs[iIf].cSettings; iAlt++)
499	if ( paIfs[iIf].paSettings[iAlt].Core.bInterfaceNumber < 32
500	&& ((1 << paIfs[iIf].paSettings[iAlt].Core.bInterfaceNumber) & pProxyDev->fMaskedIfs))
501	{
502	Log(("usb-proxy: removing interface #%d (iIf=%d iAlt=%d) on config #%d (iCfg=%d)\n",
503	paIfs[iIf].paSettings[iAlt].Core.bInterfaceNumber, iIf, iAlt, paCfgs[iCfg].Core.bConfigurationValue, iCfg));
504	cRemoved++;
505
506	paCfgs[iCfg].Core.bNumInterfaces--;
507	unsigned cToCopy = paCfgs[iCfg].Core.bNumInterfaces - iIf;
508	if (cToCopy)
509	memmove(&paIfs[iIf], &paIfs[iIf + 1], sizeof(paIfs[0]) * cToCopy);
510	memset(&paIfs[iIf + cToCopy], '\0', sizeof(paIfs[0]));
511	break;
512	}
513	}
514
515	Log(("usb-proxy: edited out %d interface(s).\n", cRemoved));
516	}
517
518
519	/**
520	* @copydoc PDMUSBREG::pfnUsbReset
521	*
522	* USB Device Proxy: Call OS specific code to reset the device.
523	*/
524	static DECLCALLBACK(int) usbProxyDevReset(PPDMUSBINS pUsbIns, bool fResetOnLinux)
525	{
526	PUSBPROXYDEV pProxyDev = PDMINS_2_DATA(pUsbIns, PUSBPROXYDEV);
527
528	if (pProxyDev->fMaskedIfs)
529	{
530	Log(("usbProxyDevReset: pProxyDev=%s - ignoring reset request fMaskedIfs=%#x\n", pUsbIns->pszName, pProxyDev->fMaskedIfs));
531	return VINF_SUCCESS;
532	}
533	LogFlow(("usbProxyDevReset: pProxyDev=%s\n", pUsbIns->pszName));
534	return pProxyDev->pOps->pfnReset(pProxyDev, fResetOnLinux);
535	}
536
537
538	/**
539	* @copydoc PDMUSBREG::pfnUsbGetDescriptorCache
540	*/
541	static DECLCALLBACK(PCPDMUSBDESCCACHE) usbProxyDevGetDescriptorCache(PPDMUSBINS pUsbIns)
542	{
543	PUSBPROXYDEV pThis = PDMINS_2_DATA(pUsbIns, PUSBPROXYDEV);
544	return &pThis->DescCache;
545	}
546
547
548	/**
549	* @copydoc PDMUSBREG::pfnUsbSetConfiguration
550	*
551	* USB Device Proxy: Release claimed interfaces, tell the OS+device about the config change, claim the new interfaces.
552	*/
553	static DECLCALLBACK(int) usbProxyDevSetConfiguration(PPDMUSBINS pUsbIns, uint8_t bConfigurationValue,
554	const void pvOldCfgDesc, const void pvOldIfState, const void *pvNewCfgDesc)
555	{
556	PUSBPROXYDEV pProxyDev = PDMINS_2_DATA(pUsbIns, PUSBPROXYDEV);
557	LogFlow(("usbProxyDevSetConfiguration: pProxyDev=%s iActiveCfg=%d bConfigurationValue=%d\n",
558	pUsbIns->pszName, pProxyDev->iActiveCfg, bConfigurationValue));
559
560	/*
561	* Release the current config.
562	*/
563	if (pvOldCfgDesc)
564	{
565	PCVUSBDESCCONFIGEX pOldCfgDesc = (PCVUSBDESCCONFIGEX)pvOldCfgDesc;
566	PCVUSBINTERFACESTATE pOldIfState = (PCVUSBINTERFACESTATE)pvOldIfState;
567	for (unsigned i = 0; i < pOldCfgDesc->Core.bNumInterfaces; i++)
568	if (pOldIfState[i].pCurIfDesc)
569	pProxyDev->pOps->pfnReleaseInterface(pProxyDev, pOldIfState[i].pCurIfDesc->Core.bInterfaceNumber);
570	}
571
572	/*
573	* Do the actual SET_CONFIGURE.
574	* The mess here is because most backends will already have selected a
575	* configuration and there are a bunch of devices which will freak out
576	* if we do SET_CONFIGURE twice with the same value. (PalmOne, TrekStor USB-StickGO, ..)
577	*
578	* After open and reset the backend should use the members iActiveCfg and cIgnoreSetConfigs
579	* to indicate the new configuration state and what to do on the next SET_CONFIGURATION call.
580	*/
581	if ( pProxyDev->iActiveCfg != bConfigurationValue
582	\|\| ( bConfigurationValue == 0
583	&& pProxyDev->iActiveCfg != -1 /* this test doesn't make sense, we know it's 0 */
584	&& pProxyDev->cIgnoreSetConfigs >= 2)
585	\|\| !pProxyDev->cIgnoreSetConfigs)
586	{
587	pProxyDev->cIgnoreSetConfigs = 0;
588	if (!pProxyDev->pOps->pfnSetConfig(pProxyDev, bConfigurationValue))
589	{
590	pProxyDev->iActiveCfg = -1;
591	return VERR_GENERAL_FAILURE;
592	}
593	pProxyDev->iActiveCfg = bConfigurationValue;
594	}
595	else if (pProxyDev->cIgnoreSetConfigs > 0)
596	pProxyDev->cIgnoreSetConfigs--;
597
598	/*
599	* Claim the interfaces.
600	*/
601	PCVUSBDESCCONFIGEX pNewCfgDesc = (PCVUSBDESCCONFIGEX)pvNewCfgDesc;
602	Assert(pNewCfgDesc->Core.bConfigurationValue == bConfigurationValue);
603	for (unsigned iIf = 0; iIf < pNewCfgDesc->Core.bNumInterfaces; iIf++)
604	{
605	PCVUSBINTERFACE pIf = &pNewCfgDesc->paIfs[iIf];
606	for (uint32_t iAlt = 0; iAlt < pIf->cSettings; iAlt++)
607	{
608	if (pIf->paSettings[iAlt].Core.bAlternateSetting != 0)
609	continue;
610	pProxyDev->pOps->pfnClaimInterface(pProxyDev, pIf->paSettings[iAlt].Core.bInterfaceNumber);
611	/* ignore failures - the backend deals with that and does the necessary logging. */
612	break;
613	}
614	}
615
616	return VINF_SUCCESS;
617	}
618
619
620	/**
621	* @copydoc PDMUSBREG::pfnUsbSetInterface
622	*
623	* USB Device Proxy: Call OS specific code to select alternate interface settings.
624	*/
625	static DECLCALLBACK(int) usbProxyDevSetInterface(PPDMUSBINS pUsbIns, uint8_t bInterfaceNumber, uint8_t bAlternateSetting)
626	{
627	PUSBPROXYDEV pProxyDev = PDMINS_2_DATA(pUsbIns, PUSBPROXYDEV);
628	LogFlow(("usbProxyDevSetInterface: pProxyDev=%s bInterfaceNumber=%d bAlternateSetting=%d\n",
629	pUsbIns->pszName, bInterfaceNumber, bAlternateSetting));
630
631	/** @todo this is fishy, pfnSetInterface returns true/false from what I can see... */
632	if (pProxyDev->pOps->pfnSetInterface(pProxyDev, bInterfaceNumber, bAlternateSetting) < 0)
633	return VERR_GENERAL_FAILURE;
634	return VINF_SUCCESS;
635	}
636
637
638	/**
639	* @copydoc PDMUSBREG::pfnUsbClearHaltedEndpoint
640	*
641	* USB Device Proxy: Call OS specific code to clear the endpoint.
642	*/
643	static DECLCALLBACK(int) usbProxyDevClearHaltedEndpoint(PPDMUSBINS pUsbIns, unsigned uEndpoint)
644	{
645	PUSBPROXYDEV pProxyDev = PDMINS_2_DATA(pUsbIns, PUSBPROXYDEV);
646	LogFlow(("usbProxyDevClearHaltedEndpoint: pProxyDev=%s uEndpoint=%u\n",
647	pUsbIns->pszName, uEndpoint));
648
649	if (!pProxyDev->pOps->pfnClearHaltedEndpoint(pProxyDev, uEndpoint))
650	return VERR_GENERAL_FAILURE;
651	return VINF_SUCCESS;
652	}
653
654
655	/**
656	* @copydoc PDMUSBREG::pfnUrbQueue
657	*
658	* USB Device Proxy: Call OS specific code.
659	*/
660	static DECLCALLBACK(int) usbProxyDevUrbQueue(PPDMUSBINS pUsbIns, PVUSBURB pUrb)
661	{
662	PUSBPROXYDEV pProxyDev = PDMINS_2_DATA(pUsbIns, PUSBPROXYDEV);
663	if (!pProxyDev->pOps->pfnUrbQueue(pUrb))
664	return pProxyDev->fDetached
665	? VERR_VUSB_DEVICE_NOT_ATTACHED
666	: VERR_VUSB_FAILED_TO_QUEUE_URB;
667	return VINF_SUCCESS;
668	}
669
670
671	/**
672	* @copydoc PDMUSBREG::pfnUrbCancel
673	*
674	* USB Device Proxy: Call OS specific code.
675	*/
676	static DECLCALLBACK(int) usbProxyDevUrbCancel(PPDMUSBINS pUsbIns, PVUSBURB pUrb)
677	{
678	PUSBPROXYDEV pProxyDev = PDMINS_2_DATA(pUsbIns, PUSBPROXYDEV);
679	pProxyDev->pOps->pfnUrbCancel(pUrb);
680	return VINF_SUCCESS;
681	}
682
683
684	/**
685	* @copydoc PDMUSBREG::pfnUrbReap
686	*
687	* USB Device Proxy: Call OS specific code.
688	*/
689	static DECLCALLBACK(PVUSBURB) usbProxyDevUrbReap(PPDMUSBINS pUsbIns, RTMSINTERVAL cMillies)
690	{
691	PUSBPROXYDEV pProxyDev = PDMINS_2_DATA(pUsbIns, PUSBPROXYDEV);
692	PVUSBURB pUrb = pProxyDev->pOps->pfnUrbReap(pProxyDev, cMillies);
693	if ( pUrb
694	&& pUrb->enmState == VUSBURBSTATE_CANCELLED
695	&& pUrb->enmStatus == VUSBSTATUS_OK)
696	pUrb->enmStatus = VUSBSTATUS_DNR;
697	return pUrb;
698	}
699
700
701	/** @copydoc PDMUSBREG::pfnDestruct */
702	static DECLCALLBACK(void) usbProxyDestruct(PPDMUSBINS pUsbIns)
703	{
704	PUSBPROXYDEV pThis = PDMINS_2_DATA(pUsbIns, PUSBPROXYDEV);
705	Log(("usbProxyDestruct: destroying pProxyDev=%s\n", pUsbIns->pszName));
706
707	/* close it. */
708	if (pThis->fOpened)
709	{
710	pThis->pOps->pfnClose(pThis);
711	pThis->fOpened = false;
712	}
713
714	/* free the config descriptors. */
715	if (pThis->paCfgDescs)
716	{
717	for (unsigned i = 0; i < pThis->DevDesc.bNumConfigurations; i++)
718	{
719	RTMemFree((void *)pThis->paCfgDescs[i].paIfs);
720	RTMemFree((void *)pThis->paCfgDescs[i].pvOriginal);
721	}
722	RTMemFree(pThis->paCfgDescs);
723	pThis->paCfgDescs = NULL;
724	}
725
726	/* free dev */
727	if (&g_szDummyName[0] != pUsbIns->pszName)
728	RTStrFree(pUsbIns->pszName);
729	pUsbIns->pszName = NULL;
730	}
731
732
733	/**
734	* Helper function used by usbProxyConstruct when
735	* reading a filter from CFG.
736	*
737	* @returns VBox status code.
738	* @param pFilter The filter.
739	* @param enmFieldIdx The filter field indext.
740	* @param pNode The CFGM node.
741	* @param pszExact The exact value name.
742	* @param pszExpr The expression value name.
743	*/
744	static int usbProxyQueryNum(PUSBFILTER pFilter, USBFILTERIDX enmFieldIdx, PCFGMNODE pNode, const char pszExact, const char pszExpr)
745	{
746	char szTmp[256];
747
748	/* try exact first */
749	uint16_t u16;
750	int rc = CFGMR3QueryU16(pNode, pszExact, &u16);
751	if (RT_SUCCESS(rc))
752	{
753	rc = USBFilterSetNumExact(pFilter, enmFieldIdx, u16, true);
754	AssertRCReturn(rc, rc);
755
756	/* make sure only the exact attribute is present. */
757	rc = CFGMR3QueryString(pNode, pszExpr, szTmp, sizeof(szTmp));
758	if (RT_UNLIKELY(rc != VERR_CFGM_VALUE_NOT_FOUND))
759	{
760	szTmp[0] = '\0';
761	CFGMR3GetName(pNode, szTmp, sizeof(szTmp));
762	LogRel(("usbProxyConstruct: %s: Both %s and %s are present!\n", szTmp, pszExact, pszExpr));
763	return VERR_INVALID_PARAMETER;
764	}
765	return VINF_SUCCESS;
766	}
767	if (RT_UNLIKELY(rc != VERR_CFGM_VALUE_NOT_FOUND))
768	{
769	szTmp[0] = '\0';
770	CFGMR3GetName(pNode, szTmp, sizeof(szTmp));
771	LogRel(("usbProxyConstruct: %s: %s query failed, rc=%Rrc\n", szTmp, pszExact, rc));
772	return rc;
773	}
774
775	/* expression? */
776	rc = CFGMR3QueryString(pNode, pszExpr, szTmp, sizeof(szTmp));
777	if (RT_SUCCESS(rc))
778	{
779	rc = USBFilterSetNumExpression(pFilter, enmFieldIdx, szTmp, true);
780	AssertRCReturn(rc, rc);
781	return VINF_SUCCESS;
782	}
783	if (RT_UNLIKELY(rc != VERR_CFGM_VALUE_NOT_FOUND))
784	{
785	szTmp[0] = '\0';
786	CFGMR3GetName(pNode, szTmp, sizeof(szTmp));
787	LogRel(("usbProxyConstruct: %s: %s query failed, rc=%Rrc\n", szTmp, pszExpr, rc));
788	return rc;
789	}
790
791	return VINF_SUCCESS;
792	}
793
794
795	/** @copydoc PDMUSBREG::pfnConstruct */
796	static DECLCALLBACK(int) usbProxyConstruct(PPDMUSBINS pUsbIns, int iInstance, PCFGMNODE pCfg, PCFGMNODE pCfgGlobal)
797	{
798	PUSBPROXYDEV pThis = PDMINS_2_DATA(pUsbIns, PUSBPROXYDEV);
799	LogFlow(("usbProxyConstruct: pUsbIns=%p iInstance=%d\n", pUsbIns, iInstance));
800
801	/*
802	* Initialize the instance data.
803	*/
804	pThis->pUsbIns = pUsbIns;
805	pThis->pUsbIns->pszName = g_szDummyName;
806	pThis->iActiveCfg = -1;
807	pThis->fMaskedIfs = 0;
808	pThis->fOpened = false;
809	pThis->fInited = false;
810
811	/*
812	* Read the basic configuration.
813	*/
814	char szAddress[1024];
815	int rc = CFGMR3QueryString(pCfg, "Address", szAddress, sizeof(szAddress));
816	AssertRCReturn(rc, rc);
817
818	bool fRemote;
819	rc = CFGMR3QueryBool(pCfg, "Remote", &fRemote);
820	AssertRCReturn(rc, rc);
821
822	void *pvBackend;
823	rc = CFGMR3QueryPtr(pCfg, "pvBackend", &pvBackend);
824	AssertRCReturn(rc, rc);
825
826	/*
827	* Select backend and open the device.
828	*/
829	if (!fRemote)
830	pThis->pOps = &g_USBProxyDeviceHost;
831	else
832	pThis->pOps = &g_USBProxyDeviceVRDP;
833	rc = pThis->pOps->pfnOpen(pThis, szAddress, pvBackend);
834	if (RT_FAILURE(rc))
835	return rc;
836	pThis->fOpened = true;
837
838	/*
839	* Get the device descriptor and format the device name (for logging).
840	*/
841	if (!usbProxyGetDeviceDesc(pThis, &pThis->DevDesc))
842	{
843	Log(("usbProxyConstruct: usbProxyGetDeviceDesc failed\n"));
844	return VERR_READ_ERROR;
845	}
846
847	RTStrAPrintf(&pUsbIns->pszName, "%p[proxy %04x:%04x]", pThis, pThis->DevDesc.idVendor, pThis->DevDesc.idProduct); /** @todo append the user comment */
848	AssertReturn(pUsbIns->pszName, VERR_NO_MEMORY);
849
850	/*
851	* Get config descriptors.
852	*/
853	size_t cbConfigs = pThis->DevDesc.bNumConfigurations * sizeof(pThis->paCfgDescs[0]);
854	pThis->paCfgDescs = (PVUSBDESCCONFIGEX)RTMemAllocZ(cbConfigs);
855	AssertReturn(pThis->paCfgDescs, VERR_NO_MEMORY);
856
857	unsigned i;
858	for (i = 0; i < pThis->DevDesc.bNumConfigurations; i++)
859	if (!copy_config(pThis, i, (PVUSBDESCCONFIGEX)&pThis->paCfgDescs[i]))
860	break;
861	if (i < pThis->DevDesc.bNumConfigurations)
862	{
863	Log(("usbProxyConstruct: copy_config failed, i=%d\n", i));
864	return VERR_READ_ERROR;
865	}
866
867	/*
868	* Pickup best matching global configuration for this device.
869	* The global configuration is organized like this:
870	*
871	* GlobalConfig/Whatever/
872	* \|- idVendor = 300
873	* \|- idProduct = 300
874	* - Config/
875	*
876	* The first level contains filter attributes which we stuff into a USBFILTER
877	* structure and match against the device info that's available. The highest
878	* ranked match is will be used. If nothing is found, the values will be
879	* queried from the GlobalConfig node (simplifies code and might actually
880	* be useful).
881	*/
882	PCFGMNODE pCfgGlobalDev = pCfgGlobal;
883	PCFGMNODE pCur = CFGMR3GetFirstChild(pCfgGlobal);
884	if (pCur)
885	{
886	/*
887	* Create a device filter from the device configuration
888	* descriptor ++. No strings currently.
889	*/
890	USBFILTER Device;
891	USBFilterInit(&Device, USBFILTERTYPE_CAPTURE);
892	rc = USBFilterSetNumExact(&Device, USBFILTERIDX_VENDOR_ID, pThis->DevDesc.idVendor, true); AssertRC(rc);
893	rc = USBFilterSetNumExact(&Device, USBFILTERIDX_PRODUCT_ID, pThis->DevDesc.idProduct, true); AssertRC(rc);
894	rc = USBFilterSetNumExact(&Device, USBFILTERIDX_DEVICE_REV, pThis->DevDesc.bcdDevice, true); AssertRC(rc);
895	rc = USBFilterSetNumExact(&Device, USBFILTERIDX_DEVICE_CLASS, pThis->DevDesc.bDeviceClass, true); AssertRC(rc);
896	rc = USBFilterSetNumExact(&Device, USBFILTERIDX_DEVICE_SUB_CLASS, pThis->DevDesc.bDeviceSubClass, true); AssertRC(rc);
897	rc = USBFilterSetNumExact(&Device, USBFILTERIDX_DEVICE_PROTOCOL, pThis->DevDesc.bDeviceProtocol, true); AssertRC(rc);
898	/** @todo manufacturer, product and serial strings */
899
900	int iBestMatchRate = -1;
901	PCFGMNODE pBestMatch = NULL;
902	for (pCur = CFGMR3GetFirstChild(pCfgGlobal); pCur; pCur = CFGMR3GetNextChild(pCur))
903	{
904	/*
905	* Construct a filter from the attributes in the node.
906	*/
907	USBFILTER Filter;
908	USBFilterInit(&Filter, USBFILTERTYPE_CAPTURE);
909
910	/* numeric */
911	if ( RT_FAILURE(usbProxyQueryNum(&Filter, USBFILTERIDX_VENDOR_ID, pCur, "idVendor", "idVendorExpr"))
912	\|\| RT_FAILURE(usbProxyQueryNum(&Filter, USBFILTERIDX_PRODUCT_ID, pCur, "idProduct", "idProcutExpr"))
913	\|\| RT_FAILURE(usbProxyQueryNum(&Filter, USBFILTERIDX_DEVICE_REV, pCur, "bcdDevice", "bcdDeviceExpr"))
914	\|\| RT_FAILURE(usbProxyQueryNum(&Filter, USBFILTERIDX_DEVICE_CLASS, pCur, "bDeviceClass", "bDeviceClassExpr"))
915	\|\| RT_FAILURE(usbProxyQueryNum(&Filter, USBFILTERIDX_DEVICE_SUB_CLASS, pCur, "bDeviceSubClass", "bDeviceSubClassExpr"))
916	\|\| RT_FAILURE(usbProxyQueryNum(&Filter, USBFILTERIDX_DEVICE_PROTOCOL, pCur, "bDeviceProtocol", "bDeviceProtocolExpr")))
917	continue; /* skip it */
918
919	/* strings */
920	/** @todo manufacturer, product and serial strings */
921
922	/* ignore unknown config values, but not without bitching. */
923	if (!CFGMR3AreValuesValid(pCur,
924	"idVendor\0idVendorExpr\0"
925	"idProduct\0idProductExpr\0"
926	"bcdDevice\0bcdDeviceExpr\0"
927	"bDeviceClass\0bDeviceClassExpr\0"
928	"bDeviceSubClass\0bDeviceSubClassExpr\0"
929	"bDeviceProtocol\0bDeviceProtocolExpr\0"))
930	LogRel(("usbProxyConstruct: Unknown value(s) in config filter (ignored)!\n"));
931
932	/*
933	* Try match it and on match see if it has is a higher rate hit
934	* than the previous match. Quit if its a 100% match.
935	*/
936	int iRate = USBFilterMatchRated(&Filter, &Device);
937	if (iRate > iBestMatchRate)
938	{
939	pBestMatch = pCur;
940	iBestMatchRate = iRate;
941	if (iRate >= 100)
942	break;
943	}
944	}
945	if (pBestMatch)
946	pCfgGlobalDev = CFGMR3GetChild(pBestMatch, "Config");
947	if (pCfgGlobalDev)
948	pCfgGlobalDev = pCfgGlobal;
949	}
950
951	/*
952	* Query the rest of the configuration using the global as fallback.
953	*/
954	rc = CFGMR3QueryU32(pCfg, "MaskedIfs", &pThis->fMaskedIfs);
955	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
956	rc = CFGMR3QueryU32(pCfgGlobalDev, "MaskedIfs", &pThis->fMaskedIfs);
957	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
958	pThis->fMaskedIfs = 0;
959	else
960	AssertRCReturn(rc, rc);
961
962	bool fForce11Device;
963	rc = CFGMR3QueryBool(pCfg, "Force11Device", &fForce11Device);
964	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
965	rc = CFGMR3QueryBool(pCfgGlobalDev, "Force11Device", &fForce11Device);
966	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
967	fForce11Device = false;
968	else
969	AssertRCReturn(rc, rc);
970
971	bool fForce11PacketSize;
972	rc = CFGMR3QueryBool(pCfg, "Force11PacketSize", &fForce11PacketSize);
973	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
974	rc = CFGMR3QueryBool(pCfgGlobalDev, "Force11PacketSize", &fForce11PacketSize);
975	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
976	fForce11PacketSize = false;
977	else
978	AssertRCReturn(rc, rc);
979
980	/*
981	* If we're masking interfaces, edit the descriptors.
982	*/
983	bool fEdited = pThis->fMaskedIfs != 0;
984	if (pThis->fMaskedIfs)
985	usbProxyDevEditOutMaskedIfs(pThis);
986
987	/*
988	* Do 2.0 -> 1.1 device edits if requested to do so.
989	*/
990	if ( fForce11PacketSize
991	&& pThis->DevDesc.bcdUSB >= 0x0200)
992	{
993	PVUSBDESCCONFIGEX paCfgs = pThis->paCfgDescs;
994	for (unsigned iCfg = 0; iCfg < pThis->DevDesc.bNumConfigurations; iCfg++)
995	{
996	PVUSBINTERFACE paIfs = (PVUSBINTERFACE)paCfgs[iCfg].paIfs;
997	for (unsigned iIf = 0; iIf < paCfgs[iCfg].Core.bNumInterfaces; iIf++)
998	for (uint32_t iAlt = 0; iAlt < paIfs[iIf].cSettings; iAlt++)
999	{
1000	/*
1001	* USB 1.1 defines the max for control, interrupt and bulk to be 64 bytes.
1002	* While isochronous has a max of 1023 bytes.
1003	*/
1004	PVUSBDESCENDPOINTEX paEps = (PVUSBDESCENDPOINTEX)paIfs[iIf].paSettings[iAlt].paEndpoints;
1005	for (unsigned iEp = 0; iEp < paIfs[iIf].paSettings[iAlt].Core.bNumEndpoints; iEp++)
1006	{
1007	const uint16_t cbMax = (paEps[iEp].Core.bmAttributes & 3) == 1 /* isoc */
1008	? 1023
1009	: 64;
1010	if (paEps[iEp].Core.wMaxPacketSize > cbMax)
1011	{
1012	Log(("usb-proxy: pProxyDev=%s correcting wMaxPacketSize from %#x to %#x (mainly for vista)\n",
1013	pUsbIns->pszName, paEps[iEp].Core.wMaxPacketSize, cbMax));
1014	paEps[iEp].Core.wMaxPacketSize = cbMax;
1015	fEdited = true;
1016	}
1017	}
1018	}
1019	}
1020	}
1021
1022	if ( fForce11Device
1023	&& pThis->DevDesc.bcdUSB == 0x0200)
1024	{
1025	/*
1026	* Discourages windows from helping you find a 2.0 port.
1027	*/
1028	Log(("usb-proxy: %s correcting USB version 2.0 to 1.1 (to avoid Windows warning)\n", pUsbIns->pszName));
1029	pThis->DevDesc.bcdUSB = 0x110;
1030	fEdited = true;
1031	}
1032
1033
1034	/*
1035	* Init the PDM/VUSB descriptor cache.
1036	*/
1037	pThis->DescCache.pDevice = &pThis->DevDesc;
1038	pThis->DescCache.paConfigs = pThis->paCfgDescs;
1039	pThis->DescCache.paLanguages = NULL;
1040	pThis->DescCache.cLanguages = 0;
1041	pThis->DescCache.fUseCachedDescriptors = fEdited;
1042	pThis->DescCache.fUseCachedStringsDescriptors = false;
1043
1044	/*
1045	* Call the backend if it wishes to do some more initializing
1046	* after we've read the config and descriptors.
1047	*/
1048	if (pThis->pOps->pfnInit)
1049	{
1050	rc = pThis->pOps->pfnInit(pThis);
1051	if (RT_FAILURE(rc))
1052	return rc;
1053	}
1054	pThis->fInited = true;
1055
1056	/*
1057	* We're good!
1058	*/
1059	Log(("usb-proxy: created pProxyDev=%s address '%s' fMaskedIfs=%#x (rc=%Rrc)\n",
1060	pUsbIns->pszName, szAddress, pThis->fMaskedIfs, rc));
1061	return VINF_SUCCESS;
1062	}
1063
1064
1065	/**
1066	* The USB proxy device registration record.
1067	*/
1068	const PDMUSBREG g_UsbDevProxy =
1069	{
1070	/* u32Version */
1071	PDM_USBREG_VERSION,
1072	/* szName */
1073	"USBProxy",
1074	/* pszDescription */
1075	"USB Proxy Device.",
1076	/* fFlags */
1077	0,
1078	/* cMaxInstances */
1079	~0U,
1080	/* cbInstance */
1081	sizeof(USBPROXYDEV),
1082	/* pfnConstruct */
1083	usbProxyConstruct,
1084	/* pfnDestruct */
1085	usbProxyDestruct,
1086	/* pfnVMInitComplete */
1087	NULL,
1088	/* pfnVMPowerOn */
1089	NULL,
1090	/* pfnVMReset */
1091	NULL,
1092	/* pfnVMSuspend */
1093	NULL,
1094	/* pfnVMResume */
1095	NULL,
1096	/* pfnVMPowerOff */
1097	NULL,
1098	/* pfnHotPlugged */
1099	NULL,
1100	/* pfnHotUnplugged */
1101	NULL,
1102	/* pfnDriverAttach */
1103	NULL,
1104	/* pfnDriverDetach */
1105	NULL,
1106	/* pfnQueryInterface */
1107	NULL,
1108	/* pfnUsbReset */
1109	usbProxyDevReset,
1110	/* pfnUsbGetDescriptorCache */
1111	usbProxyDevGetDescriptorCache,
1112	/* pfnUsbSetConfiguration */
1113	usbProxyDevSetConfiguration,
1114	/* pfnUsbSetInterface */
1115	usbProxyDevSetInterface,
1116	/* pfnUsbClearHaltedEndpoint */
1117	usbProxyDevClearHaltedEndpoint,
1118	/* pfnUrbNew */
1119	NULL,
1120	/* pfnUrbQueue */
1121	usbProxyDevUrbQueue,
1122	/* pfnUrbCancel */
1123	usbProxyDevUrbCancel,
1124	/* pfnUrbReap */
1125	usbProxyDevUrbReap,
1126
1127	/* u32TheEnd */
1128	PDM_USBREG_VERSION
1129	};
1130

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

source: vbox/trunk/src/VBox/Devices/USB/USBProxyDevice.cpp@ 42401

Download in other formats: