VUSBUrb.cpp@ 74441

Last change on this file since 74441 was 73097, checked in by vboxsync, 6 years ago
*: Made RT_UOFFSETOF, RT_OFFSETOF, RT_UOFFSETOF_ADD and RT_OFFSETOF_ADD work like builtin_offsetof() and require compile time resolvable requests, adding RT_UOFFSETOF_DYN for the dynamic questions that can only be answered at runtime.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 50.7 KB

Line
1	/* $Id: VUSBUrb.cpp 73097 2018-07-12 21:06:33Z vboxsync $ */
2	/** @file
3	* Virtual USB - URBs.
4	*/
5
6	/*
7	* Copyright (C) 2006-2017 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	vusbRhR3ProcessFrame(pRh, true /* fCallback */);
380	}
381
382
383	/**
384	* Certain control requests must not ever be forwarded to the device because
385	* they are required by the vusb core in order to maintain the vusb internal
386	* data structures.
387	*/
388	DECLINLINE(bool) vusbUrbIsRequestSafe(PCVUSBSETUP pSetup, PVUSBURB pUrb)
389	{
390	if ((pSetup->bmRequestType & VUSB_REQ_MASK) != VUSB_REQ_STANDARD)
391	return true;
392
393	switch (pSetup->bRequest)
394	{
395	case VUSB_REQ_CLEAR_FEATURE:
396	return pUrb->EndPt != 0 /* not default control pipe */
397	\|\| pSetup->wValue != 0 /* not ENDPOINT_HALT */
398	\|\| !pUrb->pVUsb->pDev->pUsbIns->pReg->pfnUsbClearHaltedEndpoint; /* not special need for backend */
399	case VUSB_REQ_SET_ADDRESS:
400	case VUSB_REQ_SET_CONFIGURATION:
401	case VUSB_REQ_GET_CONFIGURATION:
402	case VUSB_REQ_SET_INTERFACE:
403	case VUSB_REQ_GET_INTERFACE:
404	return false;
405
406	/*
407	* If the device wishes it, we'll use the cached device and
408	* configuration descriptors. (We return false when we want to use the
409	* cache. Yeah, it's a bit weird to read.)
410	*/
411	case VUSB_REQ_GET_DESCRIPTOR:
412	if ( !pUrb->pVUsb->pDev->pDescCache->fUseCachedDescriptors
413	\|\| (pSetup->bmRequestType & VUSB_RECIP_MASK) != VUSB_TO_DEVICE)
414	return true;
415	switch (pSetup->wValue >> 8)
416	{
417	case VUSB_DT_DEVICE:
418	case VUSB_DT_CONFIG:
419	return false;
420	case VUSB_DT_STRING:
421	return !pUrb->pVUsb->pDev->pDescCache->fUseCachedStringsDescriptors;
422	default:
423	return true;
424	}
425
426	default:
427	return true;
428	}
429	}
430
431
432	/**
433	* Queues an URB for asynchronous transfer.
434	* A list of asynchronous URBs is kept by the roothub.
435	*
436	* @returns VBox status code (from pfnUrbQueue).
437	* @param pUrb The URB.
438	*/
439	int vusbUrbQueueAsyncRh(PVUSBURB pUrb)
440	{
441	#ifdef LOG_ENABLED
442	vusbUrbTrace(pUrb, "vusbUrbQueueAsyncRh", false);
443	#endif
444
445	/* Immediately return in case of error.
446	* XXX There is still a race: The Rh might vanish after this point! */
447	PVUSBDEV pDev = pUrb->pVUsb->pDev;
448	PVUSBROOTHUB pRh = vusbDevGetRh(pDev);
449	if (!pRh)
450	{
451	Log(("vusbUrbQueueAsyncRh returning VERR_OBJECT_DESTROYED\n"));
452	return VERR_OBJECT_DESTROYED;
453	}
454
455	RTCritSectEnter(&pDev->CritSectAsyncUrbs);
456	int rc = pDev->pUsbIns->pReg->pfnUrbQueue(pDev->pUsbIns, pUrb);
457	if (RT_FAILURE(rc))
458	{
459	LogFlow(("%s: vusbUrbQueueAsyncRh: returns %Rrc (queue_urb)\n", pUrb->pszDesc, rc));
460	RTCritSectLeave(&pDev->CritSectAsyncUrbs);
461	return rc;
462	}
463
464	ASMAtomicIncU32(&pDev->aPipes[pUrb->EndPt].async);
465
466	/* Queue the Urb on the roothub */
467	RTListAppend(&pDev->LstAsyncUrbs, &pUrb->pVUsb->NdLst);
468	RTCritSectLeave(&pDev->CritSectAsyncUrbs);
469
470	return VINF_SUCCESS;
471	}
472
473
474	/**
475	* Send a control message synchronously.
476	* @return
477	*/
478	static void vusbMsgSubmitSynchronously(PVUSBURB pUrb, bool fSafeRequest)
479	{
480	PVUSBDEV pDev = pUrb->pVUsb->pDev;
481	Assert(pDev);
482	PVUSBPIPE pPipe = &pDev->aPipes[pUrb->EndPt];
483	PVUSBCTRLEXTRA pExtra = pPipe->pCtrl;
484	PVUSBSETUP pSetup = pExtra->pMsg;
485	LogFlow(("%s: vusbMsgSubmitSynchronously: pDev=%p[%s]\n", pUrb->pszDesc, pDev, pDev->pUsbIns ? pDev->pUsbIns->pszName : ""));
486
487	uint8_t pbData = (uint8_t )pExtra->pMsg + sizeof(*pSetup);
488	uint32_t cbData = pSetup->wLength;
489	bool fOk = false;
490	if (!fSafeRequest)
491	fOk = vusbDevStandardRequest(pDev, pUrb->EndPt, pSetup, pbData, &cbData);
492	else
493	AssertMsgFailed(("oops\n"));
494
495	pUrb->enmState = VUSBURBSTATE_REAPED;
496	if (fOk)
497	{
498	pSetup->wLength = cbData;
499	pUrb->enmStatus = VUSBSTATUS_OK;
500	pExtra->fOk = true;
501	}
502	else
503	{
504	pUrb->enmStatus = VUSBSTATUS_STALL;
505	pExtra->fOk = false;
506	}
507	pExtra->cbLeft = cbData; /* used by IN only */
508
509	vusbCtrlCompletion(pUrb);
510	vusbUrbCompletionRh(pUrb);
511
512	/*
513	* 'Free' the message URB, i.e. put it back to the allocated state.
514	*/
515	pExtra->Urb.enmState = VUSBURBSTATE_ALLOCATED;
516	pExtra->Urb.fCompleting = false;
517	}
518
519	/**
520	* Callback for dealing with device reset.
521	*/
522	void vusbMsgResetExtraData(PVUSBCTRLEXTRA pExtra)
523	{
524	if (!pExtra)
525	return;
526	pExtra->enmStage = CTLSTAGE_SETUP;
527	if (pExtra->Urb.enmState != VUSBURBSTATE_CANCELLED)
528	{
529	pExtra->Urb.enmState = VUSBURBSTATE_ALLOCATED;
530	pExtra->Urb.fCompleting = false;
531	}
532	}
533
534
535	/**
536	* Callback to free a cancelled message URB.
537	*
538	* This is yet another place we're we have to performance acrobatics to
539	* deal with cancelled URBs. sigh.
540	*
541	* The deal here is that we never free message URBs since they are integrated
542	* into the message pipe state. But since cancel can leave URBs unreaped and in
543	* a state which require them not to be freed, we'll have to do two things.
544	* First, if a new message URB is processed we'll have to get a new message
545	* pipe state. Second, we cannot just free the damn state structure because
546	* that might lead to heap corruption since it might still be in-flight.
547	*
548	* The URB embedded into the message pipe control structure will start in an
549	* ALLOCATED state. When submitted it will be go to the IN-FLIGHT state. When
550	* reaped it will go from REAPED to ALLOCATED. When completed in the CANCELLED
551	* state it will remain in that state (as does normal URBs).
552	*
553	* If a new message urb comes up while it's in the CANCELLED state, we will
554	* orphan it and it will be freed here in vusbMsgFreeUrb. We indicate this
555	* by setting pVUsb->pvFreeCtx to NULL.
556	*
557	* If we have to free the message state structure because of device destruction,
558	* configuration changes, or similar, we will orphan the message pipe state in
559	* the same way by setting pVUsb->pvFreeCtx to NULL and let this function free it.
560	*
561	* @param pUrb
562	*/
563	static DECLCALLBACK(void) vusbMsgFreeUrb(PVUSBURB pUrb)
564	{
565	vusbUrbAssert(pUrb);
566	PVUSBCTRLEXTRA pExtra = (PVUSBCTRLEXTRA)((uint8_t *)pUrb - RT_UOFFSETOF(VUSBCTRLEXTRA, Urb));
567	if ( pUrb->enmState == VUSBURBSTATE_CANCELLED
568	&& !pUrb->pVUsb->pvFreeCtx)
569	{
570	LogFlow(("vusbMsgFreeUrb: Freeing orphan: %p (pUrb=%p)\n", pExtra, pUrb));
571	RTMemFree(pExtra);
572	}
573	else
574	{
575	Assert(pUrb->pVUsb->pvFreeCtx == &pExtra->Urb);
576	pUrb->enmState = VUSBURBSTATE_ALLOCATED;
577	pUrb->fCompleting = false;
578	}
579	}
580
581	/**
582	* Frees the extra state data associated with a message pipe.
583	*
584	* @param pExtra The data.
585	*/
586	void vusbMsgFreeExtraData(PVUSBCTRLEXTRA pExtra)
587	{
588	if (!pExtra)
589	return;
590	if (pExtra->Urb.enmState != VUSBURBSTATE_CANCELLED)
591	{
592	pExtra->Urb.u32Magic = 0;
593	pExtra->Urb.enmState = VUSBURBSTATE_FREE;
594	if (pExtra->Urb.pszDesc)
595	RTStrFree(pExtra->Urb.pszDesc);
596	RTMemFree(pExtra);
597	}
598	else
599	pExtra->Urb.pVUsb->pvFreeCtx = NULL; /* see vusbMsgFreeUrb */
600	}
601
602	/**
603	* Allocates the extra state data required for a control pipe.
604	*
605	* @returns Pointer to the allocated and initialized state data.
606	* @returns NULL on out of memory condition.
607	* @param pUrb A URB we can copy default data from.
608	*/
609	static PVUSBCTRLEXTRA vusbMsgAllocExtraData(PVUSBURB pUrb)
610	{
611	/** @todo reuse these? */
612	PVUSBCTRLEXTRA pExtra;
613	const size_t cbMax = sizeof(VUSBURBVUSBINT) + sizeof(pExtra->Urb.abData) + sizeof(VUSBSETUP);
614	pExtra = (PVUSBCTRLEXTRA)RTMemAllocZ(RT_UOFFSETOF_DYN(VUSBCTRLEXTRA, Urb.abData[cbMax]));
615	if (pExtra)
616	{
617	pExtra->enmStage = CTLSTAGE_SETUP;
618	//pExtra->fOk = false;
619	pExtra->pMsg = (PVUSBSETUP)pExtra->Urb.abData;
620	pExtra->pbCur = (uint8_t *)(pExtra->pMsg + 1);
621	//pExtra->cbLeft = 0;
622	pExtra->cbMax = cbMax;
623
624	//pExtra->Urb.Dev.pvProxyUrb = NULL;
625	pExtra->Urb.u32Magic = VUSBURB_MAGIC;
626	pExtra->Urb.enmState = VUSBURBSTATE_ALLOCATED;
627	pExtra->Urb.fCompleting = false;
628	#ifdef LOG_ENABLED
629	RTStrAPrintf(&pExtra->Urb.pszDesc, "URB %p msg->%p", &pExtra->Urb, pUrb);
630	#endif
631	pExtra->Urb.pVUsb = (PVUSBURBVUSB)&pExtra->Urb.abData[sizeof(pExtra->Urb.abData) + sizeof(VUSBSETUP)];
632	//pExtra->Urb.pVUsb->pCtrlUrb = NULL;
633	//pExtra->Urb.pVUsb->pNext = NULL;
634	//pExtra->Urb.pVUsb->ppPrev = NULL;
635	pExtra->Urb.pVUsb->pUrb = &pExtra->Urb;
636	pExtra->Urb.pVUsb->pDev = pUrb->pVUsb->pDev;
637	pExtra->Urb.pVUsb->pfnFree = vusbMsgFreeUrb;
638	pExtra->Urb.pVUsb->pvFreeCtx = &pExtra->Urb;
639	//pExtra->Urb.Hci = {0};
640	//pExtra->Urb.Dev.pvProxyUrb = NULL;
641	pExtra->Urb.DstAddress = pUrb->DstAddress;
642	pExtra->Urb.EndPt = pUrb->EndPt;
643	pExtra->Urb.enmType = VUSBXFERTYPE_MSG;
644	pExtra->Urb.enmDir = VUSBDIRECTION_INVALID;
645	//pExtra->Urb.fShortNotOk = false;
646	pExtra->Urb.enmStatus = VUSBSTATUS_INVALID;
647	//pExtra->Urb.cbData = 0;
648	vusbUrbAssert(&pExtra->Urb);
649	}
650	return pExtra;
651	}
652
653	/**
654	* Sets up the message.
655	*
656	* The message is associated with the pipe, in what's currently called
657	* control pipe extra state data (pointed to by pPipe->pCtrl). If this
658	* is a OUT message, we will no go on collecting data URB. If it's a
659	* IN message, we'll send it and then queue any incoming data for the
660	* URBs collecting it.
661	*
662	* @returns Success indicator.
663	*/
664	static bool vusbMsgSetup(PVUSBPIPE pPipe, const void *pvBuf, uint32_t cbBuf)
665	{
666	PVUSBCTRLEXTRA pExtra = pPipe->pCtrl;
667	const VUSBSETUP *pSetupIn = (PVUSBSETUP)pvBuf;
668
669	/*
670	* Validate length.
671	*/
672	if (cbBuf < sizeof(VUSBSETUP))
673	{
674	LogFlow(("vusbMsgSetup: pPipe=%p cbBuf=%u < %u (failure) !!!\n",
675	pPipe, cbBuf, sizeof(VUSBSETUP)));
676	return false;
677	}
678
679	/*
680	* Check if we've got an cancelled message URB. Allocate a new one in that case.
681	*/
682	if (pExtra->Urb.enmState == VUSBURBSTATE_CANCELLED)
683	{
684	void *pvNew = RTMemDup(pExtra, RT_UOFFSETOF_DYN(VUSBCTRLEXTRA, Urb.abData[pExtra->cbMax]));
685	if (!pvNew)
686	{
687	Log(("vusbMsgSetup: out of memory!!! cbReq=%zu\n", RT_UOFFSETOF_DYN(VUSBCTRLEXTRA, Urb.abData[pExtra->cbMax])));
688	return false;
689	}
690	pExtra->Urb.pVUsb->pvFreeCtx = NULL;
691	LogFlow(("vusbMsgSetup: Replacing canceled pExtra=%p with %p.\n", pExtra, pvNew));
692	pPipe->pCtrl = pExtra = (PVUSBCTRLEXTRA)pvNew;
693	pExtra->Urb.pVUsb = (PVUSBURBVUSB)&pExtra->Urb.abData[sizeof(pExtra->Urb.abData) + sizeof(VUSBSETUP)];
694	pExtra->Urb.pVUsb->pUrb = &pExtra->Urb;
695	pExtra->pMsg = (PVUSBSETUP)pExtra->Urb.abData;
696	pExtra->Urb.enmState = VUSBURBSTATE_ALLOCATED;
697	pExtra->Urb.fCompleting = false;
698	}
699
700	/*
701	* Check that we've got sufficient space in the message URB.
702	*/
703	if (pExtra->cbMax < cbBuf + pSetupIn->wLength + sizeof(VUSBURBVUSBINT))
704	{
705	uint32_t cbReq = RT_ALIGN_32(cbBuf + pSetupIn->wLength + sizeof(VUSBURBVUSBINT), 1024);
706	PVUSBCTRLEXTRA pNew = (PVUSBCTRLEXTRA)RTMemRealloc(pExtra, RT_UOFFSETOF_DYN(VUSBCTRLEXTRA, Urb.abData[cbReq]));
707	if (!pNew)
708	{
709	Log(("vusbMsgSetup: out of memory!!! cbReq=%u %zu\n",
710	cbReq, RT_UOFFSETOF_DYN(VUSBCTRLEXTRA, Urb.abData[cbReq])));
711	return false;
712	}
713	if (pExtra != pNew)
714	{
715	pNew->pMsg = (PVUSBSETUP)pNew->Urb.abData;
716	pExtra = pNew;
717	}
718	pExtra->Urb.pVUsb = (PVUSBURBVUSB)&pExtra->Urb.abData[cbBuf + pSetupIn->wLength];
719	pExtra->Urb.pVUsb->pUrb = &pExtra->Urb;
720	pExtra->cbMax = cbReq;
721	}
722	Assert(pExtra->Urb.enmState == VUSBURBSTATE_ALLOCATED);
723
724	/*
725	* Copy the setup data and prepare for data.
726	*/
727	PVUSBSETUP pSetup = pExtra->pMsg;
728	pExtra->fSubmitted = false;
729	pExtra->Urb.enmState = VUSBURBSTATE_IN_FLIGHT;
730	pExtra->pbCur = (uint8_t *)(pSetup + 1);
731	pSetup->bmRequestType = pSetupIn->bmRequestType;
732	pSetup->bRequest = pSetupIn->bRequest;
733	pSetup->wValue = RT_LE2H_U16(pSetupIn->wValue);
734	pSetup->wIndex = RT_LE2H_U16(pSetupIn->wIndex);
735	pSetup->wLength = RT_LE2H_U16(pSetupIn->wLength);
736
737	LogFlow(("vusbMsgSetup(%p,,%d): bmRequestType=%#04x bRequest=%#04x wValue=%#06x wIndex=%#06x wLength=0x%.4x\n",
738	pPipe, cbBuf, pSetup->bmRequestType, pSetup->bRequest, pSetup->wValue, pSetup->wIndex, pSetup->wLength));
739	return true;
740	}
741
742	/**
743	* Build the message URB from the given control URB and accompanying message
744	* pipe state which we grab from the device for the URB.
745	*
746	* @param pUrb The URB to submit.
747	* @param pSetup The setup packet for the message transfer.
748	* @param pExtra Pointer to the additional state requred for a control transfer.
749	* @param pPipe The message pipe state.
750	*/
751	static void vusbMsgDoTransfer(PVUSBURB pUrb, PVUSBSETUP pSetup, PVUSBCTRLEXTRA pExtra, PVUSBPIPE pPipe)
752	{
753	RT_NOREF(pPipe);
754
755	/*
756	* Mark this transfer as sent (cleared at setup time).
757	*/
758	Assert(!pExtra->fSubmitted);
759	pExtra->fSubmitted = true;
760
761	/*
762	* Do we have to do this synchronously?
763	*/
764	bool fSafeRequest = vusbUrbIsRequestSafe(pSetup, pUrb);
765	if (!fSafeRequest)
766	{
767	vusbMsgSubmitSynchronously(pUrb, fSafeRequest);
768	return;
769	}
770
771	/*
772	* Do it asynchronously.
773	*/
774	LogFlow(("%s: vusbMsgDoTransfer: ep=%d pMsgUrb=%p pPipe=%p stage=%s\n",
775	pUrb->pszDesc, pUrb->EndPt, &pExtra->Urb, pPipe, g_apszCtlStates[pExtra->enmStage]));
776	Assert(pExtra->Urb.enmType == VUSBXFERTYPE_MSG);
777	Assert(pExtra->Urb.EndPt == pUrb->EndPt);
778	pExtra->Urb.enmDir = (pSetup->bmRequestType & VUSB_DIR_TO_HOST) ? VUSBDIRECTION_IN : VUSBDIRECTION_OUT;
779	pExtra->Urb.cbData = pSetup->wLength + sizeof(*pSetup);
780	pExtra->Urb.pVUsb->pCtrlUrb = pUrb;
781	int rc = vusbUrbQueueAsyncRh(&pExtra->Urb);
782	if (RT_FAILURE(rc))
783	{
784	/*
785	* If we fail submitting it, will not retry but fail immediately.
786	*
787	* This keeps things simple. The host OS will have retried if
788	* it's a proxied device, and if it's a virtual one it really means
789	* it if it's failing a control message.
790	*/
791	LogFlow(("%s: vusbMsgDoTransfer: failed submitting urb! failing it with %s (rc=%Rrc)!!!\n",
792	pUrb->pszDesc, rc == VERR_VUSB_DEVICE_NOT_ATTACHED ? "DNR" : "CRC", rc));
793	pExtra->Urb.enmStatus = rc == VERR_VUSB_DEVICE_NOT_ATTACHED ? VUSBSTATUS_DNR : VUSBSTATUS_CRC;
794	pExtra->Urb.enmState = VUSBURBSTATE_REAPED;
795	vusbMsgCompletion(&pExtra->Urb);
796	}
797	}
798
799	/**
800	* Fails a URB request with a pipe STALL error.
801	*
802	* @returns VINF_SUCCESS indicating that we've completed the URB.
803	* @param pUrb The URB in question.
804	*/
805	static int vusbMsgStall(PVUSBURB pUrb)
806	{
807	PVUSBPIPE pPipe = &pUrb->pVUsb->pDev->aPipes[pUrb->EndPt];
808	PVUSBCTRLEXTRA pExtra = pPipe->pCtrl;
809	LogFlow(("%s: vusbMsgStall: pPipe=%p err=STALL stage %s->SETUP\n",
810	pUrb->pszDesc, pPipe, g_apszCtlStates[pExtra->enmStage]));
811
812	pExtra->pbCur = NULL;
813	pExtra->enmStage = CTLSTAGE_SETUP;
814	pUrb->enmState = VUSBURBSTATE_REAPED;
815	pUrb->enmStatus = VUSBSTATUS_STALL;
816	vusbUrbCompletionRh(pUrb);
817	return VINF_SUCCESS;
818	}
819
820	/**
821	* Submit a control message.
822	*
823	* Here we implement the USB defined traffic that occurs in message pipes
824	* (aka control endpoints). We want to provide a single function for device
825	* drivers so that they don't all have to reimplement the usb logic for
826	* themselves. This means we need to keep a little bit of state information
827	* because control transfers occur over multiple bus transactions. We may
828	* also need to buffer data over multiple data stages.
829	*
830	* @returns VBox status code.
831	* @param pUrb The URB to submit.
832	*/
833	static int vusbUrbSubmitCtrl(PVUSBURB pUrb)
834	{
835	#ifdef LOG_ENABLED
836	vusbUrbTrace(pUrb, "vusbUrbSubmitCtrl", false);
837	#endif
838	PVUSBDEV pDev = pUrb->pVUsb->pDev;
839	PVUSBPIPE pPipe = &pDev->aPipes[pUrb->EndPt];
840
841	RTCritSectEnter(&pPipe->CritSectCtrl);
842	PVUSBCTRLEXTRA pExtra = pPipe->pCtrl;
843
844	if (!pExtra && !(pExtra = pPipe->pCtrl = vusbMsgAllocExtraData(pUrb)))
845	{
846	RTCritSectLeave(&pPipe->CritSectCtrl);
847	return VERR_VUSB_NO_URB_MEMORY;
848	}
849	PVUSBSETUP pSetup = pExtra->pMsg;
850
851	if (pPipe->async)
852	{
853	AssertMsgFailed(("%u\n", pPipe->async));
854	RTCritSectLeave(&pPipe->CritSectCtrl);
855	return VERR_GENERAL_FAILURE;
856	}
857
858	/*
859	* A setup packet always resets the transaction and the
860	* end of data transmission is signified by change in
861	* data direction.
862	*/
863	if (pUrb->enmDir == VUSBDIRECTION_SETUP)
864	{
865	LogFlow(("%s: vusbUrbSubmitCtrl: pPipe=%p state %s->SETUP\n",
866	pUrb->pszDesc, pPipe, g_apszCtlStates[pExtra->enmStage]));
867	pExtra->enmStage = CTLSTAGE_SETUP;
868	}
869	else if ( pExtra->enmStage == CTLSTAGE_DATA
870	/* (the STATUS stage direction goes the other way) */
871	&& !!(pSetup->bmRequestType & VUSB_DIR_TO_HOST) != (pUrb->enmDir == VUSBDIRECTION_IN))
872	{
873	LogFlow(("%s: vusbUrbSubmitCtrl: pPipe=%p state %s->STATUS\n",
874	pUrb->pszDesc, pPipe, g_apszCtlStates[pExtra->enmStage]));
875	pExtra->enmStage = CTLSTAGE_STATUS;
876	}
877
878	/*
879	* Act according to the current message stage.
880	*/
881	switch (pExtra->enmStage)
882	{
883	case CTLSTAGE_SETUP:
884	/*
885	* When stall handshake is returned, all subsequent packets
886	* must generate stall until a setup packet arrives.
887	*/
888	if (pUrb->enmDir != VUSBDIRECTION_SETUP)
889	{
890	Log(("%s: vusbUrbSubmitCtrl: Stall at setup stage (dir=%#x)!!\n", pUrb->pszDesc, pUrb->enmDir));
891	vusbMsgStall(pUrb);
892	break;
893	}
894
895	/* Store setup details, return DNR if corrupt */
896	if (!vusbMsgSetup(pPipe, pUrb->abData, pUrb->cbData))
897	{
898	pUrb->enmState = VUSBURBSTATE_REAPED;
899	pUrb->enmStatus = VUSBSTATUS_DNR;
900	vusbUrbCompletionRh(pUrb);
901	break;
902	}
903	if (pPipe->pCtrl != pExtra)
904	{
905	pExtra = pPipe->pCtrl;
906	pSetup = pExtra->pMsg;
907	}
908
909	/* pre-buffer our output if it's device-to-host */
910	if (pSetup->bmRequestType & VUSB_DIR_TO_HOST)
911	vusbMsgDoTransfer(pUrb, pSetup, pExtra, pPipe);
912	else if (pSetup->wLength)
913	{
914	LogFlow(("%s: vusbUrbSubmitCtrl: stage=SETUP - to dev: need data\n", pUrb->pszDesc));
915	pUrb->enmState = VUSBURBSTATE_REAPED;
916	vusbMsgSetupCompletion(pUrb);
917	vusbUrbCompletionRh(pUrb);
918	}
919	/*
920	* If there is no DATA stage, we must send it now since there are
921	* no requirement of a STATUS stage.
922	*/
923	else
924	{
925	LogFlow(("%s: vusbUrbSubmitCtrl: stage=SETUP - to dev: sending\n", pUrb->pszDesc));
926	vusbMsgDoTransfer(pUrb, pSetup, pExtra, pPipe);
927	}
928	break;
929
930	case CTLSTAGE_DATA:
931	{
932	/*
933	* If a data stage exceeds the target buffer indicated in
934	* setup return stall, if data stage returns stall there
935	* will be no status stage.
936	*/
937	uint8_t pbData = (uint8_t )(pExtra->pMsg + 1);
938	if (&pExtra->pbCur[pUrb->cbData] > &pbData[pSetup->wLength])
939	{
940	if (!pSetup->wLength) /* happens during iPhone detection with iTunes (correct?) */
941	{
942	Log(("%s: vusbUrbSubmitCtrl: pSetup->wLength == 0!! (iPhone)\n", pUrb->pszDesc));
943	pSetup->wLength = pUrb->cbData;
944	}
945
946	/* Variable length data transfers */
947	if ( (pSetup->bmRequestType & VUSB_DIR_TO_HOST)
948	\|\| pSetup->wLength == 0
949	\|\| (pUrb->cbData % pSetup->wLength) == 0) /* magic which need explaining... */
950	{
951	uint8_t *pbEnd = pbData + pSetup->wLength;
952	int cbLeft = pbEnd - pExtra->pbCur;
953	LogFlow(("%s: vusbUrbSubmitCtrl: Var DATA, pUrb->cbData %d -> %d\n", pUrb->pszDesc, pUrb->cbData, cbLeft));
954	pUrb->cbData = cbLeft;
955	}
956	else
957	{
958	Log(("%s: vusbUrbSubmitCtrl: Stall at data stage!!\n", pUrb->pszDesc));
959	vusbMsgStall(pUrb);
960	break;
961	}
962	}
963
964	if (pUrb->enmDir == VUSBDIRECTION_IN)
965	{
966	/* put data received from the device. */
967	const uint32_t cbRead = RT_MIN(pUrb->cbData, pExtra->cbLeft);
968	memcpy(pUrb->abData, pExtra->pbCur, cbRead);
969
970	/* advance */
971	pExtra->pbCur += cbRead;
972	if (pUrb->cbData == cbRead)
973	pExtra->cbLeft -= pUrb->cbData;
974	else
975	{
976	/* adjust the pUrb->cbData to reflect the number of bytes containing actual data. */
977	LogFlow(("%s: vusbUrbSubmitCtrl: adjusting last DATA pUrb->cbData, %d -> %d\n",
978	pUrb->pszDesc, pUrb->cbData, pExtra->cbLeft));
979	pUrb->cbData = cbRead;
980	pExtra->cbLeft = 0;
981	}
982	}
983	else
984	{
985	/* get data for sending when completed. */
986	memcpy(pExtra->pbCur, pUrb->abData, pUrb->cbData);
987
988	/* advance */
989	pExtra->pbCur += pUrb->cbData;
990
991	/*
992	* If we've got the necessary data, we'll send it now since there are
993	* no requirement of a STATUS stage.
994	*/
995	if ( !pExtra->fSubmitted
996	&& pExtra->pbCur - pbData >= pSetup->wLength)
997	{
998	LogFlow(("%s: vusbUrbSubmitCtrl: stage=DATA - to dev: sending\n", pUrb->pszDesc));
999	vusbMsgDoTransfer(pUrb, pSetup, pExtra, pPipe);
1000	break;
1001	}
1002	}
1003
1004	pUrb->enmState = VUSBURBSTATE_REAPED;
1005	vusbMsgDataCompletion(pUrb);
1006	vusbUrbCompletionRh(pUrb);
1007	break;
1008	}
1009
1010	case CTLSTAGE_STATUS:
1011	if ( (pSetup->bmRequestType & VUSB_DIR_TO_HOST)
1012	\|\| pExtra->fSubmitted)
1013	{
1014	Assert(pExtra->fSubmitted);
1015	pUrb->enmState = VUSBURBSTATE_REAPED;
1016	vusbMsgStatusCompletion(pUrb);
1017	vusbUrbCompletionRh(pUrb);
1018	}
1019	else
1020	{
1021	LogFlow(("%s: vusbUrbSubmitCtrl: stage=STATUS - to dev: sending\n", pUrb->pszDesc));
1022	vusbMsgDoTransfer(pUrb, pSetup, pExtra, pPipe);
1023	}
1024	break;
1025	}
1026
1027	RTCritSectLeave(&pPipe->CritSectCtrl);
1028	return VINF_SUCCESS;
1029	}
1030
1031
1032	/**
1033	* Submit a interrupt URB.
1034	*
1035	* @returns VBox status code.
1036	* @param pUrb The URB to submit.
1037	*/
1038	static int vusbUrbSubmitInterrupt(PVUSBURB pUrb)
1039	{
1040	LogFlow(("%s: vusbUrbSubmitInterrupt: (sync)\n", pUrb->pszDesc));
1041	return vusbUrbQueueAsyncRh(pUrb);
1042	}
1043
1044
1045	/**
1046	* Submit a bulk URB.
1047	*
1048	* @returns VBox status code.
1049	* @param pUrb The URB to submit.
1050	*/
1051	static int vusbUrbSubmitBulk(PVUSBURB pUrb)
1052	{
1053	LogFlow(("%s: vusbUrbSubmitBulk: (async)\n", pUrb->pszDesc));
1054	return vusbUrbQueueAsyncRh(pUrb);
1055	}
1056
1057
1058	/**
1059	* Submit an isochronous URB.
1060	*
1061	* @returns VBox status code.
1062	* @param pUrb The URB to submit.
1063	*/
1064	static int vusbUrbSubmitIsochronous(PVUSBURB pUrb)
1065	{
1066	LogFlow(("%s: vusbUrbSubmitIsochronous: (async)\n", pUrb->pszDesc));
1067	return vusbUrbQueueAsyncRh(pUrb);
1068	}
1069
1070
1071	/**
1072	* Fail a URB with a 'hard-error' sort of error.
1073	*
1074	* @return VINF_SUCCESS (the Urb status indicates the error).
1075	* @param pUrb The URB.
1076	*/
1077	int vusbUrbSubmitHardError(PVUSBURB pUrb)
1078	{
1079	/* FIXME: Find out the correct return code from the spec */
1080	pUrb->enmState = VUSBURBSTATE_REAPED;
1081	pUrb->enmStatus = VUSBSTATUS_DNR;
1082	vusbUrbCompletionRh(pUrb);
1083	return VINF_SUCCESS;
1084	}
1085
1086
1087	/**
1088	* Submit a URB.
1089	*/
1090	int vusbUrbSubmit(PVUSBURB pUrb)
1091	{
1092	vusbUrbAssert(pUrb);
1093	Assert(pUrb->enmState == VUSBURBSTATE_ALLOCATED);
1094	PVUSBDEV pDev = pUrb->pVUsb->pDev;
1095	PVUSBPIPE pPipe = NULL;
1096	Assert(pDev);
1097
1098	/*
1099	* Check that the device is in a valid state.
1100	*/
1101	const VUSBDEVICESTATE enmState = vusbDevGetState(pDev);
1102	if (enmState == VUSB_DEVICE_STATE_RESET)
1103	{
1104	LogRel(("VUSB: %s: power off ignored, the device is resetting!\n", pDev->pUsbIns->pszName));
1105	pUrb->enmStatus = VUSBSTATUS_DNR;
1106	/* This will postpone the TDs until we're done with the resetting. */
1107	return VERR_VUSB_DEVICE_IS_RESETTING;
1108	}
1109
1110	#ifdef LOG_ENABLED
1111	/* stamp it */
1112	pUrb->pVUsb->u64SubmitTS = RTTimeNanoTS();
1113	#endif
1114
1115	/** @todo Check max packet size here too? */
1116
1117	/*
1118	* Validate the pipe.
1119	*/
1120	if (pUrb->EndPt >= VUSB_PIPE_MAX)
1121	{
1122	Log(("%s: pDev=%p[%s]: SUBMIT: ep %i >= %i!!!\n", pUrb->pszDesc, pDev, pDev->pUsbIns->pszName, pUrb->EndPt, VUSB_PIPE_MAX));
1123	return vusbUrbSubmitHardError(pUrb);
1124	}
1125	PCVUSBDESCENDPOINTEX pEndPtDesc;
1126	switch (pUrb->enmDir)
1127	{
1128	case VUSBDIRECTION_IN:
1129	pEndPtDesc = pDev->aPipes[pUrb->EndPt].in;
1130	pPipe = &pDev->aPipes[pUrb->EndPt];
1131	break;
1132	case VUSBDIRECTION_SETUP:
1133	case VUSBDIRECTION_OUT:
1134	default:
1135	pEndPtDesc = pDev->aPipes[pUrb->EndPt].out;
1136	pPipe = &pDev->aPipes[pUrb->EndPt];
1137	break;
1138	}
1139	if (!pEndPtDesc)
1140	{
1141	Log(("%s: pDev=%p[%s]: SUBMIT: no endpoint!!! dir=%s e=%i\n",
1142	pUrb->pszDesc, pDev, pDev->pUsbIns->pszName, vusbUrbDirName(pUrb->enmDir), pUrb->EndPt));
1143	return vusbUrbSubmitHardError(pUrb);
1144	}
1145
1146	/*
1147	* Check for correct transfer types.
1148	* Our type codes are the same - what a coincidence.
1149	*/
1150	if ((pEndPtDesc->Core.bmAttributes & 0x3) != pUrb->enmType)
1151	{
1152	/* Bulk and interrupt transfers are identical on the bus level (the only difference
1153	* is in how they are scheduled by the HCD/HC) and need an exemption.
1154	* Atheros AR9271 is a known offender; its configuration descriptors include
1155	* interrupt endpoints, but drivers (Win7/8, Linux kernel pre-3.05) treat them
1156	* as bulk endpoints.
1157	*/
1158	if ( (pUrb->enmType == VUSBXFERTYPE_BULK && (pEndPtDesc->Core.bmAttributes & 0x3) == VUSBXFERTYPE_INTR)
1159	\|\| (pUrb->enmType == VUSBXFERTYPE_INTR && (pEndPtDesc->Core.bmAttributes & 0x3) == VUSBXFERTYPE_BULK))
1160	{
1161	Log2(("%s: pDev=%p[%s]: SUBMIT: mixing bulk/interrupt transfers on DstAddress=%i ep=%i dir=%s\n",
1162	pUrb->pszDesc, pDev, pDev->pUsbIns->pszName,
1163	pUrb->DstAddress, pUrb->EndPt, vusbUrbDirName(pUrb->enmDir)));
1164	}
1165	else
1166	{
1167	Log(("%s: pDev=%p[%s]: SUBMIT: %s transfer requested for %#x endpoint on DstAddress=%i ep=%i dir=%s\n",
1168	pUrb->pszDesc, pDev, pDev->pUsbIns->pszName, vusbUrbTypeName(pUrb->enmType), pEndPtDesc->Core.bmAttributes,
1169	pUrb->DstAddress, pUrb->EndPt, vusbUrbDirName(pUrb->enmDir)));
1170	return vusbUrbSubmitHardError(pUrb);
1171	}
1172	}
1173
1174	/*
1175	* If there's a URB in the read-ahead buffer, use it.
1176	*/
1177	int rc;
1178
1179	if (pDev->hSniffer)
1180	{
1181	rc = VUSBSnifferRecordEvent(pDev->hSniffer, pUrb, VUSBSNIFFEREVENT_SUBMIT);
1182	if (RT_FAILURE(rc))
1183	LogRel(("VUSB: Capturing URB submit event failed with %Rrc\n", rc));
1184	}
1185
1186	/*
1187	* Take action based on type.
1188	*/
1189	pUrb->enmState = VUSBURBSTATE_IN_FLIGHT;
1190	switch (pUrb->enmType)
1191	{
1192	case VUSBXFERTYPE_CTRL:
1193	rc = vusbUrbSubmitCtrl(pUrb);
1194	break;
1195	case VUSBXFERTYPE_BULK:
1196	rc = vusbUrbSubmitBulk(pUrb);
1197	break;
1198	case VUSBXFERTYPE_INTR:
1199	rc = vusbUrbSubmitInterrupt(pUrb);
1200	break;
1201	case VUSBXFERTYPE_ISOC:
1202	rc = vusbUrbSubmitIsochronous(pUrb);
1203	break;
1204	default:
1205	AssertMsgFailed(("Unexpected pUrb type %d\n", pUrb->enmType));
1206	return vusbUrbSubmitHardError(pUrb);
1207	}
1208
1209	/*
1210	* The device was detached, so we fail everything.
1211	* (We should really detach and destroy the device, but we'll have to wait till Main reacts.)
1212	*/
1213	if (rc == VERR_VUSB_DEVICE_NOT_ATTACHED)
1214	rc = vusbUrbSubmitHardError(pUrb);
1215	/*
1216	* We don't increment error count if async URBs are in flight, in
1217	* this case we just assume we need to throttle back, this also
1218	* makes sure we don't halt bulk endpoints at the wrong time.
1219	*/
1220	else if ( RT_FAILURE(rc)
1221	&& !ASMAtomicReadU32(&pDev->aPipes[pUrb->EndPt].async)
1222	/* && pUrb->enmType == VUSBXFERTYPE_BULK ?? */
1223	&& !vusbUrbErrorRh(pUrb))
1224	{
1225	/* don't retry it anymore. */
1226	pUrb->enmState = VUSBURBSTATE_REAPED;
1227	pUrb->enmStatus = VUSBSTATUS_CRC;
1228	vusbUrbCompletionRh(pUrb);
1229	return VINF_SUCCESS;
1230	}
1231
1232	return rc;
1233	}
1234
1235
1236	/**
1237	* Reap in-flight URBs.
1238	*
1239	* @param pUrbLst Pointer to the head of the URB list.
1240	* @param cMillies Number of milliseconds to block in each reap operation.
1241	* Use 0 to not block at all.
1242	*/
1243	void vusbUrbDoReapAsync(PRTLISTANCHOR pUrbLst, RTMSINTERVAL cMillies)
1244	{
1245	PVUSBURBVUSB pVUsbUrb = RTListGetFirst(pUrbLst, VUSBURBVUSBINT, NdLst);
1246	while (pVUsbUrb)
1247	{
1248	vusbUrbAssert(pVUsbUrb->pUrb);
1249	PVUSBURBVUSB pVUsbUrbNext = RTListGetNext(pUrbLst, pVUsbUrb, VUSBURBVUSBINT, NdLst);
1250	PVUSBDEV pDev = pVUsbUrb->pDev;
1251
1252	/* Don't touch resetting devices - paranoid safety precaution. */
1253	if (vusbDevGetState(pDev) != VUSB_DEVICE_STATE_RESET)
1254	{
1255	/*
1256	* Reap most URBs pending on a single device.
1257	*/
1258	PVUSBURB pRipe;
1259
1260	/**
1261	* This is workaround for race(should be fixed) detach on one EMT thread and frame boundary timer on other
1262	* and leaked URBs (shouldn't be affected by leaked URBs).
1263	*/
1264	Assert(pDev->pUsbIns);
1265	while ( pDev->pUsbIns
1266	&& ((pRipe = pDev->pUsbIns->pReg->pfnUrbReap(pDev->pUsbIns, cMillies)) != NULL))
1267	{
1268	vusbUrbAssert(pRipe);
1269	if (pRipe == pVUsbUrbNext->pUrb)
1270	pVUsbUrbNext = RTListGetNext(pUrbLst, pVUsbUrb, VUSBURBVUSBINT, NdLst);
1271	vusbUrbRipe(pRipe);
1272	}
1273	}
1274
1275	/* next */
1276	pVUsbUrb = pVUsbUrbNext;
1277	}
1278	}
1279
1280	/**
1281	* Reap URBs on a per device level.
1282	*
1283	* @returns nothing.
1284	* @param pDev The device instance to reap URBs for.
1285	* @param cMillies Number of milliseconds to block in each reap operation.
1286	* Use 0 to not block at all.
1287	*/
1288	void vusbUrbDoReapAsyncDev(PVUSBDEV pDev, RTMSINTERVAL cMillies)
1289	{
1290	Assert(pDev->enmState != VUSB_DEVICE_STATE_RESET);
1291
1292	/*
1293	* Reap most URBs pending on a single device.
1294	*/
1295	PVUSBURB pRipe;
1296
1297	/**
1298	* This is workaround for race(should be fixed) detach on one EMT thread and frame boundary timer on other
1299	* and leaked URBs (shouldn't be affected by leaked URBs).
1300	*/
1301
1302	if (ASMAtomicXchgBool(&pDev->fWokenUp, false))
1303	return;
1304
1305	Assert(pDev->pUsbIns);
1306	while ( pDev->pUsbIns
1307	&& ((pRipe = pDev->pUsbIns->pReg->pfnUrbReap(pDev->pUsbIns, cMillies)) != NULL))
1308	{
1309	vusbUrbAssert(pRipe);
1310	vusbUrbRipe(pRipe);
1311	if (ASMAtomicXchgBool(&pDev->fWokenUp, false))
1312	break;
1313	}
1314	}
1315
1316	/**
1317	* Completes the URB.
1318	*/
1319	static void vusbUrbCompletion(PVUSBURB pUrb)
1320	{
1321	Assert(pUrb->pVUsb->pDev->aPipes);
1322	ASMAtomicDecU32(&pUrb->pVUsb->pDev->aPipes[pUrb->EndPt].async);
1323
1324	if (pUrb->enmState == VUSBURBSTATE_REAPED)
1325	vusbUrbUnlink(pUrb);
1326
1327	vusbUrbCompletionRh(pUrb);
1328	}
1329
1330	/**
1331	* The worker for vusbUrbCancel() which is executed on the I/O thread.
1332	*
1333	* @returns IPRT status code.
1334	* @param pUrb The URB to cancel.
1335	* @param enmMode The way the URB should be canceled.
1336	*/
1337	DECLHIDDEN(int) vusbUrbCancelWorker(PVUSBURB pUrb, CANCELMODE enmMode)
1338	{
1339	vusbUrbAssert(pUrb);
1340	#ifdef VBOX_WITH_STATISTICS
1341	PVUSBROOTHUB pRh = vusbDevGetRh(pUrb->pVUsb->pDev);
1342	#endif
1343	if (pUrb->enmState == VUSBURBSTATE_IN_FLIGHT)
1344	{
1345	LogFlow(("%s: vusbUrbCancel: Canceling in-flight\n", pUrb->pszDesc));
1346	STAM_COUNTER_INC(&pRh->Total.StatUrbsCancelled);
1347	if (pUrb->enmType != VUSBXFERTYPE_MSG)
1348	{
1349	STAM_STATS({Assert(pUrb->enmType >= 0 && pUrb->enmType < (int)RT_ELEMENTS(pRh->aTypes));});
1350	STAM_COUNTER_INC(&pRh->aTypes[pUrb->enmType].StatUrbsCancelled);
1351	}
1352
1353	pUrb->enmState = VUSBURBSTATE_CANCELLED;
1354	PPDMUSBINS pUsbIns = pUrb->pVUsb->pDev->pUsbIns;
1355	pUsbIns->pReg->pfnUrbCancel(pUsbIns, pUrb);
1356	Assert(pUrb->enmState == VUSBURBSTATE_CANCELLED \|\| pUrb->enmState == VUSBURBSTATE_REAPED);
1357
1358	pUrb->enmStatus = VUSBSTATUS_CRC;
1359	vusbUrbCompletion(pUrb);
1360	}
1361	else if (pUrb->enmState == VUSBURBSTATE_REAPED)
1362	{
1363	LogFlow(("%s: vusbUrbCancel: Canceling reaped urb\n", pUrb->pszDesc));
1364	STAM_COUNTER_INC(&pRh->Total.StatUrbsCancelled);
1365	if (pUrb->enmType != VUSBXFERTYPE_MSG)
1366	{
1367	STAM_STATS({Assert(pUrb->enmType >= 0 && pUrb->enmType < (int)RT_ELEMENTS(pRh->aTypes));});
1368	STAM_COUNTER_INC(&pRh->aTypes[pUrb->enmType].StatUrbsCancelled);
1369	}
1370
1371	pUrb->enmStatus = VUSBSTATUS_CRC;
1372	vusbUrbCompletion(pUrb);
1373	}
1374	else
1375	{
1376	AssertMsg(pUrb->enmState == VUSBURBSTATE_CANCELLED, ("Invalid state %d, pUrb=%p\n", pUrb->enmState, pUrb));
1377	switch (enmMode)
1378	{
1379	default:
1380	AssertMsgFailed(("Invalid cancel mode\n"));
1381	RT_FALL_THRU();
1382	case CANCELMODE_FAIL:
1383	pUrb->enmStatus = VUSBSTATUS_CRC;
1384	break;
1385	case CANCELMODE_UNDO:
1386	pUrb->enmStatus = VUSBSTATUS_UNDO;
1387	break;
1388
1389	}
1390	}
1391	return VINF_SUCCESS;
1392	}
1393
1394	/**
1395	* Cancels an URB with CRC failure.
1396	*
1397	* Cancelling an URB is a tricky thing. The USBProxy backend can not
1398	* all cancel it and we must keep the URB around until it's ripe and
1399	* can be reaped the normal way. However, we must complete the URB
1400	* now, before leaving this function. This is not nice. sigh.
1401	*
1402	* This function will cancel the URB if it's in-flight and complete
1403	* it. The device will in its pfnCancel method be given the chance to
1404	* say that the URB doesn't need reaping and should be unlinked.
1405	*
1406	* An URB which is in the cancel state after pfnCancel will remain in that
1407	* state and in the async list until its reaped. When it's finally reaped
1408	* it will be unlinked and freed without doing any completion.
1409	*
1410	* There are different modes of canceling an URB. When devices are being
1411	* disconnected etc., they will be completed with an error (CRC). However,
1412	* when the HC needs to temporarily halt communication with a device, the
1413	* URB/TD must be left alone if possible.
1414	*
1415	* @param pUrb The URB to cancel.
1416	* @param mode The way the URB should be canceled.
1417	*/
1418	void vusbUrbCancel(PVUSBURB pUrb, CANCELMODE mode)
1419	{
1420	int rc = vusbDevIoThreadExecSync(pUrb->pVUsb->pDev, (PFNRT)vusbUrbCancelWorker, 2, pUrb, mode);
1421	AssertRC(rc);
1422	}
1423
1424
1425	/**
1426	* Async version of vusbUrbCancel() - doesn't wait for the cancelling to be complete.
1427	*/
1428	void vusbUrbCancelAsync(PVUSBURB pUrb, CANCELMODE mode)
1429	{
1430	/* Don't try to cancel the URB when completion is in progress at the moment. */
1431	if (!ASMAtomicXchgBool(&pUrb->fCompleting, true))
1432	{
1433	int rc = vusbDevIoThreadExec(pUrb->pVUsb->pDev, 0 /* fFlags */, (PFNRT)vusbUrbCancelWorker, 2, pUrb, mode);
1434	AssertRC(rc);
1435	}
1436	}
1437
1438
1439	/**
1440	* Deals with a ripe URB (i.e. after reaping it).
1441	*
1442	* If an URB is in the reaped or in-flight state, we'll
1443	* complete it. If it's cancelled, we'll simply free it.
1444	* Any other states should never get here.
1445	*
1446	* @param pUrb The URB.
1447	*/
1448	void vusbUrbRipe(PVUSBURB pUrb)
1449	{
1450	if ( pUrb->enmState == VUSBURBSTATE_IN_FLIGHT
1451	\|\| pUrb->enmState == VUSBURBSTATE_REAPED)
1452	{
1453	pUrb->enmState = VUSBURBSTATE_REAPED;
1454	if (!ASMAtomicXchgBool(&pUrb->fCompleting, true))
1455	vusbUrbCompletion(pUrb);
1456	}
1457	else if (pUrb->enmState == VUSBURBSTATE_CANCELLED)
1458	{
1459	vusbUrbUnlink(pUrb);
1460	LogFlow(("%s: vusbUrbRipe: Freeing cancelled URB\n", pUrb->pszDesc));
1461	pUrb->pVUsb->pfnFree(pUrb);
1462	}
1463	else
1464	AssertMsgFailed(("Invalid URB state %d; %s\n", pUrb->enmState, pUrb->pszDesc));
1465	}
1466
1467
1468	/*
1469	* Local Variables:
1470	* mode: c
1471	* c-file-style: "bsd"
1472	* c-basic-offset: 4
1473	* tab-width: 4
1474	* indent-tabs-mode: s
1475	* End:
1476	*/
1477

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

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

Download in other formats: