USBProxyDevice-win.cpp@ 49890

Last change on this file since 49890 was 49814, checked in by vboxsync, 11 years ago
Devices/USB: First part of the rework, move most of the work to dedicated threads to improve performance
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 27.0 KB

Line
1	/* $Id: USBProxyDevice-win.cpp 49814 2013-12-06 21:38:28Z vboxsync $ */
2	/** @file
3	* USBPROXY - USB proxy, Win32 backend
4	*
5	* NOTE: This code assumes only one thread will use it at a time!!
6	* bird: usbProxyWinReset() will be called in a separate thread because it
7	* will usually take >=10ms. So, the assumption is broken.
8	*/
9
10	/*
11	* Copyright (C) 2006-2011 Oracle Corporation
12	*
13	* This file is part of VirtualBox Open Source Edition (OSE), as
14	* available from http://www.virtualbox.org. This file is free software;
15	* you can redistribute it and/or modify it under the terms of the GNU
16	* General Public License (GPL) as published by the Free Software
17	* Foundation, in version 2 as it comes in the "COPYING" file of the
18	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
19	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
20	*/
21
22
23	/*******************************************************************************
24	* Header Files *
25	*******************************************************************************/
26	#define LOG_GROUP LOG_GROUP_DRV_USBPROXY
27	#include <windows.h>
28
29	#include <VBox/vmm/pdm.h>
30	#include <VBox/err.h>
31	#include <VBox/usb.h>
32	#include <VBox/log.h>
33	#include <iprt/assert.h>
34	#include <iprt/alloc.h>
35	#include <iprt/err.h>
36	#include <iprt/string.h>
37	#include <iprt/thread.h>
38	#include <iprt/asm.h>
39	#include "../USBProxyDevice.h"
40	#include <VBox/usblib.h>
41
42
43	/*******************************************************************************
44	* Structures and Typedefs *
45	*******************************************************************************/
46	typedef struct _QUEUED_URB
47	{
48	PVUSBURB urb;
49
50	USBSUP_URB urbwin;
51	OVERLAPPED overlapped;
52	DWORD cbReturned;
53	bool fCancelled;
54	} QUEUED_URB, *PQUEUED_URB;
55
56	typedef struct
57	{
58	/* Critical section to protect this structure. */
59	RTCRITSECT CritSect;
60	HANDLE hDev;
61	uint8_t bInterfaceNumber;
62	bool fClaimed;
63	/** The allocated size of paHandles and paQueuedUrbs. */
64	unsigned cAllocatedUrbs;
65	/** The number of URBs in the array. */
66	unsigned cQueuedUrbs;
67	/** Array of pointers to the in-flight URB structures. */
68	PQUEUED_URB *paQueuedUrbs;
69	/** Array of handles, this is parallel to paQueuedUrbs. */
70	PHANDLE paHandles;
71	/* Event sempahore to wakeup the reaper thead. */
72	HANDLE hEventWakeup;
73	/** Number of queued URBs waiting to get into the handle list. */
74	unsigned cPendingUrbs;
75	/** Array of pending URBs. */
76	PQUEUED_URB aPendingUrbs[64];
77	} PRIV_USBW32, *PPRIV_USBW32;
78
79	/* All functions are returning 1 on success, 0 on error */
80
81	/*******************************************************************************
82	* Internal Functions *
83	*******************************************************************************/
84	static int usbProxyWinSetInterface(PUSBPROXYDEV p, int ifnum, int setting);
85	static DECLCALLBACK(int) usbProxyWinAsyncIoThread(RTTHREAD ThreadSelf, void *lpParameter);
86
87	/**
88	* Open a USB device and create a backend instance for it.
89	*
90	* @returns VBox status code.
91	*/
92	static int usbProxyWinOpen(PUSBPROXYDEV pProxyDev, const char pszAddress, void pvBackend)
93	{
94	/* Here you just need to use pProxyDev->priv to store whatever per-device
95	* data is needed
96	*/
97	/*
98	* Allocate private device instance data and use USBPROXYDEV::Backend::pv to point to it.
99	*/
100	PPRIV_USBW32 pPriv = (PPRIV_USBW32)RTMemAllocZ(sizeof(PRIV_USBW32));
101	if (!pPriv)
102	return VERR_NO_MEMORY;
103	pProxyDev->Backend.pv = pPriv;
104
105	int rc = VINF_SUCCESS;
106	pPriv->cAllocatedUrbs = 32;
107	pPriv->paHandles = (PHANDLE)RTMemAllocZ(sizeof(pPriv->paHandles[0]) * pPriv->cAllocatedUrbs);
108	pPriv->paQueuedUrbs = (PQUEUED_URB )RTMemAllocZ(sizeof(pPriv->paQueuedUrbs[0]) pPriv->cAllocatedUrbs);
109	if ( pPriv->paQueuedUrbs
110	&& pPriv->paHandles)
111	{
112	/*
113	* Open the device.
114	*/
115	pPriv->hDev = CreateFile(pszAddress,
116	GENERIC_READ \| GENERIC_WRITE,
117	FILE_SHARE_WRITE \| FILE_SHARE_READ,
118	NULL, // no SECURITY_ATTRIBUTES structure
119	OPEN_EXISTING, // No special create flags
120	FILE_ATTRIBUTE_SYSTEM \| FILE_FLAG_OVERLAPPED, // overlapped IO
121	NULL); // No template file
122	if (pPriv->hDev != INVALID_HANDLE_VALUE)
123	{
124	Log(("usbProxyWinOpen: hDev=%p\n", pPriv->hDev));
125
126	/*
127	* Check the version
128	*/
129	USBSUP_VERSION version = {0};
130	DWORD cbReturned = 0;
131	if (DeviceIoControl(pPriv->hDev, SUPUSB_IOCTL_GET_VERSION, NULL, 0, &version, sizeof(version), &cbReturned, NULL))
132	{
133	if (!( version.u32Major != USBDRV_MAJOR_VERSION
134	\|\| version.u32Minor < USBDRV_MINOR_VERSION))
135	{
136	USBSUP_CLAIMDEV in;
137	in.bInterfaceNumber = 0;
138
139	cbReturned = 0;
140	if (DeviceIoControl(pPriv->hDev, SUPUSB_IOCTL_USB_CLAIM_DEVICE, &in, sizeof(in), &in, sizeof(in), &cbReturned, NULL))
141	{
142	if (in.fClaimed)
143	{
144	pPriv->fClaimed = true;
145	#if 0 /** @todo this needs to be enabled if windows chooses a default config. Test with the TrekStor GO Stick. */
146	pProxyDev->iActiveCfg = 1;
147	pProxyDev->cIgnoreSetConfigs = 1;
148	#endif
149
150	rc = RTCritSectInit(&pPriv->CritSect);
151	AssertRC(rc);
152	pPriv->hEventWakeup = CreateEvent(NULL, FALSE, FALSE, NULL);
153	Assert(pPriv->hEventWakeup);
154
155	pPriv->paHandles[0] = pPriv->hEventWakeup;
156
157	return VINF_SUCCESS;
158	}
159
160	rc = VERR_GENERAL_FAILURE;
161	Log(("usbproxy: unable to claim device %x (%s)!!\n", pPriv->hDev, pszAddress));
162	}
163	}
164	else
165	{
166	rc = VERR_VERSION_MISMATCH;
167	Log(("usbproxy: Version mismatch: %d.%d != %d.%d (cur)\n",
168	version.u32Major, version.u32Minor, USBDRV_MAJOR_VERSION, USBDRV_MINOR_VERSION));
169	}
170	}
171
172	/* Convert last error if necessary */
173	if (RT_SUCCESS(rc))
174	{
175	DWORD dwErr = GetLastError();
176	Log(("usbproxy: last error %d\n", dwErr));
177	rc = RTErrConvertFromWin32(dwErr);
178	}
179
180	CloseHandle(pPriv->hDev);
181	pPriv->hDev = INVALID_HANDLE_VALUE;
182	}
183	else
184	{
185	Log(("usbproxy: FAILED to open '%s'! last error %d\n", pszAddress, GetLastError()));
186	rc = VERR_FILE_NOT_FOUND;
187	}
188	}
189	else
190	rc = VERR_NO_MEMORY;
191
192	RTMemFree(pPriv->paQueuedUrbs);
193	RTMemFree(pPriv->paHandles);
194	RTMemFree(pPriv);
195	pProxyDev->Backend.pv = NULL;
196	return rc;
197	}
198
199	/**
200	* Copy the device and free resources associated with the backend.
201	*/
202	static void usbProxyWinClose(PUSBPROXYDEV pProxyDev)
203	{
204	/* Here we just close the device and free up p->priv
205	* there is no need to do anything like cancel outstanding requests
206	* that will have been done already
207	*/
208	PPRIV_USBW32 pPriv = (PPRIV_USBW32)pProxyDev->Backend.pv;
209	Assert(pPriv);
210	if (!pPriv)
211	return;
212	Log(("usbProxyWinClose: %p\n", pPriv->hDev));
213
214	if (pPriv->hDev != INVALID_HANDLE_VALUE)
215	{
216	Assert(pPriv->fClaimed);
217
218	USBSUP_RELEASEDEV in;
219	DWORD cbReturned = 0;
220	in.bInterfaceNumber = pPriv->bInterfaceNumber;
221	if (!DeviceIoControl(pPriv->hDev, SUPUSB_IOCTL_USB_RELEASE_DEVICE, &in, sizeof(in), NULL, 0, &cbReturned, NULL))
222	{
223	Log(("usbproxy: usbProxyWinClose: DeviceIoControl %#x failed with %#x!!\n", pPriv->hDev, GetLastError()));
224	}
225	if (!CloseHandle(pPriv->hDev))
226	AssertLogRelMsgFailed(("usbproxy: usbProxyWinClose: CloseHandle %#x failed with %#x!!\n", pPriv->hDev, GetLastError()));
227	pPriv->hDev = INVALID_HANDLE_VALUE;
228	}
229
230	CloseHandle(pPriv->hEventWakeup);
231	RTCritSectDelete(&pPriv->CritSect);
232
233	RTMemFree(pPriv->paQueuedUrbs);
234	RTMemFree(pPriv->paHandles);
235	RTMemFree(pPriv);
236	pProxyDev->Backend.pv = NULL;
237	}
238
239
240	static int usbProxyWinReset(PUSBPROXYDEV pProxyDev, bool fResetOnLinux)
241	{
242	PPRIV_USBW32 pPriv = (PPRIV_USBW32)pProxyDev->Backend.pv;
243	DWORD cbReturned;
244	int rc;
245
246	Assert(pPriv);
247
248	Log(("usbproxy: Reset %x\n", pPriv->hDev));
249
250	/* Here we just need to assert reset signalling on the USB device */
251	cbReturned = 0;
252	if (DeviceIoControl(pPriv->hDev, SUPUSB_IOCTL_USB_RESET, NULL, 0, NULL, 0, &cbReturned, NULL))
253	{
254	#if 0 /** @todo this needs to be enabled if windows chooses a default config. Test with the TrekStor GO Stick. */
255	pProxyDev->iActiveCfg = 1;
256	pProxyDev->cIgnoreSetConfigs = 2;
257	#else
258	pProxyDev->iActiveCfg = -1;
259	pProxyDev->cIgnoreSetConfigs = 0;
260	#endif
261	return VINF_SUCCESS;
262	}
263
264	rc = GetLastError();
265	if (rc == ERROR_DEVICE_REMOVED)
266	{
267	Log(("usbproxy: device %p unplugged!!\n", pPriv->hDev));
268	pProxyDev->fDetached = true;
269	}
270	return RTErrConvertFromWin32(rc);
271	}
272
273	static int usbProxyWinSetConfig(PUSBPROXYDEV pProxyDev, int cfg)
274	{
275	/* Send a SET_CONFIGURATION command to the device. We don't do this
276	* as a normal control message, because the OS might not want to
277	* be left out of the loop on such a thing.
278	*
279	* It would be OK to send a SET_CONFIGURATION control URB at this
280	* point but it has to be synchronous.
281	*/
282	PPRIV_USBW32 pPriv = (PPRIV_USBW32)pProxyDev->Backend.pv;
283	USBSUP_SET_CONFIG in;
284	DWORD cbReturned;
285
286	Assert(pPriv);
287
288	Log(("usbproxy: Set config of %p to %d\n", pPriv->hDev, cfg));
289	in.bConfigurationValue = cfg;
290
291	/* Here we just need to assert reset signalling on the USB device */
292	cbReturned = 0;
293	if (DeviceIoControl(pPriv->hDev, SUPUSB_IOCTL_USB_SET_CONFIG, &in, sizeof(in), NULL, 0, &cbReturned, NULL))
294	return 1;
295
296	if ( GetLastError() == ERROR_INVALID_HANDLE_STATE
297	\|\| GetLastError() == ERROR_BAD_COMMAND)
298	{
299	Log(("usbproxy: device %p unplugged!!\n", pPriv->hDev));
300	pProxyDev->fDetached = true;
301	}
302	else
303	AssertMsgFailed(("lasterr=%u\n", GetLastError()));
304
305	return 0;
306	}
307
308	static int usbProxyWinClaimInterface(PUSBPROXYDEV p, int ifnum)
309	{
310	/* Called just before we use an interface. Needed on Linux to claim
311	* the interface from the OS, since even when proxying the host OS
312	* might want to allow other programs to use the unused interfaces.
313	* Not relevant for Windows.
314	*/
315	PPRIV_USBW32 pPriv = (PPRIV_USBW32)p->Backend.pv;
316
317	pPriv->bInterfaceNumber = ifnum;
318
319	Assert(pPriv);
320	return true;
321	}
322
323	static int usbProxyWinReleaseInterface(PUSBPROXYDEV p, int ifnum)
324	{
325	/* The opposite of claim_interface. */
326	PPRIV_USBW32 pPriv = (PPRIV_USBW32)p->Backend.pv;
327
328	Assert(pPriv);
329	return true;
330	}
331
332	static int usbProxyWinSetInterface(PUSBPROXYDEV pProxyDev, int ifnum, int setting)
333	{
334	/* Select an alternate setting for an interface, the same applies
335	* here as for set_config, you may convert this in to a control
336	* message if you want but it must be synchronous
337	*/
338	PPRIV_USBW32 pPriv = (PPRIV_USBW32)pProxyDev->Backend.pv;
339	USBSUP_SELECT_INTERFACE in;
340	DWORD cbReturned;
341
342	Assert(pPriv);
343
344	Log(("usbproxy: Select interface of %x to %d/%d\n", pPriv->hDev, ifnum, setting));
345	in.bInterfaceNumber = ifnum;
346	in.bAlternateSetting = setting;
347
348	/* Here we just need to assert reset signalling on the USB device */
349	cbReturned = 0;
350	if (DeviceIoControl(pPriv->hDev, SUPUSB_IOCTL_USB_SELECT_INTERFACE, &in, sizeof(in), NULL, 0, &cbReturned, NULL))
351	return true;
352
353	if ( GetLastError() == ERROR_INVALID_HANDLE_STATE
354	\|\| GetLastError() == ERROR_BAD_COMMAND)
355	{
356	Log(("usbproxy: device %x unplugged!!\n", pPriv->hDev));
357	pProxyDev->fDetached = true;
358	}
359	else
360	AssertMsgFailed(("lasterr=%d\n", GetLastError()));
361	return 0;
362	}
363
364	/**
365	* Clears the halted endpoint 'ep'.
366	*/
367	static bool usbProxyWinClearHaltedEndPt(PUSBPROXYDEV pProxyDev, unsigned int ep)
368	{
369	PPRIV_USBW32 pPriv = (PPRIV_USBW32)pProxyDev->Backend.pv;
370	USBSUP_CLEAR_ENDPOINT in;
371	DWORD cbReturned;
372
373	Assert(pPriv);
374
375	Log(("usbproxy: Clear endpoint %d of %x\n", ep, pPriv->hDev));
376	in.bEndpoint = ep;
377
378	cbReturned = 0;
379	if (DeviceIoControl(pPriv->hDev, SUPUSB_IOCTL_USB_CLEAR_ENDPOINT, &in, sizeof(in), NULL, 0, &cbReturned, NULL))
380	return true;
381
382	if ( GetLastError() == ERROR_INVALID_HANDLE_STATE
383	\|\| GetLastError() == ERROR_BAD_COMMAND)
384	{
385	Log(("usbproxy: device %x unplugged!!\n", pPriv->hDev));
386	pProxyDev->fDetached = true;
387	}
388	else
389	AssertMsgFailed(("lasterr=%d\n", GetLastError()));
390	return 0;
391	}
392
393	/**
394	* Aborts a pipe/endpoint (cancels all outstanding URBs on the endpoint).
395	*/
396	static int usbProxyWinAbortEndPt(PUSBPROXYDEV pProxyDev, unsigned int ep)
397	{
398	PPRIV_USBW32 pPriv = (PPRIV_USBW32)pProxyDev->Backend.pv;
399	USBSUP_CLEAR_ENDPOINT in;
400	DWORD cbReturned;
401	int rc;
402
403	Assert(pPriv);
404
405	Log(("usbproxy: Abort endpoint %d of %x\n", ep, pPriv->hDev));
406	in.bEndpoint = ep;
407
408	cbReturned = 0;
409	if (DeviceIoControl(pPriv->hDev, SUPUSB_IOCTL_USB_ABORT_ENDPOINT, &in, sizeof(in), NULL, 0, &cbReturned, NULL))
410	return VINF_SUCCESS;
411
412	rc = GetLastError();
413	if ( rc == ERROR_INVALID_HANDLE_STATE
414	\|\| rc == ERROR_BAD_COMMAND)
415	{
416	Log(("usbproxy: device %x unplugged!!\n", pPriv->hDev));
417	pProxyDev->fDetached = true;
418	}
419	else
420	AssertMsgFailed(("lasterr=%d\n", rc));
421	return RTErrConvertFromWin32(rc);
422	}
423
424	/**
425	* @copydoc USBPROXYBACK::pfnUrbQueue
426	*/
427	static int usbProxyWinUrbQueue(PVUSBURB pUrb)
428	{
429	PUSBPROXYDEV pProxyDev = PDMINS_2_DATA(pUrb->pUsbIns, PUSBPROXYDEV);
430	PPRIV_USBW32 pPriv = (PPRIV_USBW32)pProxyDev->Backend.pv;
431	Assert(pPriv);
432
433	/*
434	* Allocate and initialize a URB queue structure.
435	*/
436	/** @todo pool these */
437	PQUEUED_URB pQUrbWin = (PQUEUED_URB)RTMemAllocZ(sizeof(QUEUED_URB));
438	if (!pQUrbWin)
439	return false;
440
441	switch (pUrb->enmType)
442	{
443	case VUSBXFERTYPE_CTRL: pQUrbWin->urbwin.type = USBSUP_TRANSFER_TYPE_CTRL; break; /* you won't ever see these */
444	case VUSBXFERTYPE_ISOC: pQUrbWin->urbwin.type = USBSUP_TRANSFER_TYPE_ISOC;
445	pQUrbWin->urbwin.numIsoPkts = pUrb->cIsocPkts;
446	for (unsigned i = 0; i < pUrb->cIsocPkts; ++i)
447	{
448	pQUrbWin->urbwin.aIsoPkts[i].cb = pUrb->aIsocPkts[i].cb;
449	pQUrbWin->urbwin.aIsoPkts[i].off = pUrb->aIsocPkts[i].off;
450	pQUrbWin->urbwin.aIsoPkts[i].stat = USBSUP_XFER_OK;
451	}
452	break;
453	case VUSBXFERTYPE_BULK: pQUrbWin->urbwin.type = USBSUP_TRANSFER_TYPE_BULK; break;
454	case VUSBXFERTYPE_INTR: pQUrbWin->urbwin.type = USBSUP_TRANSFER_TYPE_INTR; break;
455	case VUSBXFERTYPE_MSG: pQUrbWin->urbwin.type = USBSUP_TRANSFER_TYPE_MSG; break;
456	default:
457	AssertMsgFailed(("Invalid type %d\n", pUrb->enmType));
458	return false;
459	}
460
461	switch (pUrb->enmDir)
462	{
463	case VUSBDIRECTION_SETUP:
464	AssertFailed();
465	pQUrbWin->urbwin.dir = USBSUP_DIRECTION_SETUP;
466	break;
467	case VUSBDIRECTION_IN:
468	pQUrbWin->urbwin.dir = USBSUP_DIRECTION_IN;
469	break;
470	case VUSBDIRECTION_OUT:
471	pQUrbWin->urbwin.dir = USBSUP_DIRECTION_OUT;
472	break;
473	default:
474	AssertMsgFailed(("Invalid direction %d\n", pUrb->enmDir));
475	return false;
476	}
477
478	Log(("usbproxy: Queue URB %p ep=%d cbData=%d abData=%p cIsocPkts=%d\n", pUrb, pUrb->EndPt, pUrb->cbData, pUrb->abData, pUrb->cIsocPkts));
479
480	pQUrbWin->urb = pUrb;
481	pQUrbWin->urbwin.ep = pUrb->EndPt;
482	pQUrbWin->urbwin.len = pUrb->cbData;
483	pQUrbWin->urbwin.buf = pUrb->abData;
484	pQUrbWin->urbwin.error = USBSUP_XFER_OK;
485	pQUrbWin->urbwin.flags = USBSUP_FLAG_NONE;
486	if (pUrb->enmDir == VUSBDIRECTION_IN && !pUrb->fShortNotOk)
487	pQUrbWin->urbwin.flags = USBSUP_FLAG_SHORT_OK;
488
489	pQUrbWin->overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
490	if (pQUrbWin->overlapped.hEvent != INVALID_HANDLE_VALUE)
491	{
492	pUrb->Dev.pvPrivate = pQUrbWin;
493
494	if ( DeviceIoControl(pPriv->hDev, SUPUSB_IOCTL_SEND_URB,
495	&pQUrbWin->urbwin, sizeof(pQUrbWin->urbwin),
496	&pQUrbWin->urbwin, sizeof(pQUrbWin->urbwin),
497	&pQUrbWin->cbReturned, &pQUrbWin->overlapped)
498	\|\| GetLastError() == ERROR_IO_PENDING)
499	{
500	/* insert into the queue */
501	RTCritSectEnter(&pPriv->CritSect);
502	unsigned j = pPriv->cPendingUrbs;
503	pPriv->aPendingUrbs[j] = pQUrbWin;
504	pPriv->cPendingUrbs++;
505	RTCritSectLeave(&pPriv->CritSect);
506	SetEvent(pPriv->hEventWakeup);
507	return true;
508	}
509	else
510	{
511	DWORD dwErr = GetLastError();
512	if ( dwErr == ERROR_INVALID_HANDLE_STATE
513	\|\| dwErr == ERROR_BAD_COMMAND)
514	{
515	PUSBPROXYDEV pProxyDev = PDMINS_2_DATA(pQUrbWin->urb->pUsbIns, PUSBPROXYDEV);
516	Log(("usbproxy: device %p unplugged!!\n", pPriv->hDev));
517	pProxyDev->fDetached = true;
518	}
519	else
520	AssertMsgFailed(("dwErr=%X urbwin.error=%d (submit urb)\n", dwErr, pQUrbWin->urbwin.error));
521	CloseHandle(pQUrbWin->overlapped.hEvent);
522	pQUrbWin->overlapped.hEvent = INVALID_HANDLE_VALUE;
523	}
524	}
525	#ifdef DEBUG_misha
526	else
527	{
528	AssertMsgFailed(("FAILED!!, hEvent(0x%p)\n", pQUrbWin->overlapped.hEvent));
529	}
530	#endif
531
532	Assert(pQUrbWin->overlapped.hEvent == INVALID_HANDLE_VALUE);
533	RTMemFree(pQUrbWin);
534	return false;
535	}
536
537	/**
538	* Convert Windows proxy URB status to VUSB status.
539	*
540	* @returns VUSB status constant.
541	* @param win_status Windows USB proxy status constant.
542	*/
543	static VUSBSTATUS usbProxyWinStatusToVUsbStatus(USBSUP_ERROR win_status)
544	{
545	VUSBSTATUS vusb_status;
546
547	switch (win_status)
548	{
549	case USBSUP_XFER_OK: vusb_status = VUSBSTATUS_OK; break;
550	case USBSUP_XFER_STALL: vusb_status = VUSBSTATUS_STALL; break;
551	case USBSUP_XFER_DNR: vusb_status = VUSBSTATUS_DNR; break;
552	case USBSUP_XFER_CRC: vusb_status = VUSBSTATUS_CRC; break;
553	case USBSUP_XFER_NAC: vusb_status = VUSBSTATUS_NOT_ACCESSED; break;
554	case USBSUP_XFER_UNDERRUN: vusb_status = VUSBSTATUS_DATA_UNDERRUN; break;
555	case USBSUP_XFER_OVERRUN: vusb_status = VUSBSTATUS_DATA_OVERRUN; break;
556	default:
557	AssertMsgFailed(("USB: Invalid error %d\n", win_status));
558	vusb_status = VUSBSTATUS_DNR;
559	break;
560	}
561	return vusb_status;
562	}
563
564	/**
565	* Reap URBs in-flight on a device.
566	*
567	* @returns Pointer to a completed URB.
568	* @returns NULL if no URB was completed.
569	* @param pProxyDev The device.
570	* @param cMillies Number of milliseconds to wait. Use 0 to not
571	* wait at all.
572	*/
573	static PVUSBURB usbProxyWinUrbReap(PUSBPROXYDEV pProxyDev, RTMSINTERVAL cMillies)
574	{
575	PPRIV_USBW32 pPriv = (PPRIV_USBW32)pProxyDev->Backend.pv;
576	AssertReturn(pPriv, NULL);
577
578	/*
579	* There are some unnecessary calls, just return immediately or
580	* WaitForMultipleObjects will fail.
581	*/
582	if ( pPriv->cQueuedUrbs <= 0
583	&& pPriv->cPendingUrbs == 0)
584	{
585	if ( cMillies != 0
586	&& pPriv->cPendingUrbs == 0)
587	{
588	/* Wait for the wakeup call. */
589	DWORD cMilliesWait = cMillies == RT_INDEFINITE_WAIT ? INFINITE : cMillies;
590	DWORD rc = WaitForMultipleObjects(1, &pPriv->hEventWakeup, FALSE, cMilliesWait);
591	}
592
593	return NULL;
594	}
595
596	again:
597	/* Check for pending URBs. */
598	if (pPriv->cPendingUrbs)
599	{
600	RTCritSectEnter(&pPriv->CritSect);
601
602	/* Ensure we've got sufficient space in the arrays.
603	* Do it inside the lock to ensure we do not concur
604	* with the usbProxyWinAsyncIoThread */
605	if (pPriv->cQueuedUrbs + pPriv->cPendingUrbs + 1 > pPriv->cAllocatedUrbs)
606	{
607	unsigned cNewMax = pPriv->cAllocatedUrbs + pPriv->cPendingUrbs + 1;
608	void pv = RTMemRealloc(pPriv->paHandles, sizeof(pPriv->paHandles[0]) (cNewMax + 1)); /* One extra for the wakeup event. */
609	if (!pv)
610	{
611	AssertMsgFailed(("RTMemRealloc failed for paHandles[%d]", cNewMax));
612	//break;
613	}
614	pPriv->paHandles = (PHANDLE)pv;
615
616	pv = RTMemRealloc(pPriv->paQueuedUrbs, sizeof(pPriv->paQueuedUrbs[0]) * cNewMax);
617	if (!pv)
618	{
619	AssertMsgFailed(("RTMemRealloc failed for paQueuedUrbs[%d]", cNewMax));
620	//break;
621	}
622	pPriv->paQueuedUrbs = (PQUEUED_URB *)pv;
623	pPriv->cAllocatedUrbs = cNewMax;
624	}
625
626	/* Copy the pending URBs over. */
627	for (unsigned i = 0; i < pPriv->cPendingUrbs; i++)
628	{
629	pPriv->paHandles[pPriv->cQueuedUrbs + i] = pPriv->aPendingUrbs[i]->overlapped.hEvent;
630	pPriv->paQueuedUrbs[pPriv->cQueuedUrbs + i] = pPriv->aPendingUrbs[i];
631	}
632	pPriv->cQueuedUrbs += pPriv->cPendingUrbs;
633	pPriv->cPendingUrbs = 0;
634	pPriv->paHandles[pPriv->cQueuedUrbs] = pPriv->hEventWakeup;
635	pPriv->paHandles[pPriv->cQueuedUrbs + 1] = INVALID_HANDLE_VALUE;
636
637	RTCritSectLeave(&pPriv->CritSect);
638	}
639
640	/*
641	* Wait/poll.
642	*
643	* ASSUMPTIONS:
644	* 1. The usbProxyWinUrbReap can not be run concurrently with each other
645	* so racing the cQueuedUrbs access/modification can not occur.
646	* 2. The usbProxyWinUrbReap can not be run concurrently with
647	* usbProxyWinUrbQueue so they can not race the pPriv->paHandles
648	* access/realloc.
649	*/
650	unsigned cQueuedUrbs = ASMAtomicReadU32((volatile uint32_t *)&pPriv->cQueuedUrbs);
651	DWORD cMilliesWait = cMillies == RT_INDEFINITE_WAIT ? INFINITE : cMillies;
652	PVUSBURB pUrb = NULL;
653	DWORD rc = WaitForMultipleObjects(cQueuedUrbs + 1, pPriv->paHandles, FALSE, cMilliesWait);
654
655	/* If the wakeup event fired return immediately. */
656	if (rc == WAIT_OBJECT_0 + cQueuedUrbs)
657	{
658	if (pPriv->cPendingUrbs)
659	goto again;
660	return NULL;
661	}
662
663	if (rc >= WAIT_OBJECT_0 && rc < WAIT_OBJECT_0 + cQueuedUrbs)
664	{
665	RTCritSectEnter(&pPriv->CritSect);
666	unsigned iUrb = rc - WAIT_OBJECT_0;
667	PQUEUED_URB pQUrbWin = pPriv->paQueuedUrbs[iUrb];
668	pUrb = pQUrbWin->urb;
669
670	/*
671	* Remove it from the arrays.
672	*/
673	cQueuedUrbs = --pPriv->cQueuedUrbs;
674	if (cQueuedUrbs != iUrb)
675	{
676	/* Move the array forward */
677	for (unsigned i=iUrb;i<cQueuedUrbs;i++)
678	{
679	pPriv->paHandles[i] = pPriv->paHandles[i+1];
680	pPriv->paQueuedUrbs[i] = pPriv->paQueuedUrbs[i+1];
681	}
682	}
683	pPriv->paHandles[cQueuedUrbs] = pPriv->hEventWakeup;
684	pPriv->paHandles[cQueuedUrbs + 1] = INVALID_HANDLE_VALUE;
685	pPriv->paQueuedUrbs[cQueuedUrbs] = NULL;
686	RTCritSectLeave(&pPriv->CritSect);
687	Assert(cQueuedUrbs == pPriv->cQueuedUrbs);
688
689	/*
690	* Update the urb.
691	*/
692	pUrb->enmStatus = usbProxyWinStatusToVUsbStatus(pQUrbWin->urbwin.error);
693	pUrb->cbData = (uint32_t)pQUrbWin->urbwin.len;
694	if (pUrb->enmType == VUSBXFERTYPE_ISOC)
695	{
696	for (unsigned i = 0; i < pUrb->cIsocPkts; ++i)
697	{
698	/* NB: Windows won't change the packet offsets, but the packets may
699	* be only partially filled or completely empty.
700	*/
701	pUrb->aIsocPkts[i].enmStatus = usbProxyWinStatusToVUsbStatus(pQUrbWin->urbwin.aIsoPkts[i].stat);
702	pUrb->aIsocPkts[i].cb = pQUrbWin->urbwin.aIsoPkts[i].cb;
703	}
704	}
705	Log(("usbproxy: pUrb=%p (#%d) ep=%d cbData=%d status=%d cIsocPkts=%d ready\n",
706	pUrb, rc - WAIT_OBJECT_0, pQUrbWin->urb->EndPt, pQUrbWin->urb->cbData, pUrb->enmStatus, pUrb->cIsocPkts));
707
708	/* free the urb queuing structure */
709	if (pQUrbWin->overlapped.hEvent != INVALID_HANDLE_VALUE)
710	{
711	CloseHandle(pQUrbWin->overlapped.hEvent);
712	pQUrbWin->overlapped.hEvent = INVALID_HANDLE_VALUE;
713	}
714	RTMemFree(pQUrbWin);
715	}
716	else if ( rc == WAIT_FAILED
717	\|\| (rc >= WAIT_ABANDONED_0 && rc < WAIT_ABANDONED_0 + cQueuedUrbs))
718	AssertMsgFailed(("USB: WaitForMultipleObjects %d objects failed with rc=%d and last error %d\n", cQueuedUrbs, rc, GetLastError()));
719
720	return pUrb;
721	}
722
723
724	/**
725	* Cancels an in-flight URB.
726	*
727	* The URB requires reaping, so we don't change its state.
728	*
729	* @remark There isn't a way to cancel a specific URB on Windows.
730	* on darwin. The interface only supports the aborting of
731	* all URBs pending on an endpoint. Luckily that is usually
732	* exactly what the guest wants to do.
733	*/
734	static void usbProxyWinUrbCancel(PVUSBURB pUrb)
735	{
736	PUSBPROXYDEV pProxyDev = PDMINS_2_DATA(pUrb->pUsbIns, PUSBPROXYDEV);
737	PPRIV_USBW32 pPriv = (PPRIV_USBW32)pProxyDev->Backend.pv;
738	PQUEUED_URB pQUrbWin = (PQUEUED_URB)pUrb->Dev.pvPrivate;
739	int rc;
740	USBSUP_CLEAR_ENDPOINT in;
741	DWORD cbReturned;
742	Assert(pQUrbWin);
743
744	in.bEndpoint = pUrb->EndPt \| (pUrb->enmDir == VUSBDIRECTION_IN ? 0x80 : 0);
745	Log(("Cancel urb %p, endpoint %x\n", pUrb, in.bEndpoint));
746
747	cbReturned = 0;
748	if (DeviceIoControl(pPriv->hDev, SUPUSB_IOCTL_USB_ABORT_ENDPOINT, &in, sizeof(in), NULL, 0, &cbReturned, NULL))
749	return;
750
751	rc = GetLastError();
752	if ( rc == ERROR_INVALID_HANDLE_STATE
753	\|\| rc == ERROR_BAD_COMMAND)
754	{
755	Log(("usbproxy: device %x unplugged!!\n", pPriv->hDev));
756	pProxyDev->fDetached = true;
757	}
758	else
759	AssertMsgFailed(("lasterr=%d\n", rc));
760	}
761
762	static int usbProxyWinWakeup(PUSBPROXYDEV pProxyDev)
763	{
764	PPRIV_USBW32 pPriv = (PPRIV_USBW32)pProxyDev->Backend.pv;
765
766	SetEvent(pPriv->hEventWakeup);
767	return VINF_SUCCESS;
768	}
769
770	/**
771	* The Win32 USB Proxy Backend.
772	*/
773	extern const USBPROXYBACK g_USBProxyDeviceHost =
774	{
775	"host",
776	usbProxyWinOpen,
777	NULL,
778	usbProxyWinClose,
779	usbProxyWinReset,
780	usbProxyWinSetConfig,
781	usbProxyWinClaimInterface,
782	usbProxyWinReleaseInterface,
783	usbProxyWinSetInterface,
784	usbProxyWinClearHaltedEndPt,
785	usbProxyWinUrbQueue,
786	usbProxyWinUrbCancel,
787	usbProxyWinUrbReap,
788	usbProxyWinWakeup,
789	0
790	};
791

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

source: vbox/trunk/src/VBox/Devices/USB/win/USBProxyDevice-win.cpp@ 49890

Download in other formats: