VUSBUrb.cpp@ 59796

Last change on this file since 59796 was 59796, checked in by vboxsync, 9 years ago
VUSB: Update pointer pointers to pVUsb and pVUsb->pUrb when reallocating message URB structures
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 49.8 KB

Line
1	/* $Id: VUSBUrb.cpp 59796 2016-02-24 10:59:59Z vboxsync $ */
2	/** @file
3	* Virtual USB - URBs.
4	*/
5
6	/*
7	* Copyright (C) 2006-2016 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#define LOG_GROUP LOG_GROUP_DRV_VUSB
23	#include <VBox/vmm/pdm.h>
24	#include <VBox/vmm/vmapi.h>
25	#include <VBox/err.h>
26	#include <iprt/alloc.h>
27	#include <VBox/log.h>
28	#include <iprt/time.h>
29	#include <iprt/thread.h>
30	#include <iprt/semaphore.h>
31	#include <iprt/string.h>
32	#include <iprt/assert.h>
33	#include <iprt/asm.h>
34	#include <iprt/env.h>
35	#include "VUSBInternal.h"
36
37
38
39	/*********************************************************************************************************************************
40	* Global Variables *
41	*********************************************************************************************************************************/
42	/** Strings for the CTLSTAGE enum values. */
43	const char * const g_apszCtlStates[4] =
44	{
45	"SETUP",
46	"DATA",
47	"STATUS",
48	"N/A"
49	};
50
51
52	/*********************************************************************************************************************************
53	* Internal Functions *
54	*********************************************************************************************************************************/
55
56
57	/**
58	* Complete a SETUP stage URB.
59	*
60	* This is used both for dev2host and host2dev kind of transfers.
61	* It is used by both the sync and async control paths.
62	*/
63	static void vusbMsgSetupCompletion(PVUSBURB pUrb)
64	{
65	PVUSBDEV pDev = pUrb->pVUsb->pDev;
66	PVUSBPIPE pPipe = &pDev->aPipes[pUrb->EndPt];
67	PVUSBCTRLEXTRA pExtra = pPipe->pCtrl;
68	PVUSBSETUP pSetup = pExtra->pMsg;
69
70	LogFlow(("%s: vusbMsgSetupCompletion: cbData=%d wLength=%#x cbLeft=%d pPipe=%p stage %s->DATA\n",
71	pUrb->pszDesc, pUrb->cbData, pSetup->wLength, pExtra->cbLeft, pPipe, g_apszCtlStates[pExtra->enmStage])); NOREF(pSetup);
72	pExtra->enmStage = CTLSTAGE_DATA;
73	pUrb->enmStatus = VUSBSTATUS_OK;
74	}
75
76	/**
77	* Complete a DATA stage URB.
78	*
79	* This is used both for dev2host and host2dev kind of transfers.
80	* It is used by both the sync and async control paths.
81	*/
82	static void vusbMsgDataCompletion(PVUSBURB pUrb)
83	{
84	PVUSBDEV pDev = pUrb->pVUsb->pDev;
85	PVUSBPIPE pPipe = &pDev->aPipes[pUrb->EndPt];
86	PVUSBCTRLEXTRA pExtra = pPipe->pCtrl;
87	PVUSBSETUP pSetup = pExtra->pMsg;
88
89	LogFlow(("%s: vusbMsgDataCompletion: cbData=%d wLength=%#x cbLeft=%d pPipe=%p stage DATA\n",
90	pUrb->pszDesc, pUrb->cbData, pSetup->wLength, pExtra->cbLeft, pPipe)); NOREF(pSetup);
91
92	pUrb->enmStatus = VUSBSTATUS_OK;
93	}
94
95	/**
96	* Complete a STATUS stage URB.
97	*
98	* This is used both for dev2host and host2dev kind of transfers.
99	* It is used by both the sync and async control paths.
100	*/
101	static void vusbMsgStatusCompletion(PVUSBURB pUrb)
102	{
103	PVUSBDEV pDev = pUrb->pVUsb->pDev;
104	PVUSBPIPE pPipe = &pDev->aPipes[pUrb->EndPt];
105	PVUSBCTRLEXTRA pExtra = pPipe->pCtrl;
106
107	if (pExtra->fOk)
108	{
109	/*
110	* vusbDevStdReqSetAddress requests are deferred.
111	*/
112	if (pDev->u8NewAddress != VUSB_INVALID_ADDRESS)
113	{
114	vusbDevSetAddress(pDev, pDev->u8NewAddress);
115	pDev->u8NewAddress = VUSB_INVALID_ADDRESS;
116	}
117
118	LogFlow(("%s: vusbMsgStatusCompletion: pDev=%p[%s] pPipe=%p err=OK stage %s->SETUP\n",
119	pUrb->pszDesc, pDev, pDev->pUsbIns->pszName, pPipe, g_apszCtlStates[pExtra->enmStage]));
120	pUrb->enmStatus = VUSBSTATUS_OK;
121	}
122	else
123	{
124	LogFlow(("%s: vusbMsgStatusCompletion: pDev=%p[%s] pPipe=%p err=STALL stage %s->SETUP\n",
125	pUrb->pszDesc, pDev, pDev->pUsbIns->pszName, pPipe, g_apszCtlStates[pExtra->enmStage]));
126	pUrb->enmStatus = VUSBSTATUS_STALL;
127	}
128
129	/*
130	* Done with this message sequence.
131	*/
132	pExtra->pbCur = NULL;
133	pExtra->enmStage = CTLSTAGE_SETUP;
134	}
135
136	/**
137	* This is a worker function for vusbMsgCompletion and
138	* vusbMsgSubmitSynchronously used to complete the original URB.
139	*
140	* @param pUrb The URB originating from the HCI.
141	*/
142	static void vusbCtrlCompletion(PVUSBURB pUrb)
143	{
144	PVUSBDEV pDev = pUrb->pVUsb->pDev;
145	PVUSBPIPE pPipe = &pDev->aPipes[pUrb->EndPt];
146	PVUSBCTRLEXTRA pExtra = pPipe->pCtrl;
147	LogFlow(("%s: vusbCtrlCompletion: pDev=%p[%s]\n", pUrb->pszDesc, pDev, pDev->pUsbIns->pszName));
148
149	switch (pExtra->enmStage)
150	{
151	case CTLSTAGE_SETUP:
152	vusbMsgSetupCompletion(pUrb);
153	break;
154	case CTLSTAGE_DATA:
155	vusbMsgDataCompletion(pUrb);
156	break;
157	case CTLSTAGE_STATUS:
158	vusbMsgStatusCompletion(pUrb);
159	break;
160	}
161	}
162
163	/**
164	* Called from vusbUrbCompletionRh when it encounters a
165	* message type URB.
166	*
167	* @param pUrb The URB within the control pipe extra state data.
168	*/
169	static void vusbMsgCompletion(PVUSBURB pUrb)
170	{
171	PVUSBDEV pDev = pUrb->pVUsb->pDev;
172	PVUSBPIPE pPipe = &pDev->aPipes[pUrb->EndPt];
173
174	RTCritSectEnter(&pPipe->CritSectCtrl);
175	PVUSBCTRLEXTRA pExtra = pPipe->pCtrl;
176
177	#ifdef LOG_ENABLED
178	LogFlow(("%s: vusbMsgCompletion: pDev=%p[%s]\n", pUrb->pszDesc, pDev, pDev->pUsbIns->pszName));
179	vusbUrbTrace(pUrb, "vusbMsgCompletion", true);
180	#endif
181	Assert(&pExtra->Urb == pUrb);
182
183
184	if (pUrb->enmStatus == VUSBSTATUS_OK)
185	pExtra->fOk = true;
186	else
187	pExtra->fOk = false;
188	pExtra->cbLeft = pUrb->cbData - sizeof(VUSBSETUP);
189
190	/*
191	* Complete the original URB.
192	*/
193	PVUSBURB pCtrlUrb = pUrb->pVUsb->pCtrlUrb;
194	pCtrlUrb->enmState = VUSBURBSTATE_REAPED;
195	vusbCtrlCompletion(pCtrlUrb);
196
197	/*
198	* 'Free' the message URB, i.e. put it back to the allocated state.
199	*/
200	Assert( pUrb->enmState == VUSBURBSTATE_REAPED
201	\|\| pUrb->enmState == VUSBURBSTATE_CANCELLED);
202	if (pUrb->enmState != VUSBURBSTATE_CANCELLED)
203	{
204	pUrb->enmState = VUSBURBSTATE_ALLOCATED;
205	pUrb->fCompleting = false;
206	}
207	RTCritSectLeave(&pPipe->CritSectCtrl);
208
209	/* Complete the original control URB on the root hub now. */
210	vusbUrbCompletionRh(pCtrlUrb);
211	}
212
213	/**
214	* Deal with URB errors, talking thru the RH to the HCI.
215	*
216	* @returns true if it could be retried.
217	* @returns false if it should be completed with failure.
218	* @param pUrb The URB in question.
219	*/
220	int vusbUrbErrorRh(PVUSBURB pUrb)
221	{
222	PVUSBDEV pDev = pUrb->pVUsb->pDev;
223	PVUSBROOTHUB pRh = vusbDevGetRh(pDev);
224	AssertPtrReturn(pRh, VERR_VUSB_DEVICE_NOT_ATTACHED);
225	LogFlow(("%s: vusbUrbErrorRh: pDev=%p[%s] rh=%p\n", pUrb->pszDesc, pDev, pDev->pUsbIns ? pDev->pUsbIns->pszName : "", pRh));
226	return pRh->pIRhPort->pfnXferError(pRh->pIRhPort, pUrb);
227	}
228
229	/**
230	* Does URB completion on roothub level.
231	*
232	* @param pUrb The URB to complete.
233	*/
234	void vusbUrbCompletionRh(PVUSBURB pUrb)
235	{
236	LogFlow(("%s: vusbUrbCompletionRh: type=%s status=%s\n",
237	pUrb->pszDesc, vusbUrbTypeName(pUrb->enmType), vusbUrbStatusName(pUrb->enmStatus)));
238	AssertMsg( pUrb->enmState == VUSBURBSTATE_REAPED
239	\|\| pUrb->enmState == VUSBURBSTATE_CANCELLED, ("%d\n", pUrb->enmState));
240
241	if ( pUrb->pVUsb->pDev
242	&& pUrb->pVUsb->pDev->hSniffer)
243	{
244	int rc = VUSBSnifferRecordEvent(pUrb->pVUsb->pDev->hSniffer, pUrb,
245	pUrb->enmStatus == VUSBSTATUS_OK
246	? VUSBSNIFFEREVENT_COMPLETE
247	: VUSBSNIFFEREVENT_ERROR_COMPLETE);
248	if (RT_FAILURE(rc))
249	LogRel(("VUSB: Capturing URB completion event failed with %Rrc\n", rc));
250	}
251
252	PVUSBROOTHUB pRh = vusbDevGetRh(pUrb->pVUsb->pDev);
253	AssertPtrReturnVoid(pRh);
254
255	/* If there is a sniffer on the roothub record the completed URB there too. */
256	if (pRh->hSniffer != VUSBSNIFFER_NIL)
257	{
258	int rc = VUSBSnifferRecordEvent(pRh->hSniffer, pUrb,
259	pUrb->enmStatus == VUSBSTATUS_OK
260	? VUSBSNIFFEREVENT_COMPLETE
261	: VUSBSNIFFEREVENT_ERROR_COMPLETE);
262	if (RT_FAILURE(rc))
263	LogRel(("VUSB: Capturing URB completion event on the root hub failed with %Rrc\n", rc));
264	}
265
266	#ifdef VBOX_WITH_STATISTICS
267	/*
268	* Total and per-type submit statistics.
269	*/
270	if (pUrb->enmType != VUSBXFERTYPE_MSG)
271	{
272	Assert(pUrb->enmType >= 0 && pUrb->enmType < (int)RT_ELEMENTS(pRh->aTypes));
273
274	if ( pUrb->enmStatus == VUSBSTATUS_OK
275	\|\| pUrb->enmStatus == VUSBSTATUS_DATA_UNDERRUN
276	\|\| pUrb->enmStatus == VUSBSTATUS_DATA_OVERRUN)
277	{
278	if (pUrb->enmType == VUSBXFERTYPE_ISOC)
279	{
280	for (unsigned i = 0; i < pUrb->cIsocPkts; i++)
281	{
282	const unsigned cb = pUrb->aIsocPkts[i].cb;
283	if (cb)
284	{
285	STAM_COUNTER_ADD(&pRh->Total.StatActBytes, cb);
286	STAM_COUNTER_ADD(&pRh->aTypes[VUSBXFERTYPE_ISOC].StatActBytes, cb);
287	STAM_COUNTER_ADD(&pRh->aStatIsocDetails[i].Bytes, cb);
288	if (pUrb->enmDir == VUSBDIRECTION_IN)
289	{
290	STAM_COUNTER_ADD(&pRh->Total.StatActReadBytes, cb);
291	STAM_COUNTER_ADD(&pRh->aTypes[VUSBXFERTYPE_ISOC].StatActReadBytes, cb);
292	}
293	else
294	{
295	STAM_COUNTER_ADD(&pRh->Total.StatActWriteBytes, cb);
296	STAM_COUNTER_ADD(&pRh->aTypes[VUSBXFERTYPE_ISOC].StatActWriteBytes, cb);
297	}
298	STAM_COUNTER_INC(&pRh->StatIsocActPkts);
299	STAM_COUNTER_INC(&pRh->StatIsocActReadPkts);
300	}
301	STAM_COUNTER_INC(&pRh->aStatIsocDetails[i].Pkts);
302	switch (pUrb->aIsocPkts[i].enmStatus)
303	{
304	case VUSBSTATUS_OK:
305	if (cb) STAM_COUNTER_INC(&pRh->aStatIsocDetails[i].Ok);
306	else STAM_COUNTER_INC(&pRh->aStatIsocDetails[i].Ok0); break;
307	case VUSBSTATUS_DATA_UNDERRUN:
308	if (cb) STAM_COUNTER_INC(&pRh->aStatIsocDetails[i].DataUnderrun);
309	else STAM_COUNTER_INC(&pRh->aStatIsocDetails[i].DataUnderrun0); break;
310	case VUSBSTATUS_DATA_OVERRUN: STAM_COUNTER_INC(&pRh->aStatIsocDetails[i].DataOverrun); break;
311	case VUSBSTATUS_NOT_ACCESSED: STAM_COUNTER_INC(&pRh->aStatIsocDetails[i].NotAccessed); break;
312	default: STAM_COUNTER_INC(&pRh->aStatIsocDetails[i].Misc); break;
313	}
314	}
315	}
316	else
317	{
318	STAM_COUNTER_ADD(&pRh->Total.StatActBytes, pUrb->cbData);
319	STAM_COUNTER_ADD(&pRh->aTypes[pUrb->enmType].StatActBytes, pUrb->cbData);
320	if (pUrb->enmDir == VUSBDIRECTION_IN)
321	{
322	STAM_COUNTER_ADD(&pRh->Total.StatActReadBytes, pUrb->cbData);
323	STAM_COUNTER_ADD(&pRh->aTypes[pUrb->enmType].StatActReadBytes, pUrb->cbData);
324	}
325	else
326	{
327	STAM_COUNTER_ADD(&pRh->Total.StatActWriteBytes, pUrb->cbData);
328	STAM_COUNTER_ADD(&pRh->aTypes[pUrb->enmType].StatActWriteBytes, pUrb->cbData);
329	}
330	}
331	}
332	else
333	{
334	/* (Note. this also counts the cancelled packets) */
335	STAM_COUNTER_INC(&pRh->Total.StatUrbsFailed);
336	STAM_COUNTER_INC(&pRh->aTypes[pUrb->enmType].StatUrbsFailed);
337	}
338	}
339	#endif /* VBOX_WITH_STATISTICS */
340
341	/*
342	* Msg transfers are special virtual transfers associated with
343	* vusb, not the roothub
344	*/
345	switch (pUrb->enmType)
346	{
347	case VUSBXFERTYPE_MSG:
348	vusbMsgCompletion(pUrb);
349	return;
350	case VUSBXFERTYPE_ISOC:
351	/* Don't bother with error callback for isochronous URBs. */
352	break;
353
354	#if 1 /** @todo r=bird: OHCI say "If the Transfer Descriptor is being
355	* retired because of an error, the Host Controller must update
356	* the Halt bit of the Endpoint Descriptor."
357	*
358	* So, I'll subject all transfertypes to the same halt stuff now. It could
359	* just happen to fix the logitech disconnect trap in win2k.
360	*/
361	default:
362	#endif
363	case VUSBXFERTYPE_BULK:
364	if (pUrb->enmStatus != VUSBSTATUS_OK)
365	vusbUrbErrorRh(pUrb);
366	break;
367	}
368	#ifdef LOG_ENABLED
369	vusbUrbTrace(pUrb, "vusbUrbCompletionRh", true);
370	#endif
371
372	pRh->pIRhPort->pfnXferCompletion(pRh->pIRhPort, pUrb);
373	if (pUrb->enmState == VUSBURBSTATE_REAPED)
374	{
375	LogFlow(("%s: vusbUrbCompletionRh: Freeing URB\n", pUrb->pszDesc));
376	pUrb->pVUsb->pfnFree(pUrb);
377	}
378	}
379
380
381	/**
382	* Certain control requests must not ever be forwarded to the device because
383	* they are required by the vusb core in order to maintain the vusb internal
384	* data structures.
385	*/
386	DECLINLINE(bool) vusbUrbIsRequestSafe(PCVUSBSETUP pSetup, PVUSBURB pUrb)
387	{
388	if ((pSetup->bmRequestType & VUSB_REQ_MASK) != VUSB_REQ_STANDARD)
389	return true;
390
391	switch (pSetup->bRequest)
392	{
393	case VUSB_REQ_CLEAR_FEATURE:
394	return pUrb->EndPt != 0 /* not default control pipe */
395	\|\| pSetup->wValue != 0 /* not ENDPOINT_HALT */
396	\|\| !pUrb->pVUsb->pDev->pUsbIns->pReg->pfnUsbClearHaltedEndpoint; /* not special need for backend */
397	case VUSB_REQ_SET_ADDRESS:
398	case VUSB_REQ_SET_CONFIGURATION:
399	case VUSB_REQ_GET_CONFIGURATION:
400	case VUSB_REQ_SET_INTERFACE:
401	case VUSB_REQ_GET_INTERFACE:
402	return false;
403
404	/*
405	* If the device wishes it, we'll use the cached device and
406	* configuration descriptors. (We return false when we want to use the
407	* cache. Yeah, it's a bit weird to read.)
408	*/
409	case VUSB_REQ_GET_DESCRIPTOR:
410	if ( !pUrb->pVUsb->pDev->pDescCache->fUseCachedDescriptors
411	\|\| (pSetup->bmRequestType & VUSB_RECIP_MASK) != VUSB_TO_DEVICE)
412	return true;
413	switch (pSetup->wValue >> 8)
414	{
415	case VUSB_DT_DEVICE:
416	case VUSB_DT_CONFIG:
417	return false;
418	case VUSB_DT_STRING:
419	return !pUrb->pVUsb->pDev->pDescCache->fUseCachedStringsDescriptors;
420	default:
421	return true;
422	}
423
424	default:
425	return true;
426	}
427	}
428
429
430	/**
431	* Queues an URB for asynchronous transfer.
432	* A list of asynchronous URBs is kept by the roothub.
433	*
434	* @returns VBox status code (from pfnUrbQueue).
435	* @param pUrb The URB.
436	*/
437	int vusbUrbQueueAsyncRh(PVUSBURB pUrb)
438	{
439	#ifdef LOG_ENABLED
440	vusbUrbTrace(pUrb, "vusbUrbQueueAsyncRh", false);
441	#endif
442
443	/* Immediately return in case of error.
444	* XXX There is still a race: The Rh might vanish after this point! */
445	PVUSBDEV pDev = pUrb->pVUsb->pDev;
446	PVUSBROOTHUB pRh = vusbDevGetRh(pDev);
447	if (!pRh)
448	{
449	Log(("vusbUrbQueueAsyncRh returning VERR_OBJECT_DESTROYED\n"));
450	return VERR_OBJECT_DESTROYED;
451	}
452
453	RTCritSectEnter(&pDev->CritSectAsyncUrbs);
454	int rc = pDev->pUsbIns->pReg->pfnUrbQueue(pDev->pUsbIns, pUrb);
455	if (RT_FAILURE(rc))
456	{
457	LogFlow(("%s: vusbUrbQueueAsyncRh: returns %Rrc (queue_urb)\n", pUrb->pszDesc, rc));
458	RTCritSectLeave(&pDev->CritSectAsyncUrbs);
459	return rc;
460	}
461
462	ASMAtomicIncU32(&pDev->aPipes[pUrb->EndPt].async);
463
464	/* Queue the Urb on the roothub */
465	RTListAppend(&pDev->LstAsyncUrbs, &pUrb->pVUsb->NdLst);
466	RTCritSectLeave(&pDev->CritSectAsyncUrbs);
467
468	return VINF_SUCCESS;
469	}
470
471
472	/**
473	* Send a control message synchronously.
474	* @return
475	*/
476	static void vusbMsgSubmitSynchronously(PVUSBURB pUrb, bool fSafeRequest)
477	{
478	PVUSBDEV pDev = pUrb->pVUsb->pDev;
479	Assert(pDev);
480	PVUSBPIPE pPipe = &pDev->aPipes[pUrb->EndPt];
481	PVUSBCTRLEXTRA pExtra = pPipe->pCtrl;
482	PVUSBSETUP pSetup = pExtra->pMsg;
483	LogFlow(("%s: vusbMsgSubmitSynchronously: pDev=%p[%s]\n", pUrb->pszDesc, pDev, pDev->pUsbIns ? pDev->pUsbIns->pszName : ""));
484
485	uint8_t pbData = (uint8_t )pExtra->pMsg + sizeof(*pSetup);
486	uint32_t cbData = pSetup->wLength;
487	bool fOk = false;
488	if (!fSafeRequest)
489	fOk = vusbDevStandardRequest(pDev, pUrb->EndPt, pSetup, pbData, &cbData);
490	else
491	AssertMsgFailed(("oops\n"));
492
493	pUrb->enmState = VUSBURBSTATE_REAPED;
494	if (fOk)
495	{
496	pSetup->wLength = cbData;
497	pUrb->enmStatus = VUSBSTATUS_OK;
498	pExtra->fOk = true;
499	}
500	else
501	{
502	pUrb->enmStatus = VUSBSTATUS_STALL;
503	pExtra->fOk = false;
504	}
505	pExtra->cbLeft = cbData; /* used by IN only */
506
507	vusbCtrlCompletion(pUrb);
508	vusbUrbCompletionRh(pUrb);
509
510	/*
511	* 'Free' the message URB, i.e. put it back to the allocated state.
512	*/
513	pExtra->Urb.enmState = VUSBURBSTATE_ALLOCATED;
514	pExtra->Urb.fCompleting = false;
515	}
516
517	/**
518	* Callback for dealing with device reset.
519	*/
520	void vusbMsgResetExtraData(PVUSBCTRLEXTRA pExtra)
521	{
522	if (!pExtra)
523	return;
524	pExtra->enmStage = CTLSTAGE_SETUP;
525	if (pExtra->Urb.enmState != VUSBURBSTATE_CANCELLED)
526	{
527	pExtra->Urb.enmState = VUSBURBSTATE_ALLOCATED;
528	pExtra->Urb.fCompleting = false;
529	}
530	}
531
532
533	/**
534	* Callback to free a cancelled message URB.
535	*
536	* This is yet another place we're we have to performance acrobatics to
537	* deal with cancelled URBs. sigh.
538	*
539	* The deal here is that we never free message URBs since they are integrated
540	* into the message pipe state. But since cancel can leave URBs unreaped and in
541	* a state which require them not to be freed, we'll have to do two things.
542	* First, if a new message URB is processed we'll have to get a new message
543	* pipe state. Second, we cannot just free the damn state structure because
544	* that might lead to heap corruption since it might still be in-flight.
545	*
546	* The URB embedded into the message pipe control structure will start in an
547	* ALLOCATED state. When submitted it will be go to the IN-FLIGHT state. When
548	* reaped it will go from REAPED to ALLOCATED. When completed in the CANCELLED
549	* state it will remain in that state (as does normal URBs).
550	*
551	* If a new message urb comes up while it's in the CANCELLED state, we will
552	* orphan it and it will be freed here in vusbMsgFreeUrb. We indicate this
553	* by setting pVUsb->pvFreeCtx to NULL.
554	*
555	* If we have to free the message state structure because of device destruction,
556	* configuration changes, or similar, we will orphan the message pipe state in
557	* the same way by setting pVUsb->pvFreeCtx to NULL and let this function free it.
558	*
559	* @param pUrb
560	*/
561	static DECLCALLBACK(void) vusbMsgFreeUrb(PVUSBURB pUrb)
562	{
563	vusbUrbAssert(pUrb);
564	PVUSBCTRLEXTRA pExtra = (PVUSBCTRLEXTRA)((uint8_t *)pUrb - RT_OFFSETOF(VUSBCTRLEXTRA, Urb));
565	if ( pUrb->enmState == VUSBURBSTATE_CANCELLED
566	&& !pUrb->pVUsb->pvFreeCtx)
567	{
568	LogFlow(("vusbMsgFreeUrb: Freeing orphan: %p (pUrb=%p)\n", pExtra, pUrb));
569	RTMemFree(pExtra);
570	}
571	else
572	{
573	Assert(pUrb->pVUsb->pvFreeCtx == &pExtra->Urb);
574	pUrb->enmState = VUSBURBSTATE_ALLOCATED;
575	pUrb->fCompleting = false;
576	}
577	}
578
579	/**
580	* Frees the extra state data associated with a message pipe.
581	*
582	* @param pExtra The data.
583	*/
584	void vusbMsgFreeExtraData(PVUSBCTRLEXTRA pExtra)
585	{
586	if (!pExtra)
587	return;
588	if (pExtra->Urb.enmState != VUSBURBSTATE_CANCELLED)
589	{
590	pExtra->Urb.u32Magic = 0;
591	pExtra->Urb.enmState = VUSBURBSTATE_FREE;
592	if (pExtra->Urb.pszDesc)
593	RTStrFree(pExtra->Urb.pszDesc);
594	RTMemFree(pExtra);
595	}
596	else
597	pExtra->Urb.pVUsb->pvFreeCtx = NULL; /* see vusbMsgFreeUrb */
598	}
599
600	/**
601	* Allocates the extra state data required for a control pipe.
602	*
603	* @returns Pointer to the allocated and initialized state data.
604	* @returns NULL on out of memory condition.
605	* @param pUrb A URB we can copy default data from.
606	*/
607	static PVUSBCTRLEXTRA vusbMsgAllocExtraData(PVUSBURB pUrb)
608	{
609	/** @todo reuse these? */
610	PVUSBCTRLEXTRA pExtra;
611	const size_t cbMax = sizeof(VUSBURBVUSBINT) + sizeof(pExtra->Urb.abData) + sizeof(VUSBSETUP);
612	pExtra = (PVUSBCTRLEXTRA)RTMemAllocZ(RT_OFFSETOF(VUSBCTRLEXTRA, Urb.abData[cbMax]));
613	if (pExtra)
614	{
615	pExtra->enmStage = CTLSTAGE_SETUP;
616	//pExtra->fOk = false;
617	pExtra->pMsg = (PVUSBSETUP)pExtra->Urb.abData;
618	pExtra->pbCur = (uint8_t *)(pExtra->pMsg + 1);
619	//pExtra->cbLeft = 0;
620	pExtra->cbMax = cbMax;
621
622	//pExtra->Urb.Dev.pvProxyUrb = NULL;
623	pExtra->Urb.u32Magic = VUSBURB_MAGIC;
624	pExtra->Urb.enmState = VUSBURBSTATE_ALLOCATED;
625	pExtra->Urb.fCompleting = false;
626	#ifdef LOG_ENABLED
627	RTStrAPrintf(&pExtra->Urb.pszDesc, "URB %p msg->%p", &pExtra->Urb, pUrb);
628	#endif
629	pExtra->Urb.pVUsb = (PVUSBURBVUSB)&pExtra->Urb.abData[sizeof(pExtra->Urb.abData) + sizeof(VUSBSETUP)];
630	//pExtra->Urb.pVUsb->pCtrlUrb = NULL;
631	//pExtra->Urb.pVUsb->pNext = NULL;
632	//pExtra->Urb.pVUsb->ppPrev = NULL;
633	pExtra->Urb.pVUsb->pUrb = &pExtra->Urb;
634	pExtra->Urb.pVUsb->pDev = pUrb->pVUsb->pDev;
635	pExtra->Urb.pVUsb->pfnFree = vusbMsgFreeUrb;
636	pExtra->Urb.pVUsb->pvFreeCtx = &pExtra->Urb;
637	//pExtra->Urb.Hci = {0};
638	//pExtra->Urb.Dev.pvProxyUrb = NULL;
639	pExtra->Urb.DstAddress = pUrb->DstAddress;
640	pExtra->Urb.EndPt = pUrb->EndPt;
641	pExtra->Urb.enmType = VUSBXFERTYPE_MSG;
642	pExtra->Urb.enmDir = VUSBDIRECTION_INVALID;
643	//pExtra->Urb.fShortNotOk = false;
644	pExtra->Urb.enmStatus = VUSBSTATUS_INVALID;
645	//pExtra->Urb.cbData = 0;
646	vusbUrbAssert(&pExtra->Urb);
647	}
648	return pExtra;
649	}
650
651	/**
652	* Sets up the message.
653	*
654	* The message is associated with the pipe, in what's currently called
655	* control pipe extra state data (pointed to by pPipe->pCtrl). If this
656	* is a OUT message, we will no go on collecting data URB. If it's a
657	* IN message, we'll send it and then queue any incoming data for the
658	* URBs collecting it.
659	*
660	* @returns Success indicator.
661	*/
662	static bool vusbMsgSetup(PVUSBPIPE pPipe, const void *pvBuf, uint32_t cbBuf)
663	{
664	PVUSBCTRLEXTRA pExtra = pPipe->pCtrl;
665	const VUSBSETUP *pSetupIn = (PVUSBSETUP)pvBuf;
666
667	/*
668	* Validate length.
669	*/
670	if (cbBuf < sizeof(VUSBSETUP))
671	{
672	LogFlow(("vusbMsgSetup: pPipe=%p cbBuf=%u < %u (failure) !!!\n",
673	pPipe, cbBuf, sizeof(VUSBSETUP)));
674	return false;
675	}
676
677	/*
678	* Check if we've got an cancelled message URB. Allocate a new one in that case.
679	*/
680	if (pExtra->Urb.enmState == VUSBURBSTATE_CANCELLED)
681	{
682	void *pvNew = RTMemDup(pExtra, RT_OFFSETOF(VUSBCTRLEXTRA, Urb.abData[pExtra->cbMax]));
683	if (!pvNew)
684	{
685	Log(("vusbMsgSetup: out of memory!!! cbReq=%u\n", RT_OFFSETOF(VUSBCTRLEXTRA, Urb.abData[pExtra->cbMax])));
686	return false;
687	}
688	pExtra->Urb.pVUsb->pvFreeCtx = NULL;
689	LogFlow(("vusbMsgSetup: Replacing canceled pExtra=%p with %p.\n", pExtra, pvNew));
690	pPipe->pCtrl = pExtra = (PVUSBCTRLEXTRA)pvNew;
691	pExtra->Urb.pVUsb = (PVUSBURBVUSB)&pExtra->Urb.abData[sizeof(pExtra->Urb.abData) + sizeof(VUSBSETUP)];
692	pExtra->Urb.pVUsb->pUrb = &pExtra->Urb;
693	pExtra->pMsg = (PVUSBSETUP)pExtra->Urb.abData;
694	pExtra->Urb.enmState = VUSBURBSTATE_ALLOCATED;
695	pExtra->Urb.fCompleting = false;
696	}
697
698	/*
699	* Check that we've got sufficient space in the message URB.
700	*/
701	if (pExtra->cbMax < cbBuf + pSetupIn->wLength + sizeof(VUSBURBVUSBINT))
702	{
703	uint32_t cbReq = RT_ALIGN_32(cbBuf + pSetupIn->wLength + sizeof(VUSBURBVUSBINT), 1024);
704	PVUSBCTRLEXTRA pNew = (PVUSBCTRLEXTRA)RTMemRealloc(pExtra, RT_OFFSETOF(VUSBCTRLEXTRA, Urb.abData[cbReq]));
705	if (!pNew)
706	{
707	Log(("vusbMsgSetup: out of memory!!! cbReq=%u %u\n",
708	cbReq, RT_OFFSETOF(VUSBCTRLEXTRA, Urb.abData[cbReq])));
709	return false;
710	}
711	if (pExtra != pNew)
712	{
713	pNew->pMsg = (PVUSBSETUP)pNew->Urb.abData;
714	pExtra = pNew;
715	}
716	pExtra->Urb.pVUsb = (PVUSBURBVUSB)&pExtra->Urb.abData[cbBuf + pSetupIn->wLength];
717	pExtra->Urb.pVUsb->pUrb = &pExtra->Urb;
718	pExtra->cbMax = cbReq;
719	}
720	Assert(pExtra->Urb.enmState == VUSBURBSTATE_ALLOCATED);
721
722	/*
723	* Copy the setup data and prepare for data.
724	*/
725	PVUSBSETUP pSetup = pExtra->pMsg;
726	pExtra->fSubmitted = false;
727	pExtra->Urb.enmState = VUSBURBSTATE_IN_FLIGHT;
728	pExtra->pbCur = (uint8_t *)(pSetup + 1);
729	pSetup->bmRequestType = pSetupIn->bmRequestType;
730	pSetup->bRequest = pSetupIn->bRequest;
731	pSetup->wValue = RT_LE2H_U16(pSetupIn->wValue);
732	pSetup->wIndex = RT_LE2H_U16(pSetupIn->wIndex);
733	pSetup->wLength = RT_LE2H_U16(pSetupIn->wLength);
734
735	LogFlow(("vusbMsgSetup(%p,,%d): bmRequestType=%#04x bRequest=%#04x wValue=%#06x wIndex=%#06x wLength=0x%.4x\n",
736	pPipe, cbBuf, pSetup->bmRequestType, pSetup->bRequest, pSetup->wValue, pSetup->wIndex, pSetup->wLength));
737	return true;
738	}
739
740	/**
741	* Build the message URB from the given control URB and accompanying message
742	* pipe state which we grab from the device for the URB.
743	*
744	* @param pUrb The URB to submit.
745	*/
746	static void vusbMsgDoTransfer(PVUSBURB pUrb, PVUSBSETUP pSetup, PVUSBCTRLEXTRA pExtra, PVUSBPIPE pPipe, PVUSBDEV pDev)
747	{
748	/*
749	* Mark this transfer as sent (cleared at setup time).
750	*/
751	Assert(!pExtra->fSubmitted);
752	pExtra->fSubmitted = true;
753
754	/*
755	* Do we have to do this synchronously?
756	*/
757	bool fSafeRequest = vusbUrbIsRequestSafe(pSetup, pUrb);
758	if (!fSafeRequest)
759	{
760	vusbMsgSubmitSynchronously(pUrb, fSafeRequest);
761	return;
762	}
763
764	/*
765	* Do it asynchronously.
766	*/
767	LogFlow(("%s: vusbMsgDoTransfer: ep=%d pMsgUrb=%p pPipe=%p stage=%s\n",
768	pUrb->pszDesc, pUrb->EndPt, &pExtra->Urb, pPipe, g_apszCtlStates[pExtra->enmStage]));
769	Assert(pExtra->Urb.enmType == VUSBXFERTYPE_MSG);
770	Assert(pExtra->Urb.EndPt == pUrb->EndPt);
771	pExtra->Urb.enmDir = (pSetup->bmRequestType & VUSB_DIR_TO_HOST) ? VUSBDIRECTION_IN : VUSBDIRECTION_OUT;
772	pExtra->Urb.cbData = pSetup->wLength + sizeof(*pSetup);
773	pExtra->Urb.pVUsb->pCtrlUrb = pUrb;
774	int rc = vusbUrbQueueAsyncRh(&pExtra->Urb);
775	if (RT_FAILURE(rc))
776	{
777	/*
778	* If we fail submitting it, will not retry but fail immediately.
779	*
780	* This keeps things simple. The host OS will have retried if
781	* it's a proxied device, and if it's a virtual one it really means
782	* it if it's failing a control message.
783	*/
784	LogFlow(("%s: vusbMsgDoTransfer: failed submitting urb! failing it with %s (rc=%Rrc)!!!\n",
785	pUrb->pszDesc, rc == VERR_VUSB_DEVICE_NOT_ATTACHED ? "DNR" : "CRC", rc));
786	pExtra->Urb.enmStatus = rc == VERR_VUSB_DEVICE_NOT_ATTACHED ? VUSBSTATUS_DNR : VUSBSTATUS_CRC;
787	pExtra->Urb.enmState = VUSBURBSTATE_REAPED;
788	vusbMsgCompletion(&pExtra->Urb);
789	}
790	}
791
792	/**
793	* Fails a URB request with a pipe STALL error.
794	*
795	* @returns VINF_SUCCESS indicating that we've completed the URB.
796	* @param pUrb The URB in question.
797	*/
798	static int vusbMsgStall(PVUSBURB pUrb)
799	{
800	PVUSBPIPE pPipe = &pUrb->pVUsb->pDev->aPipes[pUrb->EndPt];
801	PVUSBCTRLEXTRA pExtra = pPipe->pCtrl;
802	LogFlow(("%s: vusbMsgStall: pPipe=%p err=STALL stage %s->SETUP\n",
803	pUrb->pszDesc, pPipe, g_apszCtlStates[pExtra->enmStage]));
804
805	pExtra->pbCur = NULL;
806	pExtra->enmStage = CTLSTAGE_SETUP;
807	pUrb->enmState = VUSBURBSTATE_REAPED;
808	pUrb->enmStatus = VUSBSTATUS_STALL;
809	vusbUrbCompletionRh(pUrb);
810	return VINF_SUCCESS;
811	}
812
813	/**
814	* Submit a control message.
815	*
816	* Here we implement the USB defined traffic that occurs in message pipes
817	* (aka control endpoints). We want to provide a single function for device
818	* drivers so that they don't all have to reimplement the usb logic for
819	* themselves. This means we need to keep a little bit of state information
820	* because control transfers occur over multiple bus transactions. We may
821	* also need to buffer data over multiple data stages.
822	*
823	* @returns VBox status code.
824	* @param pUrb The URB to submit.
825	*/
826	static int vusbUrbSubmitCtrl(PVUSBURB pUrb)
827	{
828	#ifdef LOG_ENABLED
829	vusbUrbTrace(pUrb, "vusbUrbSubmitCtrl", false);
830	#endif
831	PVUSBDEV pDev = pUrb->pVUsb->pDev;
832	PVUSBPIPE pPipe = &pDev->aPipes[pUrb->EndPt];
833
834	RTCritSectEnter(&pPipe->CritSectCtrl);
835	PVUSBCTRLEXTRA pExtra = pPipe->pCtrl;
836
837	if (!pExtra && !(pExtra = pPipe->pCtrl = vusbMsgAllocExtraData(pUrb)))
838	{
839	RTCritSectLeave(&pPipe->CritSectCtrl);
840	return VERR_VUSB_NO_URB_MEMORY;
841	}
842	PVUSBSETUP pSetup = pExtra->pMsg;
843
844	if (pPipe->async)
845	{
846	AssertMsgFailed(("%u\n", pPipe->async));
847	RTCritSectLeave(&pPipe->CritSectCtrl);
848	return VERR_GENERAL_FAILURE;
849	}
850
851	/*
852	* A setup packet always resets the transaction and the
853	* end of data transmission is signified by change in
854	* data direction.
855	*/
856	if (pUrb->enmDir == VUSBDIRECTION_SETUP)
857	{
858	LogFlow(("%s: vusbUrbSubmitCtrl: pPipe=%p state %s->SETUP\n",
859	pUrb->pszDesc, pPipe, g_apszCtlStates[pExtra->enmStage]));
860	pExtra->enmStage = CTLSTAGE_SETUP;
861	}
862	else if ( pExtra->enmStage == CTLSTAGE_DATA
863	/* (the STATUS stage direction goes the other way) */
864	&& !!(pSetup->bmRequestType & VUSB_DIR_TO_HOST) != (pUrb->enmDir == VUSBDIRECTION_IN))
865	{
866	LogFlow(("%s: vusbUrbSubmitCtrl: pPipe=%p state %s->STATUS\n",
867	pUrb->pszDesc, pPipe, g_apszCtlStates[pExtra->enmStage]));
868	pExtra->enmStage = CTLSTAGE_STATUS;
869	}
870
871	/*
872	* Act according to the current message stage.
873	*/
874	switch (pExtra->enmStage)
875	{
876	case CTLSTAGE_SETUP:
877	/*
878	* When stall handshake is returned, all subsequent packets
879	* must generate stall until a setup packet arrives.
880	*/
881	if (pUrb->enmDir != VUSBDIRECTION_SETUP)
882	{
883	Log(("%s: vusbUrbSubmitCtrl: Stall at setup stage (dir=%#x)!!\n", pUrb->pszDesc, pUrb->enmDir));
884	vusbMsgStall(pUrb);
885	break;
886	}
887
888	/* Store setup details, return DNR if corrupt */
889	if (!vusbMsgSetup(pPipe, pUrb->abData, pUrb->cbData))
890	{
891	pUrb->enmState = VUSBURBSTATE_REAPED;
892	pUrb->enmStatus = VUSBSTATUS_DNR;
893	vusbUrbCompletionRh(pUrb);
894	break;
895	}
896	if (pPipe->pCtrl != pExtra)
897	{
898	pExtra = pPipe->pCtrl;
899	pSetup = pExtra->pMsg;
900	}
901
902	/* pre-buffer our output if it's device-to-host */
903	if (pSetup->bmRequestType & VUSB_DIR_TO_HOST)
904	vusbMsgDoTransfer(pUrb, pSetup, pExtra, pPipe, pDev);
905	else if (pSetup->wLength)
906	{
907	LogFlow(("%s: vusbUrbSubmitCtrl: stage=SETUP - to dev: need data\n", pUrb->pszDesc));
908	pUrb->enmState = VUSBURBSTATE_REAPED;
909	vusbMsgSetupCompletion(pUrb);
910	vusbUrbCompletionRh(pUrb);
911	}
912	/*
913	* If there is no DATA stage, we must send it now since there are
914	* no requirement of a STATUS stage.
915	*/
916	else
917	{
918	LogFlow(("%s: vusbUrbSubmitCtrl: stage=SETUP - to dev: sending\n", pUrb->pszDesc));
919	vusbMsgDoTransfer(pUrb, pSetup, pExtra, pPipe, pDev);
920	}
921	break;
922
923	case CTLSTAGE_DATA:
924	{
925	/*
926	* If a data stage exceeds the target buffer indicated in
927	* setup return stall, if data stage returns stall there
928	* will be no status stage.
929	*/
930	uint8_t pbData = (uint8_t )(pExtra->pMsg + 1);
931	if (&pExtra->pbCur[pUrb->cbData] > &pbData[pSetup->wLength])
932	{
933	if (!pSetup->wLength) /* happens during iPhone detection with iTunes (correct?) */
934	{
935	Log(("%s: vusbUrbSubmitCtrl: pSetup->wLength == 0!! (iPhone)\n", pUrb->pszDesc));
936	pSetup->wLength = pUrb->cbData;
937	}
938
939	/* Variable length data transfers */
940	if ( (pSetup->bmRequestType & VUSB_DIR_TO_HOST)
941	\|\| pSetup->wLength == 0
942	\|\| (pUrb->cbData % pSetup->wLength) == 0) /* magic which need explaining... */
943	{
944	uint8_t *pbEnd = pbData + pSetup->wLength;
945	int cbLeft = pbEnd - pExtra->pbCur;
946	LogFlow(("%s: vusbUrbSubmitCtrl: Var DATA, pUrb->cbData %d -> %d\n", pUrb->pszDesc, pUrb->cbData, cbLeft));
947	pUrb->cbData = cbLeft;
948	}
949	else
950	{
951	Log(("%s: vusbUrbSubmitCtrl: Stall at data stage!!\n", pUrb->pszDesc));
952	vusbMsgStall(pUrb);
953	break;
954	}
955	}
956
957	if (pUrb->enmDir == VUSBDIRECTION_IN)
958	{
959	/* put data received from the device. */
960	const uint32_t cbRead = RT_MIN(pUrb->cbData, pExtra->cbLeft);
961	memcpy(pUrb->abData, pExtra->pbCur, cbRead);
962
963	/* advance */
964	pExtra->pbCur += cbRead;
965	if (pUrb->cbData == cbRead)
966	pExtra->cbLeft -= pUrb->cbData;
967	else
968	{
969	/* adjust the pUrb->cbData to reflect the number of bytes containing actual data. */
970	LogFlow(("%s: vusbUrbSubmitCtrl: adjusting last DATA pUrb->cbData, %d -> %d\n",
971	pUrb->pszDesc, pUrb->cbData, pExtra->cbLeft));
972	pUrb->cbData = cbRead;
973	pExtra->cbLeft = 0;
974	}
975	}
976	else
977	{
978	/* get data for sending when completed. */
979	memcpy(pExtra->pbCur, pUrb->abData, pUrb->cbData);
980
981	/* advance */
982	pExtra->pbCur += pUrb->cbData;
983
984	/*
985	* If we've got the necessary data, we'll send it now since there are
986	* no requirement of a STATUS stage.
987	*/
988	if ( !pExtra->fSubmitted
989	&& pExtra->pbCur - pbData >= pSetup->wLength)
990	{
991	LogFlow(("%s: vusbUrbSubmitCtrl: stage=DATA - to dev: sending\n", pUrb->pszDesc));
992	vusbMsgDoTransfer(pUrb, pSetup, pExtra, pPipe, pDev);
993	break;
994	}
995	}
996
997	pUrb->enmState = VUSBURBSTATE_REAPED;
998	vusbMsgDataCompletion(pUrb);
999	vusbUrbCompletionRh(pUrb);
1000	break;
1001	}
1002
1003	case CTLSTAGE_STATUS:
1004	if ( (pSetup->bmRequestType & VUSB_DIR_TO_HOST)
1005	\|\| pExtra->fSubmitted)
1006	{
1007	Assert(pExtra->fSubmitted);
1008	pUrb->enmState = VUSBURBSTATE_REAPED;
1009	vusbMsgStatusCompletion(pUrb);
1010	vusbUrbCompletionRh(pUrb);
1011	}
1012	else
1013	{
1014	LogFlow(("%s: vusbUrbSubmitCtrl: stage=STATUS - to dev: sending\n", pUrb->pszDesc));
1015	vusbMsgDoTransfer(pUrb, pSetup, pExtra, pPipe, pDev);
1016	}
1017	break;
1018	}
1019
1020	RTCritSectLeave(&pPipe->CritSectCtrl);
1021	return VINF_SUCCESS;
1022	}
1023
1024
1025	/**
1026	* Submit a interrupt URB.
1027	*
1028	* @returns VBox status code.
1029	* @param pUrb The URB to submit.
1030	*/
1031	static int vusbUrbSubmitInterrupt(PVUSBURB pUrb)
1032	{
1033	LogFlow(("%s: vusbUrbSubmitInterrupt: (sync)\n", pUrb->pszDesc));
1034	return vusbUrbQueueAsyncRh(pUrb);
1035	}
1036
1037
1038	/**
1039	* Submit a bulk URB.
1040	*
1041	* @returns VBox status code.
1042	* @param pUrb The URB to submit.
1043	*/
1044	static int vusbUrbSubmitBulk(PVUSBURB pUrb)
1045	{
1046	LogFlow(("%s: vusbUrbSubmitBulk: (async)\n", pUrb->pszDesc));
1047	return vusbUrbQueueAsyncRh(pUrb);
1048	}
1049
1050
1051	/**
1052	* Submit an isochronous URB.
1053	*
1054	* @returns VBox status code.
1055	* @param pUrb The URB to submit.
1056	*/
1057	static int vusbUrbSubmitIsochronous(PVUSBURB pUrb)
1058	{
1059	LogFlow(("%s: vusbUrbSubmitIsochronous: (async)\n", pUrb->pszDesc));
1060	return vusbUrbQueueAsyncRh(pUrb);
1061	}
1062
1063
1064	/**
1065	* Fail a URB with a 'hard-error' sort of error.
1066	*
1067	* @return VINF_SUCCESS (the Urb status indicates the error).
1068	* @param pUrb The URB.
1069	*/
1070	int vusbUrbSubmitHardError(PVUSBURB pUrb)
1071	{
1072	/* FIXME: Find out the correct return code from the spec */
1073	pUrb->enmState = VUSBURBSTATE_REAPED;
1074	pUrb->enmStatus = VUSBSTATUS_DNR;
1075	vusbUrbCompletionRh(pUrb);
1076	return VINF_SUCCESS;
1077	}
1078
1079
1080	/**
1081	* Submit a URB.
1082	*/
1083	int vusbUrbSubmit(PVUSBURB pUrb)
1084	{
1085	vusbUrbAssert(pUrb);
1086	Assert(pUrb->enmState == VUSBURBSTATE_ALLOCATED);
1087	PVUSBDEV pDev = pUrb->pVUsb->pDev;
1088	PVUSBPIPE pPipe = NULL;
1089	Assert(pDev);
1090
1091	/*
1092	* Check that the device is in a valid state.
1093	*/
1094	const VUSBDEVICESTATE enmState = vusbDevGetState(pDev);
1095	if (enmState == VUSB_DEVICE_STATE_RESET)
1096	{
1097	LogRel(("VUSB: %s: power off ignored, the device is resetting!\n", pDev->pUsbIns->pszName));
1098	pUrb->enmStatus = VUSBSTATUS_DNR;
1099	/* This will postpone the TDs until we're done with the resetting. */
1100	return VERR_VUSB_DEVICE_IS_RESETTING;
1101	}
1102
1103	#ifdef LOG_ENABLED
1104	/* stamp it */
1105	pUrb->pVUsb->u64SubmitTS = RTTimeNanoTS();
1106	#endif
1107
1108	/** @todo Check max packet size here too? */
1109
1110	/*
1111	* Validate the pipe.
1112	*/
1113	if (pUrb->EndPt >= VUSB_PIPE_MAX)
1114	{
1115	Log(("%s: pDev=%p[%s]: SUBMIT: ep %i >= %i!!!\n", pUrb->pszDesc, pDev, pDev->pUsbIns->pszName, pUrb->EndPt, VUSB_PIPE_MAX));
1116	return vusbUrbSubmitHardError(pUrb);
1117	}
1118	PCVUSBDESCENDPOINTEX pEndPtDesc;
1119	switch (pUrb->enmDir)
1120	{
1121	case VUSBDIRECTION_IN:
1122	pEndPtDesc = pDev->aPipes[pUrb->EndPt].in;
1123	pPipe = &pDev->aPipes[pUrb->EndPt];
1124	break;
1125	case VUSBDIRECTION_SETUP:
1126	case VUSBDIRECTION_OUT:
1127	default:
1128	pEndPtDesc = pDev->aPipes[pUrb->EndPt].out;
1129	pPipe = &pDev->aPipes[pUrb->EndPt];
1130	break;
1131	}
1132	if (!pEndPtDesc)
1133	{
1134	Log(("%s: pDev=%p[%s]: SUBMIT: no endpoint!!! dir=%s e=%i\n",
1135	pUrb->pszDesc, pDev, pDev->pUsbIns->pszName, vusbUrbDirName(pUrb->enmDir), pUrb->EndPt));
1136	return vusbUrbSubmitHardError(pUrb);
1137	}
1138
1139	/*
1140	* Check for correct transfer types.
1141	* Our type codes are the same - what a coincidence.
1142	*/
1143	if ((pEndPtDesc->Core.bmAttributes & 0x3) != pUrb->enmType)
1144	{
1145	Log(("%s: pDev=%p[%s]: SUBMIT: %s transfer requested for %#x endpoint on DstAddress=%i ep=%i dir=%s\n",
1146	pUrb->pszDesc, pDev, pDev->pUsbIns->pszName, vusbUrbTypeName(pUrb->enmType), pEndPtDesc->Core.bmAttributes,
1147	pUrb->DstAddress, pUrb->EndPt, vusbUrbDirName(pUrb->enmDir)));
1148	return vusbUrbSubmitHardError(pUrb);
1149	}
1150
1151	/*
1152	* If there's a URB in the read-ahead buffer, use it.
1153	*/
1154	int rc;
1155
1156	if (pDev->hSniffer)
1157	{
1158	rc = VUSBSnifferRecordEvent(pDev->hSniffer, pUrb, VUSBSNIFFEREVENT_SUBMIT);
1159	if (RT_FAILURE(rc))
1160	LogRel(("VUSB: Capturing URB submit event failed with %Rrc\n", rc));
1161	}
1162
1163	#ifdef VBOX_WITH_USB
1164	if (pPipe && pPipe->hBuffer)
1165	{
1166	rc = vusbBufferedPipeSubmitUrb(pPipe->hBuffer, pUrb);
1167	return rc;
1168	}
1169	#endif
1170
1171	/*
1172	* Take action based on type.
1173	*/
1174	pUrb->enmState = VUSBURBSTATE_IN_FLIGHT;
1175	switch (pUrb->enmType)
1176	{
1177	case VUSBXFERTYPE_CTRL:
1178	rc = vusbUrbSubmitCtrl(pUrb);
1179	break;
1180	case VUSBXFERTYPE_BULK:
1181	rc = vusbUrbSubmitBulk(pUrb);
1182	break;
1183	case VUSBXFERTYPE_INTR:
1184	rc = vusbUrbSubmitInterrupt(pUrb);
1185	break;
1186	case VUSBXFERTYPE_ISOC:
1187	rc = vusbUrbSubmitIsochronous(pUrb);
1188	break;
1189	default:
1190	AssertMsgFailed(("Unexpected pUrb type %d\n", pUrb->enmType));
1191	return vusbUrbSubmitHardError(pUrb);
1192	}
1193
1194	/*
1195	* The device was detached, so we fail everything.
1196	* (We should really detach and destroy the device, but we'll have to wait till Main reacts.)
1197	*/
1198	if (rc == VERR_VUSB_DEVICE_NOT_ATTACHED)
1199	rc = vusbUrbSubmitHardError(pUrb);
1200	/*
1201	* We don't increment error count if async URBs are in flight, in
1202	* this case we just assume we need to throttle back, this also
1203	* makes sure we don't halt bulk endpoints at the wrong time.
1204	*/
1205	else if ( RT_FAILURE(rc)
1206	&& !ASMAtomicReadU32(&pDev->aPipes[pUrb->EndPt].async)
1207	/* && pUrb->enmType == VUSBXFERTYPE_BULK ?? */
1208	&& !vusbUrbErrorRh(pUrb))
1209	{
1210	/* don't retry it anymore. */
1211	pUrb->enmState = VUSBURBSTATE_REAPED;
1212	pUrb->enmStatus = VUSBSTATUS_CRC;
1213	vusbUrbCompletionRh(pUrb);
1214	return VINF_SUCCESS;
1215	}
1216
1217	return rc;
1218	}
1219
1220
1221	/**
1222	* Reap in-flight URBs.
1223	*
1224	* @param pUrbLst Pointer to the head of the URB list.
1225	* @param cMillies Number of milliseconds to block in each reap operation.
1226	* Use 0 to not block at all.
1227	*/
1228	void vusbUrbDoReapAsync(PRTLISTANCHOR pUrbLst, RTMSINTERVAL cMillies)
1229	{
1230	PVUSBURBVUSB pVUsbUrb = RTListGetFirst(pUrbLst, VUSBURBVUSBINT, NdLst);
1231	while (pVUsbUrb)
1232	{
1233	PVUSBURB pUrb = pVUsbUrb->pUrb;
1234
1235	vusbUrbAssert(pUrb);
1236	PVUSBURBVUSB pVUsbUrbNext = RTListGetNext(pUrbLst, pVUsbUrb, VUSBURBVUSBINT, NdLst);
1237	PVUSBDEV pDev = pVUsbUrb->pDev;
1238
1239	/* Don't touch resetting devices - paranoid safety precaution. */
1240	if (vusbDevGetState(pDev) != VUSB_DEVICE_STATE_RESET)
1241	{
1242	/*
1243	* Reap most URBs pending on a single device.
1244	*/
1245	PVUSBURB pRipe;
1246
1247	/**
1248	* This is workaround for race(should be fixed) detach on one EMT thread and frame boundary timer on other
1249	* and leaked URBs (shouldn't be affected by leaked URBs).
1250	*/
1251	Assert(pDev->pUsbIns);
1252	while ( pDev->pUsbIns
1253	&& ((pRipe = pDev->pUsbIns->pReg->pfnUrbReap(pDev->pUsbIns, cMillies)) != NULL))
1254	{
1255	vusbUrbAssert(pRipe);
1256	if (pRipe == pVUsbUrbNext->pUrb)
1257	pVUsbUrbNext = RTListGetNext(pUrbLst, pVUsbUrb, VUSBURBVUSBINT, NdLst);
1258	vusbUrbRipe(pRipe);
1259	}
1260	}
1261
1262	/* next */
1263	pVUsbUrb = pVUsbUrbNext;
1264	}
1265	}
1266
1267	/**
1268	* Reap URBs on a per device level.
1269	*
1270	* @returns nothing.
1271	* @param pDev The device instance to reap URBs for.
1272	* @param cMillies Number of milliseconds to block in each reap operation.
1273	* Use 0 to not block at all.
1274	*/
1275	void vusbUrbDoReapAsyncDev(PVUSBDEV pDev, RTMSINTERVAL cMillies)
1276	{
1277	Assert(pDev->enmState != VUSB_DEVICE_STATE_RESET);
1278
1279	/*
1280	* Reap most URBs pending on a single device.
1281	*/
1282	PVUSBURB pRipe;
1283
1284	/**
1285	* This is workaround for race(should be fixed) detach on one EMT thread and frame boundary timer on other
1286	* and leaked URBs (shouldn't be affected by leaked URBs).
1287	*/
1288
1289	if (ASMAtomicXchgBool(&pDev->fWokenUp, false))
1290	return;
1291
1292	Assert(pDev->pUsbIns);
1293	while ( pDev->pUsbIns
1294	&& ((pRipe = pDev->pUsbIns->pReg->pfnUrbReap(pDev->pUsbIns, cMillies)) != NULL))
1295	{
1296	vusbUrbAssert(pRipe);
1297	vusbUrbRipe(pRipe);
1298	if (ASMAtomicXchgBool(&pDev->fWokenUp, false))
1299	break;
1300	}
1301	}
1302
1303	/**
1304	* Completes the URB.
1305	*/
1306	static void vusbUrbCompletion(PVUSBURB pUrb)
1307	{
1308	Assert(pUrb->pVUsb->pDev->aPipes);
1309	ASMAtomicDecU32(&pUrb->pVUsb->pDev->aPipes[pUrb->EndPt].async);
1310
1311	if (pUrb->enmState == VUSBURBSTATE_REAPED)
1312	vusbUrbUnlink(pUrb);
1313	#ifdef VBOX_WITH_USB
1314	// Read-ahead URBs are handled differently
1315	if (pUrb->pVUsb->pvBuffered)
1316	vusbBufferedPipeCompleteUrb(pUrb);
1317	else
1318	#endif
1319	vusbUrbCompletionRh(pUrb);
1320	}
1321
1322	/**
1323	* The worker for vusbUrbCancel() which is executed on the I/O thread.
1324	*
1325	* @returns IPRT status code.
1326	* @param pUrb The URB to cancel.
1327	* @param enmMode The way the URB should be canceled.
1328	*/
1329	DECLHIDDEN(int) vusbUrbCancelWorker(PVUSBURB pUrb, CANCELMODE enmMode)
1330	{
1331	vusbUrbAssert(pUrb);
1332	#ifdef VBOX_WITH_STATISTICS
1333	PVUSBROOTHUB pRh = vusbDevGetRh(pUrb->pVUsb->pDev);
1334	#endif
1335	if (pUrb->enmState == VUSBURBSTATE_IN_FLIGHT)
1336	{
1337	LogFlow(("%s: vusbUrbCancel: Canceling in-flight\n", pUrb->pszDesc));
1338	STAM_COUNTER_INC(&pRh->Total.StatUrbsCancelled);
1339	if (pUrb->enmType != VUSBXFERTYPE_MSG)
1340	{
1341	STAM_STATS({Assert(pUrb->enmType >= 0 && pUrb->enmType < (int)RT_ELEMENTS(pRh->aTypes));});
1342	STAM_COUNTER_INC(&pRh->aTypes[pUrb->enmType].StatUrbsCancelled);
1343	}
1344
1345	pUrb->enmState = VUSBURBSTATE_CANCELLED;
1346	PPDMUSBINS pUsbIns = pUrb->pVUsb->pDev->pUsbIns;
1347	pUsbIns->pReg->pfnUrbCancel(pUsbIns, pUrb);
1348	Assert(pUrb->enmState == VUSBURBSTATE_CANCELLED \|\| pUrb->enmState == VUSBURBSTATE_REAPED);
1349
1350	pUrb->enmStatus = VUSBSTATUS_CRC;
1351	vusbUrbCompletion(pUrb);
1352	}
1353	else if (pUrb->enmState == VUSBURBSTATE_REAPED)
1354	{
1355	LogFlow(("%s: vusbUrbCancel: Canceling reaped urb\n", pUrb->pszDesc));
1356	STAM_COUNTER_INC(&pRh->Total.StatUrbsCancelled);
1357	if (pUrb->enmType != VUSBXFERTYPE_MSG)
1358	{
1359	STAM_STATS({Assert(pUrb->enmType >= 0 && pUrb->enmType < (int)RT_ELEMENTS(pRh->aTypes));});
1360	STAM_COUNTER_INC(&pRh->aTypes[pUrb->enmType].StatUrbsCancelled);
1361	}
1362
1363	pUrb->enmStatus = VUSBSTATUS_CRC;
1364	vusbUrbCompletion(pUrb);
1365	}
1366	else
1367	{
1368	AssertMsg(pUrb->enmState == VUSBURBSTATE_CANCELLED, ("Invalid state %d, pUrb=%p\n", pUrb->enmState, pUrb));
1369	switch (enmMode)
1370	{
1371	default:
1372	AssertMsgFailed(("Invalid cancel mode\n"));
1373	case CANCELMODE_FAIL:
1374	pUrb->enmStatus = VUSBSTATUS_CRC;
1375	break;
1376	case CANCELMODE_UNDO:
1377	pUrb->enmStatus = VUSBSTATUS_UNDO;
1378	break;
1379
1380	}
1381	}
1382	return VINF_SUCCESS;
1383	}
1384
1385	/**
1386	* Cancels an URB with CRC failure.
1387	*
1388	* Cancelling an URB is a tricky thing. The USBProxy backend can not
1389	* all cancel it and we must keep the URB around until it's ripe and
1390	* can be reaped the normal way. However, we must complete the URB
1391	* now, before leaving this function. This is not nice. sigh.
1392	*
1393	* This function will cancel the URB if it's in-flight and complete
1394	* it. The device will in its pfnCancel method be given the chance to
1395	* say that the URB doesn't need reaping and should be unlinked.
1396	*
1397	* An URB which is in the cancel state after pfnCancel will remain in that
1398	* state and in the async list until its reaped. When it's finally reaped
1399	* it will be unlinked and freed without doing any completion.
1400	*
1401	* There are different modes of canceling an URB. When devices are being
1402	* disconnected etc., they will be completed with an error (CRC). However,
1403	* when the HC needs to temporarily halt communication with a device, the
1404	* URB/TD must be left alone if possible.
1405	*
1406	* @param pUrb The URB to cancel.
1407	* @param mode The way the URB should be canceled.
1408	*/
1409	void vusbUrbCancel(PVUSBURB pUrb, CANCELMODE mode)
1410	{
1411	int rc = vusbDevIoThreadExecSync(pUrb->pVUsb->pDev, (PFNRT)vusbUrbCancelWorker, 2, pUrb, mode);
1412	AssertRC(rc);
1413	}
1414
1415
1416	/**
1417	* Async version of vusbUrbCancel() - doesn't wait for the cancelling to be complete.
1418	*/
1419	void vusbUrbCancelAsync(PVUSBURB pUrb, CANCELMODE mode)
1420	{
1421	/* Don't try to cancel the URB when completion is in progress at the moment. */
1422	if (!ASMAtomicXchgBool(&pUrb->fCompleting, true))
1423	{
1424	int rc = vusbDevIoThreadExec(pUrb->pVUsb->pDev, 0 /* fFlags */, (PFNRT)vusbUrbCancelWorker, 2, pUrb, mode);
1425	AssertRC(rc);
1426	}
1427	}
1428
1429
1430	/**
1431	* Deals with a ripe URB (i.e. after reaping it).
1432	*
1433	* If an URB is in the reaped or in-flight state, we'll
1434	* complete it. If it's cancelled, we'll simply free it.
1435	* Any other states should never get here.
1436	*
1437	* @param pUrb The URB.
1438	*/
1439	void vusbUrbRipe(PVUSBURB pUrb)
1440	{
1441	if ( pUrb->enmState == VUSBURBSTATE_IN_FLIGHT
1442	\|\| pUrb->enmState == VUSBURBSTATE_REAPED)
1443	{
1444	pUrb->enmState = VUSBURBSTATE_REAPED;
1445	if (!ASMAtomicXchgBool(&pUrb->fCompleting, true))
1446	vusbUrbCompletion(pUrb);
1447	}
1448	else if (pUrb->enmState == VUSBURBSTATE_CANCELLED)
1449	{
1450	vusbUrbUnlink(pUrb);
1451	LogFlow(("%s: vusbUrbRipe: Freeing cancelled URB\n", pUrb->pszDesc));
1452	pUrb->pVUsb->pfnFree(pUrb);
1453	}
1454	else
1455	AssertMsgFailed(("Invalid URB state %d; %s\n", pUrb->enmState, pUrb->pszDesc));
1456	}
1457
1458
1459	/*
1460	* Local Variables:
1461	* mode: c
1462	* c-file-style: "bsd"
1463	* c-basic-offset: 4
1464	* tab-width: 4
1465	* indent-tabs-mode: s
1466	* End:
1467	*/
1468

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

source: vbox/trunk/src/VBox/Devices/USB/VUSBUrb.cpp@ 59796

Download in other formats: