USBProxyDevice-darwin.cpp@ 69498

Last change on this file since 69498 was 69498, checked in by vboxsync, 7 years ago
backed out r118835 as it incorrectly updated the 'This file is based on' file headers.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 73.8 KB

Line
1	/* $Id: USBProxyDevice-darwin.cpp 69498 2017-10-28 15:07:25Z vboxsync $ */
2	/** @file
3	* USB device proxy - the Darwin backend.
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_USBPROXY
23	#define __STDC_LIMIT_MACROS
24	#define __STDC_CONSTANT_MACROS
25
26	#include <mach/mach.h>
27	#include <Carbon/Carbon.h>
28	#include <IOKit/IOKitLib.h>
29	#include <mach/mach_error.h>
30	#include <IOKit/usb/IOUSBLib.h>
31	#include <IOKit/IOCFPlugIn.h>
32
33	#include <VBox/log.h>
34	#include <VBox/err.h>
35	#include <VBox/vmm/pdm.h>
36
37	#include <iprt/assert.h>
38	#include <iprt/critsect.h>
39	#include <iprt/list.h>
40	#include <iprt/mem.h>
41	#include <iprt/once.h>
42	#include <iprt/string.h>
43	#include <iprt/time.h>
44
45	#include "../USBProxyDevice.h"
46	#include <VBox/usblib.h>
47
48
49	/*********************************************************************************************************************************
50	* Defined Constants And Macros *
51	*********************************************************************************************************************************/
52	/** An experiment... */
53	//#define USE_LOW_LATENCY_API 1
54
55
56	/*********************************************************************************************************************************
57	* Structures and Typedefs *
58	*********************************************************************************************************************************/
59	/** Forward declaration of the Darwin interface structure. */
60	typedef struct USBPROXYIFOSX *PUSBPROXYIFOSX;
61
62
63	/**
64	* A low latency isochronous buffer.
65	*
66	* These are allocated in chunks on an interface level, see USBPROXYISOCBUFCOL.
67	*/
68	typedef struct USBPROXYISOCBUF
69	{
70	/** Whether this buffer is in use or not. */
71	bool volatile fUsed;
72	/** Pointer to the buffer. */
73	void *pvBuf;
74	/** Pointer to an array of 8 frames. */
75	IOUSBLowLatencyIsocFrame *paFrames;
76	} USBPROXYISOCBUF, *PUSBPROXYISOCBUF;
77
78
79	/**
80	* Isochronous buffer collection (associated with an interface).
81	*
82	* These are allocated in decent sized chunks and there isn't supposed
83	* to be too many of these per interface.
84	*/
85	typedef struct USBPROXYISOCBUFCOL
86	{
87	/** Write or Read buffers? */
88	USBLowLatencyBufferType enmType;
89	/** The next buffer collection on this interface. */
90	struct USBPROXYISOCBUFCOL *pNext;
91	/** The buffer. */
92	void *pvBuffer;
93	/** The frame. */
94	void *pvFrames;
95	/** The buffers.
96	* The number of buffers here is decided by pvFrame begin allocated in
97	* PAGE_SIZE chunks. The size of IOUSBLowLatencyIsocFrame is 16 bytes
98	* and we require 8 of those per buffer. PAGE_SIZE / (16 * 8) = 32.
99	* @remarks Don't allocate too many as it may temporarily halt the system if
100	* some pool is low / exhausted. (Contiguous memory woes on mach.)
101	*/
102	USBPROXYISOCBUF aBuffers[/32/ 4];
103	} USBPROXYISOCBUFCOL, *PUSBPROXYISOCBUFCOL;
104
105	AssertCompileSize(IOUSBLowLatencyIsocFrame, 16);
106
107	/**
108	* Per-urb data for the Darwin usb proxy backend.
109	*
110	* This is required to track in-flight and landed URBs
111	* since we take down the URBs in a different thread (perhaps).
112	*/
113	typedef struct USBPROXYURBOSX
114	{
115	/** Pointer to the next Darwin URB. */
116	struct USBPROXYURBOSX *pNext;
117	/** Pointer to the previous Darwin URB. */
118	struct USBPROXYURBOSX *pPrev;
119	/** The millisecond timestamp when this URB was submitted. */
120	uint64_t u64SubmitTS;
121	/** Pointer to the VUSB URB.
122	* This is set to NULL if canceled. */
123	PVUSBURB pVUsbUrb;
124	/** Pointer to the Darwin device. */
125	struct USBPROXYDEVOSX *pDevOsX;
126	/** The transfer type. */
127	VUSBXFERTYPE enmType;
128	/** Union with data depending on transfer type. */
129	union
130	{
131	/** The control message. */
132	IOUSBDevRequest ControlMsg;
133	/** The Isochronous Data. */
134	struct
135	{
136	#ifdef USE_LOW_LATENCY_API
137	/** The low latency isochronous buffer. */
138	PUSBPROXYISOCBUF pBuf;
139	/** Array of frames parallel to the one in VUSBURB. (Same as pBuf->paFrames.) */
140	IOUSBLowLatencyIsocFrame *aFrames;
141	#else
142	/** Array of frames parallel to the one in VUSBURB. */
143	IOUSBIsocFrame aFrames[8];
144	#endif
145	} Isoc;
146	} u;
147	} USBPROXYURBOSX, *PUSBPROXYURBOSX;
148
149	/**
150	* Per-pipe data for the Darwin usb proxy backend.
151	*/
152	typedef struct USBPROXYPIPEOSX
153	{
154	/** The endpoint number. */
155	uint8_t u8Endpoint;
156	/** The IOKit pipe reference. */
157	uint8_t u8PipeRef;
158	/** The pipe Transfer type type. */
159	uint8_t u8TransferType;
160	/** The pipe direction. */
161	uint8_t u8Direction;
162	/** The endpoint interval. (interrupt) */
163	uint8_t u8Interval;
164	/** Full-speed device indicator (isochronous pipes only). */
165	bool fIsFullSpeed;
166	/** The max packet size. */
167	uint16_t u16MaxPacketSize;
168	/** The next frame number (isochronous pipes only). */
169	uint64_t u64NextFrameNo;
170	} USBPROXYPIPEOSX, PUSBPROXYPIPEOSX, *PPUSBPROXYPIPEOSX;
171
172	typedef struct RUNLOOPREFLIST
173	{
174	RTLISTNODE List;
175	CFRunLoopRef RunLoopRef;
176	} RUNLOOPREFLIST, *PRUNLOOPREFLIST;
177	typedef RUNLOOPREFLIST **PPRUNLOOPREFLIST;
178
179	/**
180	* Per-interface data for the Darwin usb proxy backend.
181	*/
182	typedef struct USBPROXYIFOSX
183	{
184	/** Pointer to the next interface. */
185	struct USBPROXYIFOSX *pNext;
186	/** The interface number. */
187	uint8_t u8Interface;
188	/** The current alternative interface setting.
189	* This is used to skip unnecessary SetAltInterface calls. */
190	uint8_t u8AltSetting;
191	/** The interface class. (not really used) */
192	uint8_t u8Class;
193	/** The interface protocol. (not really used) */
194	uint8_t u8Protocol;
195	/** The number of pipes. */
196	uint8_t cPipes;
197	/** Array containing all the pipes. (Currently unsorted.) */
198	USBPROXYPIPEOSX aPipes[kUSBMaxPipes];
199	/** The IOUSBDeviceInterface. */
200	IOUSBInterfaceInterface245 **ppIfI;
201	/** The run loop source for the async operations on the interface level. */
202	CFRunLoopSourceRef RunLoopSrcRef;
203	/** List of isochronous buffer collections.
204	* These are allocated on demand by the URB queuing routine and then recycled until the interface is destroyed. */
205	RTLISTANCHOR HeadOfRunLoopLst;
206	PUSBPROXYISOCBUFCOL pIsocBufCols;
207	} USBPROXYIFOSX, PUSBPROXYIFOSX, *PPUSBPROXYIFOSX;
208	/** Pointer to a pointer to an darwin interface. */
209	typedef USBPROXYIFOSX **PPUSBPROXYIFOSX;
210
211	/**
212	* Per-device Data for the Darwin usb proxy backend.
213	*/
214	typedef struct USBPROXYDEVOSX
215	{
216	/** The USB Device IOService object. */
217	io_object_t USBDevice;
218	/** The IOUSBDeviceInterface. */
219	IOUSBDeviceInterface245 **ppDevI;
220	/** The run loop source for the async operations on the device level
221	* (i.e. the default control pipe stuff). */
222	CFRunLoopSourceRef RunLoopSrcRef;
223	/** we want to add and remove RunLoopSourceRefs to run loop's of
224	* every EMT thread participated in USB processing. */
225	RTLISTANCHOR HeadOfRunLoopLst;
226	/** Pointer to the proxy device instance. */
227	PUSBPROXYDEV pProxyDev;
228
229	/** Pointer to the first interface. */
230	PUSBPROXYIFOSX pIfHead;
231	/** Pointer to the last interface. */
232	PUSBPROXYIFOSX pIfTail;
233
234	/** Critical section protecting the lists. */
235	RTCRITSECT CritSect;
236	/** The list of free Darwin URBs. Singly linked. */
237	PUSBPROXYURBOSX pFreeHead;
238	/** The list of landed Darwin URBs. Doubly linked.
239	* Only the split head will appear in this list. */
240	PUSBPROXYURBOSX pTaxingHead;
241	/** The tail of the landed Darwin URBs. */
242	PUSBPROXYURBOSX pTaxingTail;
243	/** Last reaper runloop reference, there can be only one runloop at a time. */
244	CFRunLoopRef hRunLoopReapingLast;
245	/** Runloop source for waking up the reaper thread. */
246	CFRunLoopSourceRef hRunLoopSrcWakeRef;
247	/** List of threads used for reaping which can be woken up. */
248	RTLISTANCHOR HeadOfRunLoopWakeLst;
249	/** Runloop reference of the thread reaping. */
250	volatile CFRunLoopRef hRunLoopReaping;
251	/** Flag whether the reaping thread is about the be waked. */
252	volatile bool fReapingThreadWake;
253	} USBPROXYDEVOSX, *PUSBPROXYDEVOSX;
254
255
256	/*********************************************************************************************************************************
257	* Global Variables *
258	*********************************************************************************************************************************/
259	static RTONCE g_usbProxyDarwinOnce = RTONCE_INITIALIZER;
260	/** The runloop mode we use.
261	* Since it's difficult to remove this, we leak it to prevent crashes.
262	* @bugref{4407} */
263	static CFStringRef g_pRunLoopMode = NULL;
264	/** The IO Master Port.
265	* Not worth cleaning up. */
266	static mach_port_t g_MasterPort = MACH_PORT_NULL;
267
268
269	/**
270	* Init once callback that sets up g_MasterPort and g_pRunLoopMode.
271	*
272	* @returns IPRT status code.
273	*
274	* @param pvUser1 NULL, ignored.
275	*/
276	static DECLCALLBACK(int32_t) usbProxyDarwinInitOnce(void *pvUser1)
277	{
278	RT_NOREF(pvUser1);
279
280	int rc;
281	kern_return_t krc = IOMasterPort(MACH_PORT_NULL, &g_MasterPort);
282	if (krc == KERN_SUCCESS)
283	{
284	g_pRunLoopMode = CFStringCreateWithCString(kCFAllocatorDefault, "VBoxUsbProxyMode", kCFStringEncodingUTF8);
285	if (g_pRunLoopMode)
286	return VINF_SUCCESS;
287	rc = VERR_INTERNAL_ERROR_5;
288	}
289	else
290	rc = RTErrConvertFromDarwin(krc);
291	return rc;
292	}
293
294	/**
295	* Kicks the reaper thread if it sleeps currently to respond to state changes
296	* or to pick up completed URBs.
297	*
298	* @returns nothing.
299	* @param pDevOsX The darwin device instance data.
300	*/
301	static void usbProxyDarwinReaperKick(PUSBPROXYDEVOSX pDevOsX)
302	{
303	CFRunLoopRef hRunLoopWake = (CFRunLoopRef)ASMAtomicReadPtr((void * volatile *)&pDevOsX->hRunLoopReaping);
304	if (hRunLoopWake)
305	{
306	LogFlowFunc(("Waking runloop %p\n", hRunLoopWake));
307	CFRunLoopSourceSignal(pDevOsX->hRunLoopSrcWakeRef);
308	CFRunLoopWakeUp(hRunLoopWake);
309	}
310	}
311
312	/**
313	* Adds Source ref to current run loop and adds it the list of runloops.
314	*/
315	static int usbProxyDarwinAddRunLoopRef(PRTLISTANCHOR pListHead,
316	CFRunLoopSourceRef SourceRef)
317	{
318	AssertPtrReturn(pListHead, VERR_INVALID_PARAMETER);
319	AssertReturn(CFRunLoopSourceIsValid(SourceRef), VERR_INVALID_PARAMETER);
320
321	if (CFRunLoopContainsSource(CFRunLoopGetCurrent(), SourceRef, g_pRunLoopMode))
322	return VINF_SUCCESS;
323
324	/* Add to the list */
325	PRUNLOOPREFLIST pListNode = (PRUNLOOPREFLIST)RTMemAllocZ(sizeof(RUNLOOPREFLIST));
326	if (!pListNode)
327	return VERR_NO_MEMORY;
328
329	pListNode->RunLoopRef = CFRunLoopGetCurrent();
330
331	CFRetain(pListNode->RunLoopRef);
332	CFRetain(SourceRef); /* We want to be aware of releasing */
333
334	CFRunLoopAddSource(pListNode->RunLoopRef, SourceRef, g_pRunLoopMode);
335
336	RTListInit(&pListNode->List);
337
338	RTListAppend((PRTLISTNODE)pListHead, &pListNode->List);
339
340	return VINF_SUCCESS;
341	}
342
343
344	/*
345	* Removes all source reference from mode of run loop's we've registered them.
346	*
347	*/
348	static int usbProxyDarwinRemoveSourceRefFromAllRunLoops(PRTLISTANCHOR pHead,
349	CFRunLoopSourceRef SourceRef)
350	{
351	AssertPtrReturn(pHead, VERR_INVALID_PARAMETER);
352
353	while (!RTListIsEmpty(pHead))
354	{
355	PRUNLOOPREFLIST pNode = RTListGetFirst(pHead, RUNLOOPREFLIST, List);
356	/* XXX: Should Release Reference? */
357	Assert(CFGetRetainCount(pNode->RunLoopRef));
358
359	CFRunLoopRemoveSource(pNode->RunLoopRef, SourceRef, g_pRunLoopMode);
360	CFRelease(SourceRef);
361	CFRelease(pNode->RunLoopRef);
362
363	RTListNodeRemove(&pNode->List);
364
365	RTMemFree(pNode);
366	}
367
368	return VINF_SUCCESS;
369	}
370
371
372	/**
373	* Allocates a Darwin URB request structure.
374	*
375	* @returns Pointer to an active URB request.
376	* @returns NULL on failure.
377	*
378	* @param pDevOsX The darwin proxy device.
379	*/
380	static PUSBPROXYURBOSX usbProxyDarwinUrbAlloc(PUSBPROXYDEVOSX pDevOsX)
381	{
382	PUSBPROXYURBOSX pUrbOsX;
383
384	RTCritSectEnter(&pDevOsX->CritSect);
385
386	/*
387	* Try remove a Darwin URB from the free list, if none there allocate a new one.
388	*/
389	pUrbOsX = pDevOsX->pFreeHead;
390	if (pUrbOsX)
391	{
392	pDevOsX->pFreeHead = pUrbOsX->pNext;
393	RTCritSectLeave(&pDevOsX->CritSect);
394	}
395	else
396	{
397	RTCritSectLeave(&pDevOsX->CritSect);
398	pUrbOsX = (PUSBPROXYURBOSX)RTMemAlloc(sizeof(*pUrbOsX));
399	if (!pUrbOsX)
400	return NULL;
401	}
402	pUrbOsX->pVUsbUrb = NULL;
403	pUrbOsX->pDevOsX = pDevOsX;
404	pUrbOsX->enmType = VUSBXFERTYPE_INVALID;
405
406	return pUrbOsX;
407	}
408
409
410	#ifdef USE_LOW_LATENCY_API
411	/**
412	* Allocates an low latency isochronous buffer.
413	*
414	* @returns VBox status code.
415	* @param pUrbOsX The OsX URB to allocate it for.
416	* @param pIf The interface to allocated it from.
417	*/
418	static int usbProxyDarwinUrbAllocIsocBuf(PUSBPROXYURBOSX pUrbOsX, PUSBPROXYIFOSX pIf)
419	{
420	USBLowLatencyBufferType enmLLType = pUrbOsX->pVUsbUrb->enmDir == VUSBDIRECTION_IN
421	? kUSBLowLatencyWriteBuffer : kUSBLowLatencyReadBuffer;
422
423	/*
424	* Walk the buffer collection list and look for an unused one.
425	*/
426	pUrbOsX->u.Isoc.pBuf = NULL;
427	for (PUSBPROXYISOCBUFCOL pCur = pIf->pIsocBufCols; pCur; pCur = pCur->pNext)
428	if (pCur->enmType == enmLLType)
429	for (unsigned i = 0; i < RT_ELEMENTS(pCur->aBuffers); i++)
430	if (!pCur->aBuffers[i].fUsed)
431	{
432	pCur->aBuffers[i].fUsed = true;
433	pUrbOsX->u.Isoc.pBuf = &pCur->aBuffers[i];
434	AssertPtr(pUrbOsX->u.Isoc.pBuf);
435	AssertPtr(pUrbOsX->u.Isoc.pBuf->pvBuf);
436	pUrbOsX->u.Isoc.aFrames = pCur->aBuffers[i].paFrames;
437	AssertPtr(pUrbOsX->u.Isoc.aFrames);
438	return VINF_SUCCESS;
439	}
440
441	/*
442	* Didn't find an empty one, create a new buffer collection and take the first buffer.
443	*/
444	PUSBPROXYISOCBUFCOL pNew = (PUSBPROXYISOCBUFCOL)RTMemAllocZ(sizeof(*pNew));
445	AssertReturn(pNew, VERR_NO_MEMORY);
446
447	IOReturn irc = (pIf->ppIfI)->LowLatencyCreateBuffer(pIf->ppIfI, &pNew->pvBuffer, 8192 RT_ELEMENTS(pNew->aBuffers), enmLLType);
448	if (irc == kIOReturnSuccess != VALID_PTR(pNew->pvBuffer))
449	{
450	AssertPtr(pNew->pvBuffer);
451	irc = kIOReturnNoMemory;
452	}
453	if (irc == kIOReturnSuccess)
454	{
455	irc = (*pIf->ppIfI)->LowLatencyCreateBuffer(pIf->ppIfI, &pNew->pvFrames, PAGE_SIZE, kUSBLowLatencyFrameListBuffer);
456	if (irc == kIOReturnSuccess != VALID_PTR(pNew->pvFrames))
457	{
458	AssertPtr(pNew->pvFrames);
459	irc = kIOReturnNoMemory;
460	}
461	if (irc == kIOReturnSuccess)
462	{
463	for (unsigned i = 0; i < RT_ELEMENTS(pNew->aBuffers); i++)
464	{
465	//pNew->aBuffers[i].fUsed = false;
466	pNew->aBuffers[i].paFrames = &((IOUSBLowLatencyIsocFrame )pNew->pvFrames)[i 8];
467	pNew->aBuffers[i].pvBuf = (uint8_t )pNew->pvBuffer + i 8192;
468	}
469
470	pNew->aBuffers[0].fUsed = true;
471	pUrbOsX->u.Isoc.aFrames = pNew->aBuffers[0].paFrames;
472	pUrbOsX->u.Isoc.pBuf = &pNew->aBuffers[0];
473
474	pNew->enmType = enmLLType;
475	pNew->pNext = pIf->pIsocBufCols;
476	pIf->pIsocBufCols = pNew;
477
478	#if 0 /* doesn't help :-/ */
479	/*
480	* If this is the first time we're here, try mess with the policy?
481	*/
482	if (!pNew->pNext)
483	for (unsigned iPipe = 0; iPipe < pIf->cPipes; iPipe++)
484	if (pIf->aPipes[iPipe].u8TransferType == kUSBIsoc)
485	{
486	irc = (*pIf->ppIfI)->SetPipePolicy(pIf->ppIfI, pIf->aPipes[iPipe].u8PipeRef,
487	pIf->aPipes[iPipe].u16MaxPacketSize, pIf->aPipes[iPipe].u8Interval);
488	AssertMsg(irc == kIOReturnSuccess, ("%#x\n", irc));
489	}
490	#endif
491
492	return VINF_SUCCESS;
493	}
494
495	/* bail out */
496	(*pIf->ppIfI)->LowLatencyDestroyBuffer(pIf->ppIfI, pNew->pvBuffer);
497	}
498	AssertMsgFailed(("%#x\n", irc));
499	RTMemFree(pNew);
500
501	return RTErrConvertFromDarwin(irc);
502	}
503	#endif /* USE_LOW_LATENCY_API */
504
505
506	/**
507	* Frees a Darwin URB request structure.
508	*
509	* @param pDevOsX The darwin proxy device.
510	* @param pUrbOsX The Darwin URB to free.
511	*/
512	static void usbProxyDarwinUrbFree(PUSBPROXYDEVOSX pDevOsX, PUSBPROXYURBOSX pUrbOsX)
513	{
514	RTCritSectEnter(&pDevOsX->CritSect);
515
516	#ifdef USE_LOW_LATENCY_API
517	/*
518	* Free low latency stuff.
519	*/
520	if ( pUrbOsX->enmType == VUSBXFERTYPE_ISOC
521	&& pUrbOsX->u.Isoc.pBuf)
522	{
523	pUrbOsX->u.Isoc.pBuf->fUsed = false;
524	pUrbOsX->u.Isoc.pBuf = NULL;
525	}
526	#endif
527
528	/*
529	* Link it into the free list.
530	*/
531	pUrbOsX->pPrev = NULL;
532	pUrbOsX->pNext = pDevOsX->pFreeHead;
533	pDevOsX->pFreeHead = pUrbOsX;
534
535	pUrbOsX->pVUsbUrb = NULL;
536	pUrbOsX->pDevOsX = NULL;
537	pUrbOsX->enmType = VUSBXFERTYPE_INVALID;
538
539	RTCritSectLeave(&pDevOsX->CritSect);
540	}
541
542	/**
543	* Translate the IOKit status code to a VUSB status.
544	*
545	* @returns VUSB URB status code.
546	* @param irc IOKit status code.
547	*/
548	static VUSBSTATUS vusbProxyDarwinStatusToVUsbStatus(IOReturn irc)
549	{
550	switch (irc)
551	{
552	/* IOKit OHCI VUSB */
553	case kIOReturnSuccess: /* 0 */ return VUSBSTATUS_OK;
554	case kIOUSBCRCErr: /* 1 */ return VUSBSTATUS_CRC;
555	//case kIOUSBBitstufErr: /* 2 */ return VUSBSTATUS_;
556	//case kIOUSBDataToggleErr: /* 3 */ return VUSBSTATUS_;
557	case kIOUSBPipeStalled: /* 4 */ return VUSBSTATUS_STALL;
558	case kIOReturnNotResponding: /* 5 */ return VUSBSTATUS_DNR;
559	//case kIOUSBPIDCheckErr: /* 6 */ return VUSBSTATUS_;
560	//case kIOUSBWrongPIDErr: /* 7 */ return VUSBSTATUS_;
561	case kIOReturnOverrun: /* 8 */ return VUSBSTATUS_DATA_OVERRUN;
562	case kIOReturnUnderrun: /* 9 */ return VUSBSTATUS_DATA_UNDERRUN;
563	//case kIOUSBReserved1Err: /* 10 */ return VUSBSTATUS_;
564	//case kIOUSBReserved2Err: /* 11 */ return VUSBSTATUS_;
565	//case kIOUSBBufferOverrunErr: /* 12 */ return VUSBSTATUS_;
566	//case kIOUSBBufferUnderrunErr: /* 13 */ return VUSBSTATUS_;
567	case kIOUSBNotSent1Err: /* 14 / return VUSBSTATUS_NOT_ACCESSED/VUSBSTATUS_OK*/;
568	case kIOUSBNotSent2Err: /* 15 / return VUSBSTATUS_NOT_ACCESSED/VUSBSTATUS_OK*/;
569
570	/* Other errors */
571	case kIOUSBTransactionTimeout: return VUSBSTATUS_DNR;
572	//case kIOReturnAborted: return VUSBSTATUS_CRC; - see on SET_INTERFACE...
573
574	default:
575	Log(("vusbProxyDarwinStatusToVUsbStatus: irc=%#x!!\n", irc));
576	return VUSBSTATUS_STALL;
577	}
578	}
579
580
581	/**
582	* Completion callback for an async URB transfer.
583	*
584	* @param pvUrbOsX The Darwin URB.
585	* @param irc The status of the operation.
586	* @param Size Possible the transfer size.
587	*/
588	static void usbProxyDarwinUrbAsyncComplete(void pvUrbOsX, IOReturn irc, void Size)
589	{
590	PUSBPROXYURBOSX pUrbOsX = (PUSBPROXYURBOSX)pvUrbOsX;
591	PUSBPROXYDEVOSX pDevOsX = pUrbOsX->pDevOsX;
592	const uint32_t cb = (uintptr_t)Size;
593
594	/*
595	* Do status updates.
596	*/
597	PVUSBURB pUrb = pUrbOsX->pVUsbUrb;
598	if (pUrb)
599	{
600	Assert(pUrb->u32Magic == VUSBURB_MAGIC);
601	if (pUrb->enmType == VUSBXFERTYPE_ISOC)
602	{
603	#ifdef USE_LOW_LATENCY_API
604	/* copy the data. */
605	//if (pUrb->enmDir == VUSBDIRECTION_IN)
606	memcpy(pUrb->abData, pUrbOsX->u.Isoc.pBuf->pvBuf, pUrb->cbData);
607	#endif
608	Log3(("AsyncComplete isoc - raw data (%d bytes):\n"
609	"%16.*Rhxd\n", pUrb->cbData, pUrb->cbData, pUrb->abData));
610	uint32_t off = 0;
611	for (unsigned i = 0; i < pUrb->cIsocPkts; i++)
612	{
613	#ifdef USE_LOW_LATENCY_API
614	Log2((" %d{%d/%d-%x-%RX64}", i, pUrbOsX->u.Isoc.aFrames[i].frActCount, pUrb->aIsocPkts[i].cb, pUrbOsX->u.Isoc.aFrames[i].frStatus,
615	RT_MAKE_U64(pUrbOsX->u.Isoc.aFrames[i].frTimeStamp.lo, pUrbOsX->u.Isoc.aFrames[i].frTimeStamp.hi) ));
616	#else
617	Log2((" %d{%d/%d-%x}", i, pUrbOsX->u.Isoc.aFrames[i].frActCount, pUrb->aIsocPkts[i].cb, pUrbOsX->u.Isoc.aFrames[i].frStatus));
618	#endif
619	pUrb->aIsocPkts[i].enmStatus = vusbProxyDarwinStatusToVUsbStatus(pUrbOsX->u.Isoc.aFrames[i].frStatus);
620	pUrb->aIsocPkts[i].cb = pUrbOsX->u.Isoc.aFrames[i].frActCount;
621	off += pUrbOsX->u.Isoc.aFrames[i].frActCount;
622	}
623	Log2(("\n"));
624	#if 0 /** @todo revisit this, wasn't working previously. */
625	for (int i = (int)pUrb->cIsocPkts - 1; i >= 0; i--)
626	Assert( !pUrbOsX->u.Isoc.aFrames[i].frActCount
627	&& !pUrbOsX->u.Isoc.aFrames[i].frReqCount
628	&& !pUrbOsX->u.Isoc.aFrames[i].frStatus);
629	#endif
630	pUrb->cbData = off; /* 'Size' seems to be pointing at an error code or something... */
631	pUrb->enmStatus = VUSBSTATUS_OK; /* Don't use 'irc'. OHCI expects OK unless it's a really bad error. */
632	}
633	else
634	{
635	pUrb->cbData = cb;
636	pUrb->enmStatus = vusbProxyDarwinStatusToVUsbStatus(irc);
637	if (pUrb->enmType == VUSBXFERTYPE_MSG)
638	pUrb->cbData += sizeof(VUSBSETUP);
639	}
640	}
641
642	RTCritSectEnter(&pDevOsX->CritSect);
643
644	/*
645	* Link it into the taxing list.
646	*/
647	pUrbOsX->pNext = NULL;
648	pUrbOsX->pPrev = pDevOsX->pTaxingTail;
649	if (pDevOsX->pTaxingTail)
650	pDevOsX->pTaxingTail->pNext = pUrbOsX;
651	else
652	pDevOsX->pTaxingHead = pUrbOsX;
653	pDevOsX->pTaxingTail = pUrbOsX;
654
655	RTCritSectLeave(&pDevOsX->CritSect);
656
657	LogFlow(("%s: usbProxyDarwinUrbAsyncComplete: cb=%d EndPt=%#x irc=%#x (%d)\n",
658	pUrb->pszDesc, cb, pUrb ? pUrb->EndPt : 0xff, irc, pUrb ? pUrb->enmStatus : 0xff));
659	}
660
661	/**
662	* Release all interfaces (current config).
663	*
664	* @param pDevOsX The darwin proxy device.
665	*/
666	static void usbProxyDarwinReleaseAllInterfaces(PUSBPROXYDEVOSX pDevOsX)
667	{
668	RTCritSectEnter(&pDevOsX->CritSect);
669
670	/* Kick the reaper thread out of sleep. */
671	usbProxyDarwinReaperKick(pDevOsX);
672
673	PUSBPROXYIFOSX pIf = pDevOsX->pIfHead;
674	pDevOsX->pIfHead = pDevOsX->pIfTail = NULL;
675
676	while (pIf)
677	{
678	PUSBPROXYIFOSX pNext = pIf->pNext;
679	IOReturn irc;
680
681	if (pIf->RunLoopSrcRef)
682	{
683	int rc = usbProxyDarwinRemoveSourceRefFromAllRunLoops((PRTLISTANCHOR)&pIf->HeadOfRunLoopLst, pIf->RunLoopSrcRef);
684	AssertRC(rc);
685
686	CFRelease(pIf->RunLoopSrcRef);
687	pIf->RunLoopSrcRef = NULL;
688	RTListInit((PRTLISTNODE)&pIf->HeadOfRunLoopLst);
689	}
690
691	while (pIf->pIsocBufCols)
692	{
693	PUSBPROXYISOCBUFCOL pCur = pIf->pIsocBufCols;
694	pIf->pIsocBufCols = pCur->pNext;
695	pCur->pNext = NULL;
696
697	irc = (*pIf->ppIfI)->LowLatencyDestroyBuffer(pIf->ppIfI, pCur->pvBuffer);
698	AssertMsg(irc == kIOReturnSuccess \|\| irc == MACH_SEND_INVALID_DEST, ("%#x\n", irc));
699	pCur->pvBuffer = NULL;
700
701	irc = (*pIf->ppIfI)->LowLatencyDestroyBuffer(pIf->ppIfI, pCur->pvFrames);
702	AssertMsg(irc == kIOReturnSuccess \|\| irc == MACH_SEND_INVALID_DEST, ("%#x\n", irc));
703	pCur->pvFrames = NULL;
704
705	RTMemFree(pCur);
706	}
707
708	irc = (*pIf->ppIfI)->USBInterfaceClose(pIf->ppIfI);
709	AssertMsg(irc == kIOReturnSuccess \|\| irc == kIOReturnNoDevice, ("%#x\n", irc));
710
711	(*pIf->ppIfI)->Release(pIf->ppIfI);
712	pIf->ppIfI = NULL;
713
714	RTMemFree(pIf);
715
716	pIf = pNext;
717	}
718	RTCritSectLeave(&pDevOsX->CritSect);
719	}
720
721
722	/**
723	* Get the properties all the pipes associated with an interface.
724	*
725	* This is used when we seize all the interface and after SET_INTERFACE.
726	*
727	* @returns VBox status code.
728	* @param pDevOsX The darwin proxy device.
729	* @param pIf The interface to get pipe props for.
730	*/
731	static int usbProxyDarwinGetPipeProperties(PUSBPROXYDEVOSX pDevOsX, PUSBPROXYIFOSX pIf)
732	{
733	/*
734	* Get the pipe (endpoint) count (it might have changed - even on open).
735	*/
736	int rc = VINF_SUCCESS;
737	bool fFullSpeed;
738	UInt32 u32UsecInFrame;
739	UInt8 cPipes;
740	IOReturn irc = (*pIf->ppIfI)->GetNumEndpoints(pIf->ppIfI, &cPipes);
741	if (irc != kIOReturnSuccess)
742	{
743	pIf->cPipes = 0;
744	if (irc == kIOReturnNoDevice)
745	rc = VERR_VUSB_DEVICE_NOT_ATTACHED;
746	else
747	rc = RTErrConvertFromDarwin(irc);
748	return rc;
749	}
750	AssertRelease(cPipes < RT_ELEMENTS(pIf->aPipes));
751	pIf->cPipes = cPipes + 1;
752
753	/* Find out if this is a full-speed interface (needed for isochronous support). */
754	irc = (*pIf->ppIfI)->GetFrameListTime(pIf->ppIfI, &u32UsecInFrame);
755	if (irc != kIOReturnSuccess)
756	{
757	pIf->cPipes = 0;
758	if (irc == kIOReturnNoDevice)
759	rc = VERR_VUSB_DEVICE_NOT_ATTACHED;
760	else
761	rc = RTErrConvertFromDarwin(irc);
762	return rc;
763	}
764	fFullSpeed = u32UsecInFrame == kUSBFullSpeedMicrosecondsInFrame;
765
766	/*
767	* Get the properties of each pipe.
768	*/
769	for (unsigned i = 0; i < pIf->cPipes; i++)
770	{
771	pIf->aPipes[i].u8PipeRef = i;
772	pIf->aPipes[i].fIsFullSpeed = fFullSpeed;
773	pIf->aPipes[i].u64NextFrameNo = 0;
774	irc = (*pIf->ppIfI)->GetPipeProperties(pIf->ppIfI, i,
775	&pIf->aPipes[i].u8Direction,
776	&pIf->aPipes[i].u8Endpoint,
777	&pIf->aPipes[i].u8TransferType,
778	&pIf->aPipes[i].u16MaxPacketSize,
779	&pIf->aPipes[i].u8Interval);
780	if (irc != kIOReturnSuccess)
781	{
782	LogRel(("USB: Failed to query properties for pipe %#d / interface %#x on device '%s'. (prot=%#x class=%#x)\n",
783	i, pIf->u8Interface, pDevOsX->pProxyDev->pUsbIns->pszName, pIf->u8Protocol, pIf->u8Class));
784	if (irc == kIOReturnNoDevice)
785	rc = VERR_VUSB_DEVICE_NOT_ATTACHED;
786	else
787	rc = RTErrConvertFromDarwin(irc);
788	pIf->cPipes = i;
789	break;
790	}
791	/* reconstruct bEndpoint */
792	if (pIf->aPipes[i].u8Direction == kUSBIn)
793	pIf->aPipes[i].u8Endpoint \|= 0x80;
794	Log2(("usbProxyDarwinGetPipeProperties: #If=%d EndPt=%#x Dir=%d Type=%d PipeRef=%#x MaxPktSize=%#x Interval=%#x\n",
795	pIf->u8Interface, pIf->aPipes[i].u8Endpoint, pIf->aPipes[i].u8Direction, pIf->aPipes[i].u8TransferType,
796	pIf->aPipes[i].u8PipeRef, pIf->aPipes[i].u16MaxPacketSize, pIf->aPipes[i].u8Interval));
797	}
798
799	/** @todo sort or hash these for speedy lookup... */
800	return VINF_SUCCESS;
801	}
802
803
804	/**
805	* Seize all interfaces (current config).
806	*
807	* @returns VBox status code.
808	* @param pDevOsX The darwin proxy device.
809	* @param fMakeTheBestOfIt If set we will not give up on error. This is for
810	* use during SET_CONFIGURATION and similar.
811	*/
812	static int usbProxyDarwinSeizeAllInterfaces(PUSBPROXYDEVOSX pDevOsX, bool fMakeTheBestOfIt)
813	{
814	PUSBPROXYDEV pProxyDev = pDevOsX->pProxyDev;
815
816	RTCritSectEnter(&pDevOsX->CritSect);
817
818	/*
819	* Create a interface enumerator for all the interface (current config).
820	*/
821	io_iterator_t Interfaces = IO_OBJECT_NULL;
822	IOUSBFindInterfaceRequest Req;
823	Req.bInterfaceClass = kIOUSBFindInterfaceDontCare;
824	Req.bInterfaceSubClass = kIOUSBFindInterfaceDontCare;
825	Req.bInterfaceProtocol = kIOUSBFindInterfaceDontCare;
826	Req.bAlternateSetting = kIOUSBFindInterfaceDontCare;
827	IOReturn irc = (*pDevOsX->ppDevI)->CreateInterfaceIterator(pDevOsX->ppDevI, &Req, &Interfaces);
828	int rc;
829	if (irc == kIOReturnSuccess)
830	{
831	/*
832	* Iterate the interfaces.
833	*/
834	io_object_t Interface;
835	rc = VINF_SUCCESS;
836	while ((Interface = IOIteratorNext(Interfaces)))
837	{
838	/*
839	* Create a plug-in and query the IOUSBInterfaceInterface (cute name).
840	*/
841	IOCFPlugInInterface **ppPlugInInterface = NULL;
842	kern_return_t krc;
843	SInt32 Score = 0;
844	krc = IOCreatePlugInInterfaceForService(Interface, kIOUSBInterfaceUserClientTypeID,
845	kIOCFPlugInInterfaceID, &ppPlugInInterface, &Score);
846	IOObjectRelease(Interface);
847	Interface = IO_OBJECT_NULL;
848	if (krc == KERN_SUCCESS)
849	{
850	IOUSBInterfaceInterface245 **ppIfI;
851	HRESULT hrc = (*ppPlugInInterface)->QueryInterface(ppPlugInInterface,
852	CFUUIDGetUUIDBytes(kIOUSBInterfaceInterfaceID245),
853	(LPVOID *)&ppIfI);
854	krc = IODestroyPlugInInterface(ppPlugInInterface); Assert(krc == KERN_SUCCESS);
855	ppPlugInInterface = NULL;
856	if (hrc == S_OK)
857	{
858	/*
859	* Query some basic properties first.
860	* (This means we can print more informative messages on failure
861	* to seize the interface.)
862	*/
863	UInt8 u8Interface = 0xff;
864	irc = (*ppIfI)->GetInterfaceNumber(ppIfI, &u8Interface);
865	UInt8 u8AltSetting = 0xff;
866	if (irc == kIOReturnSuccess)
867	irc = (*ppIfI)->GetAlternateSetting(ppIfI, &u8AltSetting);
868	UInt8 u8Class = 0xff;
869	if (irc == kIOReturnSuccess)
870	irc = (*ppIfI)->GetInterfaceClass(ppIfI, &u8Class);
871	UInt8 u8Protocol = 0xff;
872	if (irc == kIOReturnSuccess)
873	irc = (*ppIfI)->GetInterfaceProtocol(ppIfI, &u8Protocol);
874	UInt8 cEndpoints = 0;
875	if (irc == kIOReturnSuccess)
876	irc = (*ppIfI)->GetNumEndpoints(ppIfI, &cEndpoints);
877	if (irc == kIOReturnSuccess)
878	{
879	/*
880	* Try seize the interface.
881	*/
882	irc = (*ppIfI)->USBInterfaceOpenSeize(ppIfI);
883	if (irc == kIOReturnSuccess)
884	{
885	PUSBPROXYIFOSX pIf = (PUSBPROXYIFOSX)RTMemAllocZ(sizeof(*pIf));
886	if (pIf)
887	{
888	/*
889	* Create the per-interface entry and query the
890	* endpoint data.
891	*/
892	/* initialize the entry */
893	pIf->u8Interface = u8Interface;
894	pIf->u8AltSetting = u8AltSetting;
895	pIf->u8Class = u8Class;
896	pIf->u8Protocol = u8Protocol;
897	pIf->cPipes = cEndpoints;
898	pIf->ppIfI = ppIfI;
899
900	/* query pipe/endpoint properties. */
901	rc = usbProxyDarwinGetPipeProperties(pDevOsX, pIf);
902	if (RT_SUCCESS(rc))
903	{
904	/*
905	* Create the async event source and add it to the
906	* default current run loop.
907	* (Later: Add to the worker thread run loop instead.)
908	*/
909	irc = (*ppIfI)->CreateInterfaceAsyncEventSource(ppIfI, &pIf->RunLoopSrcRef);
910	if (irc == kIOReturnSuccess)
911	{
912	RTListInit((PRTLISTNODE)&pIf->HeadOfRunLoopLst);
913	usbProxyDarwinAddRunLoopRef(&pIf->HeadOfRunLoopLst,
914	pIf->RunLoopSrcRef);
915
916	/*
917	* Just link the interface into the list and we're good.
918	*/
919	pIf->pNext = NULL;
920	Log(("USB: Seized interface %#x (alt=%d prot=%#x class=%#x)\n",
921	u8Interface, u8AltSetting, u8Protocol, u8Class));
922	if (pDevOsX->pIfTail)
923	pDevOsX->pIfTail = pDevOsX->pIfTail->pNext = pIf;
924	else
925	pDevOsX->pIfTail = pDevOsX->pIfHead = pIf;
926	continue;
927	}
928	rc = RTErrConvertFromDarwin(irc);
929	}
930
931	/* failure cleanup. */
932	RTMemFree(pIf);
933	}
934	}
935	else if (irc == kIOReturnExclusiveAccess)
936	{
937	LogRel(("USB: Interface %#x on device '%s' is being used by another process. (prot=%#x class=%#x)\n",
938	u8Interface, pProxyDev->pUsbIns->pszName, u8Protocol, u8Class));
939	rc = VERR_SHARING_VIOLATION;
940	}
941	else
942	{
943	LogRel(("USB: Failed to open interface %#x on device '%s'. (prot=%#x class=%#x) krc=%#x\n",
944	u8Interface, pProxyDev->pUsbIns->pszName, u8Protocol, u8Class, irc));
945	rc = VERR_OPEN_FAILED;
946	}
947	}
948	else
949	{
950	rc = RTErrConvertFromDarwin(irc);
951	LogRel(("USB: Failed to query interface properties on device '%s', irc=%#x.\n",
952	pProxyDev->pUsbIns->pszName, irc));
953	}
954	(*ppIfI)->Release(ppIfI);
955	ppIfI = NULL;
956	}
957	else if (RT_SUCCESS(rc))
958	rc = RTErrConvertFromDarwinCOM(hrc);
959	}
960	else if (RT_SUCCESS(rc))
961	rc = RTErrConvertFromDarwin(krc);
962	if (!fMakeTheBestOfIt)
963	{
964	usbProxyDarwinReleaseAllInterfaces(pDevOsX);
965	break;
966	}
967	} /* iterate */
968	IOObjectRelease(Interfaces);
969	}
970	else if (irc == kIOReturnNoDevice)
971	rc = VERR_VUSB_DEVICE_NOT_ATTACHED;
972	else
973	{
974	AssertMsgFailed(("%#x\n", irc));
975	rc = VERR_GENERAL_FAILURE;
976	}
977
978	RTCritSectLeave(&pDevOsX->CritSect);
979	return rc;
980	}
981
982
983	/**
984	* Find a particular interface.
985	*
986	* @returns The requested interface or NULL if not found.
987	* @param pDevOsX The darwin proxy device.
988	* @param u8Interface The interface number.
989	*/
990	static PUSBPROXYIFOSX usbProxyDarwinGetInterface(PUSBPROXYDEVOSX pDevOsX, uint8_t u8Interface)
991	{
992	if (!pDevOsX->pIfHead)
993	usbProxyDarwinSeizeAllInterfaces(pDevOsX, true /* make the best out of it */);
994
995	PUSBPROXYIFOSX pIf;
996	for (pIf = pDevOsX->pIfHead; pIf; pIf = pIf->pNext)
997	if (pIf->u8Interface == u8Interface)
998	return pIf;
999
1000	/* AssertMsgFailed(("Cannot find If#=%d\n", u8Interface)); - the 3rd quickcam interface is capture by the ***ing audio crap. /
1001	return NULL;
1002	}
1003
1004
1005	/**
1006	* Find a particular endpoint.
1007	*
1008	* @returns The requested interface or NULL if not found.
1009	* @param pDevOsX The darwin proxy device.
1010	* @param u8Endpoint The endpoint.
1011	* @param pu8PipeRef Where to store the darwin pipe ref.
1012	* @param ppPipe Where to store the darwin pipe pointer. (optional)
1013	*/
1014	static PUSBPROXYIFOSX usbProxyDarwinGetInterfaceForEndpoint(PUSBPROXYDEVOSX pDevOsX, uint8_t u8Endpoint,
1015	uint8_t *pu8PipeRef, PPUSBPROXYPIPEOSX ppPipe)
1016	{
1017	if (!pDevOsX->pIfHead)
1018	usbProxyDarwinSeizeAllInterfaces(pDevOsX, true /* make the best out of it */);
1019
1020	PUSBPROXYIFOSX pIf;
1021	for (pIf = pDevOsX->pIfHead; pIf; pIf = pIf->pNext)
1022	{
1023	unsigned i = pIf->cPipes;
1024	while (i-- > 0)
1025	if (pIf->aPipes[i].u8Endpoint == u8Endpoint)
1026	{
1027	*pu8PipeRef = pIf->aPipes[i].u8PipeRef;
1028	if (ppPipe)
1029	*ppPipe = &pIf->aPipes[i];
1030	return pIf;
1031	}
1032	}
1033
1034	AssertMsgFailed(("Cannot find EndPt=%#x\n", u8Endpoint));
1035	return NULL;
1036	}
1037
1038
1039	/**
1040	* Gets an unsigned 32-bit integer value.
1041	*
1042	* @returns Success indicator (true/false).
1043	* @param DictRef The dictionary.
1044	* @param KeyStrRef The key name.
1045	* @param pu32 Where to store the key value.
1046	*/
1047	static bool usbProxyDarwinDictGetU32(CFMutableDictionaryRef DictRef, CFStringRef KeyStrRef, uint32_t *pu32)
1048	{
1049	CFTypeRef ValRef = CFDictionaryGetValue(DictRef, KeyStrRef);
1050	if (ValRef)
1051	{
1052	if (CFNumberGetValue((CFNumberRef)ValRef, kCFNumberSInt32Type, pu32))
1053	return true;
1054	}
1055	*pu32 = 0;
1056	return false;
1057	}
1058
1059
1060	/**
1061	* Gets an unsigned 64-bit integer value.
1062	*
1063	* @returns Success indicator (true/false).
1064	* @param DictRef The dictionary.
1065	* @param KeyStrRef The key name.
1066	* @param pu64 Where to store the key value.
1067	*/
1068	static bool usbProxyDarwinDictGetU64(CFMutableDictionaryRef DictRef, CFStringRef KeyStrRef, uint64_t *pu64)
1069	{
1070	CFTypeRef ValRef = CFDictionaryGetValue(DictRef, KeyStrRef);
1071	if (ValRef)
1072	{
1073	if (CFNumberGetValue((CFNumberRef)ValRef, kCFNumberSInt64Type, pu64))
1074	return true;
1075	}
1076	*pu64 = 0;
1077	return false;
1078	}
1079
1080
1081	static DECLCALLBACK(void) usbProxyDarwinPerformWakeup(void *pInfo)
1082	{
1083	RT_NOREF(pInfo);
1084	return;
1085	}
1086
1087
1088	/* -=-=-=-=-=- The exported methods -=-=-=-=-=- */
1089
1090
1091	/**
1092	* Opens the USB Device.
1093	*
1094	* @returns VBox status code.
1095	* @param pProxyDev The device instance.
1096	* @param pszAddress The session id and/or location id of the device to open.
1097	* The format of this string is something iokit.c in Main defines, currently
1098	* it's sequences of "[l\|s]=<value>" separated by ";".
1099	* @param pvBackend Backend specific pointer, unused for the Darwin backend.
1100	*/
1101	static DECLCALLBACK(int) usbProxyDarwinOpen(PUSBPROXYDEV pProxyDev, const char pszAddress, void pvBackend)
1102	{
1103	RT_NOREF(pvBackend);
1104	LogFlow(("usbProxyDarwinOpen: pProxyDev=%p pszAddress=%s\n", pProxyDev, pszAddress));
1105
1106	/*
1107	* Init globals once.
1108	*/
1109	int vrc = RTOnce(&g_usbProxyDarwinOnce, usbProxyDarwinInitOnce, NULL);
1110	AssertRCReturn(vrc, vrc);
1111
1112	PUSBPROXYDEVOSX pDevOsX = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVOSX);
1113
1114	/*
1115	* The idea here was to create a matching directory with the sessionID
1116	* and locationID included, however this doesn't seem to work. So, we'll
1117	* use the product id and vendor id to limit the set of matching device
1118	* and manually match these two properties. sigh.
1119	* (Btw. vendor and product id must be used together apparently.)
1120	*
1121	* Wonder if we could use the entry path? Docs indicates says we must
1122	* use IOServiceGetMatchingServices and I'm not in a mood to explore
1123	* this subject further right now. Maybe check this later.
1124	*/
1125	CFMutableDictionaryRef RefMatchingDict = IOServiceMatching(kIOUSBDeviceClassName);
1126	AssertReturn(RefMatchingDict != IO_OBJECT_NULL, VERR_OPEN_FAILED);
1127
1128	uint64_t u64SessionId = 0;
1129	uint32_t u32LocationId = 0;
1130	const char *psz = pszAddress;
1131	do
1132	{
1133	const char chValue = *psz;
1134	AssertReleaseReturn(psz[1] == '=', VERR_INTERNAL_ERROR);
1135	uint64_t u64Value;
1136	int rc = RTStrToUInt64Ex(psz + 2, (char **)&psz, 0, &u64Value);
1137	AssertReleaseRCReturn(rc, rc);
1138	AssertReleaseReturn(!psz \|\| psz == ';', rc);
1139	switch (chValue)
1140	{
1141	case 'l':
1142	u32LocationId = (uint32_t)u64Value;
1143	break;
1144	case 's':
1145	u64SessionId = u64Value;
1146	break;
1147	case 'p':
1148	case 'v':
1149	{
1150	#if 0 /* Guess what, this doesn't 'ing work either! */
1151	SInt32 i32 = (int16_t)u64Value;
1152	CFNumberRef Num = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &i32);
1153	AssertBreak(Num);
1154	CFDictionarySetValue(RefMatchingDict, chValue == 'p' ? CFSTR(kUSBProductID) : CFSTR(kUSBVendorID), Num);
1155	CFRelease(Num);
1156	#endif
1157	break;
1158	}
1159	default:
1160	AssertReleaseMsgFailedReturn(("chValue=%#x\n", chValue), VERR_INTERNAL_ERROR);
1161	}
1162	if (*psz == ';')
1163	psz++;
1164	} while (*psz);
1165
1166	io_iterator_t USBDevices = IO_OBJECT_NULL;
1167	IOReturn irc = IOServiceGetMatchingServices(g_MasterPort, RefMatchingDict, &USBDevices);
1168	AssertMsgReturn(irc == kIOReturnSuccess, ("irc=%#x\n", irc), RTErrConvertFromDarwinIO(irc));
1169	RefMatchingDict = NULL; /* the reference is consumed by IOServiceGetMatchingServices. */
1170
1171	unsigned cMatches = 0;
1172	io_object_t USBDevice;
1173	while ((USBDevice = IOIteratorNext(USBDevices)))
1174	{
1175	cMatches++;
1176	CFMutableDictionaryRef PropsRef = 0;
1177	kern_return_t krc = IORegistryEntryCreateCFProperties(USBDevice, &PropsRef, kCFAllocatorDefault, kNilOptions);
1178	if (krc == KERN_SUCCESS)
1179	{
1180	uint64_t u64CurSessionId;
1181	uint32_t u32CurLocationId;
1182	if ( ( !u64SessionId
1183	\|\| ( usbProxyDarwinDictGetU64(PropsRef, CFSTR("sessionID"), &u64CurSessionId)
1184	&& u64CurSessionId == u64SessionId))
1185	&& ( !u32LocationId
1186	\|\| ( usbProxyDarwinDictGetU32(PropsRef, CFSTR(kUSBDevicePropertyLocationID), &u32CurLocationId)
1187	&& u32CurLocationId == u32LocationId))
1188	)
1189	{
1190	CFRelease(PropsRef);
1191	break;
1192	}
1193	CFRelease(PropsRef);
1194	}
1195	IOObjectRelease(USBDevice);
1196	}
1197	IOObjectRelease(USBDevices);
1198	USBDevices = IO_OBJECT_NULL;
1199	if (!USBDevice)
1200	{
1201	LogRel(("USB: Device '%s' not found (%d pid+vid matches)\n", pszAddress, cMatches));
1202	IOObjectRelease(USBDevices);
1203	return VERR_VUSB_DEVICE_NAME_NOT_FOUND;
1204	}
1205
1206	/*
1207	* Call the USBLib init to make sure we're a valid VBoxUSB client.
1208	* For now we'll ignore failures here and just plunge on, it might still work...
1209	*/
1210	vrc = USBLibInit();
1211	if (RT_FAILURE(vrc))
1212	LogRel(("USB: USBLibInit failed - %Rrc\n", vrc));
1213
1214	/*
1215	* Create a plugin interface for the device and query its IOUSBDeviceInterface.
1216	*/
1217	SInt32 Score = 0;
1218	IOCFPlugInInterface **ppPlugInInterface = NULL;
1219	irc = IOCreatePlugInInterfaceForService(USBDevice, kIOUSBDeviceUserClientTypeID,
1220	kIOCFPlugInInterfaceID, &ppPlugInInterface, &Score);
1221	if (irc == kIOReturnSuccess)
1222	{
1223	IOUSBDeviceInterface245 **ppDevI = NULL;
1224	HRESULT hrc = (*ppPlugInInterface)->QueryInterface(ppPlugInInterface,
1225	CFUUIDGetUUIDBytes(kIOUSBDeviceInterfaceID245),
1226	(LPVOID *)&ppDevI);
1227	irc = IODestroyPlugInInterface(ppPlugInInterface); Assert(irc == kIOReturnSuccess);
1228	ppPlugInInterface = NULL;
1229	if (hrc == S_OK)
1230	{
1231	/*
1232	* Try open the device for exclusive access.
1233	* If we fail, we'll try figure out who is using the device and
1234	* convince them to let go of it...
1235	*/
1236	irc = (*ppDevI)->USBDeviceOpenSeize(ppDevI);
1237	if (irc == kIOReturnExclusiveAccess)
1238	{
1239	RTThreadSleep(20);
1240	irc = (*ppDevI)->USBDeviceOpenSeize(ppDevI);
1241	}
1242	if (irc == kIOReturnSuccess)
1243	{
1244	/*
1245	* Init a proxy device instance.
1246	*/
1247	RTListInit((PRTLISTNODE)&pDevOsX->HeadOfRunLoopLst);
1248	vrc = RTCritSectInit(&pDevOsX->CritSect);
1249	if (RT_SUCCESS(vrc))
1250	{
1251	pDevOsX->USBDevice = USBDevice;
1252	pDevOsX->ppDevI = ppDevI;
1253	pDevOsX->pProxyDev = pProxyDev;
1254	pDevOsX->pTaxingHead = NULL;
1255	pDevOsX->pTaxingTail = NULL;
1256	pDevOsX->hRunLoopReapingLast = NULL;
1257
1258	/*
1259	* Try seize all the interface.
1260	*/
1261	char *pszDummyName = pProxyDev->pUsbIns->pszName;
1262	pProxyDev->pUsbIns->pszName = (char *)pszAddress;
1263	vrc = usbProxyDarwinSeizeAllInterfaces(pDevOsX, false /* give up on failure */);
1264	pProxyDev->pUsbIns->pszName = pszDummyName;
1265	if (RT_SUCCESS(vrc))
1266	{
1267	/*
1268	* Create the async event source and add it to the run loop.
1269	*/
1270	irc = (*ppDevI)->CreateDeviceAsyncEventSource(ppDevI, &pDevOsX->RunLoopSrcRef);
1271	if (irc == kIOReturnSuccess)
1272	{
1273	/*
1274	* Determine the active configuration.
1275	* Can cause hangs, so drop it for now.
1276	*/
1277	/** @todo test Palm. */
1278	//uint8_t u8Cfg;
1279	//irc = (*ppDevI)->GetConfiguration(ppDevI, &u8Cfg);
1280	if (irc != kIOReturnNoDevice)
1281	{
1282	CFRunLoopSourceContext CtxRunLoopSource;
1283	CtxRunLoopSource.version = 0;
1284	CtxRunLoopSource.info = NULL;
1285	CtxRunLoopSource.retain = NULL;
1286	CtxRunLoopSource.release = NULL;
1287	CtxRunLoopSource.copyDescription = NULL;
1288	CtxRunLoopSource.equal = NULL;
1289	CtxRunLoopSource.hash = NULL;
1290	CtxRunLoopSource.schedule = NULL;
1291	CtxRunLoopSource.cancel = NULL;
1292	CtxRunLoopSource.perform = usbProxyDarwinPerformWakeup;
1293	pDevOsX->hRunLoopSrcWakeRef = CFRunLoopSourceCreate(NULL, 0, &CtxRunLoopSource);
1294	if (CFRunLoopSourceIsValid(pDevOsX->hRunLoopSrcWakeRef))
1295	{
1296	//pProxyDev->iActiveCfg = irc == kIOReturnSuccess ? u8Cfg : -1;
1297	RTListInit(&pDevOsX->HeadOfRunLoopWakeLst);
1298	pProxyDev->iActiveCfg = -1;
1299	pProxyDev->cIgnoreSetConfigs = 1;
1300
1301	usbProxyDarwinAddRunLoopRef(&pDevOsX->HeadOfRunLoopLst, pDevOsX->RunLoopSrcRef);
1302	return VINF_SUCCESS; /* return */
1303	}
1304	else
1305	{
1306	LogRel(("USB: Device '%s' out of memory allocating runloop source\n", pszAddress));
1307	vrc = VERR_NO_MEMORY;
1308	}
1309	}
1310	vrc = VERR_VUSB_DEVICE_NOT_ATTACHED;
1311	}
1312	else
1313	vrc = RTErrConvertFromDarwin(irc);
1314
1315	usbProxyDarwinReleaseAllInterfaces(pDevOsX);
1316	}
1317	/* else: already bitched */
1318
1319	RTCritSectDelete(&pDevOsX->CritSect);
1320	}
1321
1322	irc = (*ppDevI)->USBDeviceClose(ppDevI);
1323	AssertMsg(irc == kIOReturnSuccess, ("%#x\n", irc));
1324	}
1325	else if (irc == kIOReturnExclusiveAccess)
1326	{
1327	LogRel(("USB: Device '%s' is being used by another process\n", pszAddress));
1328	vrc = VERR_SHARING_VIOLATION;
1329	}
1330	else
1331	{
1332	LogRel(("USB: Failed to open device '%s', irc=%#x.\n", pszAddress, irc));
1333	vrc = VERR_OPEN_FAILED;
1334	}
1335	}
1336	else
1337	{
1338	LogRel(("USB: Failed to create plugin interface for device '%s', hrc=%#x.\n", pszAddress, hrc));
1339	vrc = VERR_OPEN_FAILED;
1340	}
1341
1342	(*ppDevI)->Release(ppDevI);
1343	}
1344	else
1345	{
1346	LogRel(("USB: Failed to open device '%s', plug-in creation failed with irc=%#x.\n", pszAddress, irc));
1347	vrc = RTErrConvertFromDarwin(irc);
1348	}
1349
1350	USBLibTerm();
1351	return vrc;
1352	}
1353
1354
1355	/**
1356	* Closes the proxy device.
1357	*/
1358	static DECLCALLBACK(void) usbProxyDarwinClose(PUSBPROXYDEV pProxyDev)
1359	{
1360	LogFlow(("usbProxyDarwinClose: pProxyDev=%s\n", pProxyDev->pUsbIns->pszName));
1361	PUSBPROXYDEVOSX pDevOsX = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVOSX);
1362	AssertPtrReturnVoid(pDevOsX);
1363
1364	/*
1365	* Release interfaces we've laid claim to, then reset the device
1366	* and finally close it.
1367	*/
1368	RTCritSectEnter(&pDevOsX->CritSect);
1369	/* ?? */
1370	RTCritSectLeave(&pDevOsX->CritSect);
1371
1372	usbProxyDarwinReleaseAllInterfaces(pDevOsX);
1373
1374	if (pDevOsX->RunLoopSrcRef)
1375	{
1376	int rc = usbProxyDarwinRemoveSourceRefFromAllRunLoops(&pDevOsX->HeadOfRunLoopLst, pDevOsX->RunLoopSrcRef);
1377	AssertRC(rc);
1378
1379	RTListInit((PRTLISTNODE)&pDevOsX->HeadOfRunLoopLst);
1380
1381	CFRelease(pDevOsX->RunLoopSrcRef);
1382	pDevOsX->RunLoopSrcRef = NULL;
1383	}
1384
1385	if (pDevOsX->hRunLoopSrcWakeRef)
1386	{
1387	int rc = usbProxyDarwinRemoveSourceRefFromAllRunLoops(&pDevOsX->HeadOfRunLoopWakeLst, pDevOsX->hRunLoopSrcWakeRef);
1388	AssertRC(rc);
1389
1390	RTListInit((PRTLISTNODE)&pDevOsX->HeadOfRunLoopWakeLst);
1391
1392	CFRelease(pDevOsX->hRunLoopSrcWakeRef);
1393	pDevOsX->hRunLoopSrcWakeRef = NULL;
1394	}
1395
1396	IOReturn irc = (*pDevOsX->ppDevI)->ResetDevice(pDevOsX->ppDevI);
1397
1398	irc = (*pDevOsX->ppDevI)->USBDeviceClose(pDevOsX->ppDevI);
1399	if (irc != kIOReturnSuccess && irc != kIOReturnNoDevice)
1400	{
1401	LogRel(("USB: USBDeviceClose -> %#x\n", irc));
1402	AssertMsgFailed(("irc=%#x\n", irc));
1403	}
1404
1405	(*pDevOsX->ppDevI)->Release(pDevOsX->ppDevI);
1406	pDevOsX->ppDevI = NULL;
1407	kern_return_t krc = IOObjectRelease(pDevOsX->USBDevice); Assert(krc == KERN_SUCCESS); NOREF(krc);
1408	pDevOsX->USBDevice = IO_OBJECT_NULL;
1409	pDevOsX->pProxyDev = NULL;
1410
1411	/*
1412	* Free all the resources.
1413	*/
1414	RTCritSectDelete(&pDevOsX->CritSect);
1415
1416	PUSBPROXYURBOSX pUrbOsX;
1417	while ((pUrbOsX = pDevOsX->pFreeHead) != NULL)
1418	{
1419	pDevOsX->pFreeHead = pUrbOsX->pNext;
1420	RTMemFree(pUrbOsX);
1421	}
1422
1423	USBLibTerm();
1424	LogFlow(("usbProxyDarwinClose: returns\n"));
1425	}
1426
1427
1428	/** @interface_method_impl{USBPROXYBACK,pfnReset}*/
1429	static DECLCALLBACK(int) usbProxyDarwinReset(PUSBPROXYDEV pProxyDev, bool fResetOnLinux)
1430	{
1431	RT_NOREF(fResetOnLinux);
1432	PUSBPROXYDEVOSX pDevOsX = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVOSX);
1433	LogFlow(("usbProxyDarwinReset: pProxyDev=%s\n", pProxyDev->pUsbIns->pszName));
1434
1435	IOReturn irc = (*pDevOsX->ppDevI)->ResetDevice(pDevOsX->ppDevI);
1436	int rc;
1437	if (irc == kIOReturnSuccess)
1438	{
1439	/** @todo Some docs say that some drivers will do a default config, check this out ... */
1440	pProxyDev->cIgnoreSetConfigs = 0;
1441	pProxyDev->iActiveCfg = -1;
1442
1443	rc = VINF_SUCCESS;
1444	}
1445	else if (irc == kIOReturnNoDevice)
1446	rc = VERR_VUSB_DEVICE_NOT_ATTACHED;
1447	else
1448	{
1449	AssertMsgFailed(("irc=%#x\n", irc));
1450	rc = VERR_GENERAL_FAILURE;
1451	}
1452
1453	LogFlow(("usbProxyDarwinReset: returns success %Rrc\n", rc));
1454	return rc;
1455	}
1456
1457
1458	/**
1459	* SET_CONFIGURATION.
1460	*
1461	* The caller makes sure that it's not called first time after open or reset
1462	* with the active interface.
1463	*
1464	* @returns success indicator.
1465	* @param pProxyDev The device instance data.
1466	* @param iCfg The configuration to set.
1467	*/
1468	static DECLCALLBACK(int) usbProxyDarwinSetConfig(PUSBPROXYDEV pProxyDev, int iCfg)
1469	{
1470	PUSBPROXYDEVOSX pDevOsX = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVOSX);
1471	LogFlow(("usbProxyDarwinSetConfig: pProxyDev=%s cfg=%#x\n",
1472	pProxyDev->pUsbIns->pszName, iCfg));
1473
1474	IOReturn irc = (*pDevOsX->ppDevI)->SetConfiguration(pDevOsX->ppDevI, (uint8_t)iCfg);
1475	if (irc != kIOReturnSuccess)
1476	{
1477	Log(("usbProxyDarwinSetConfig: Set configuration -> %#x\n", irc));
1478	return RTErrConvertFromDarwin(irc);
1479	}
1480
1481	usbProxyDarwinReleaseAllInterfaces(pDevOsX);
1482	usbProxyDarwinSeizeAllInterfaces(pDevOsX, true /* make the best out of it */);
1483	return VINF_SUCCESS;
1484	}
1485
1486
1487	/**
1488	* Claims an interface.
1489	*
1490	* This is a stub on Darwin since we release/claim all interfaces at
1491	* open/reset/setconfig time.
1492	*
1493	* @returns success indicator (always VINF_SUCCESS).
1494	*/
1495	static DECLCALLBACK(int) usbProxyDarwinClaimInterface(PUSBPROXYDEV pProxyDev, int iIf)
1496	{
1497	RT_NOREF(pProxyDev, iIf);
1498	return VINF_SUCCESS;
1499	}
1500
1501
1502	/**
1503	* Releases an interface.
1504	*
1505	* This is a stub on Darwin since we release/claim all interfaces at
1506	* open/reset/setconfig time.
1507	*
1508	* @returns success indicator.
1509	*/
1510	static DECLCALLBACK(int) usbProxyDarwinReleaseInterface(PUSBPROXYDEV pProxyDev, int iIf)
1511	{
1512	RT_NOREF(pProxyDev, iIf);
1513	return VINF_SUCCESS;
1514	}
1515
1516
1517	/**
1518	* SET_INTERFACE.
1519	*
1520	* @returns success indicator.
1521	*/
1522	static DECLCALLBACK(int) usbProxyDarwinSetInterface(PUSBPROXYDEV pProxyDev, int iIf, int iAlt)
1523	{
1524	PUSBPROXYDEVOSX pDevOsX = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVOSX);
1525	IOReturn irc = kIOReturnSuccess;
1526	PUSBPROXYIFOSX pIf = usbProxyDarwinGetInterface(pDevOsX, iIf);
1527	LogFlow(("usbProxyDarwinSetInterface: pProxyDev=%s iIf=%#x iAlt=%#x iCurAlt=%#x\n",
1528	pProxyDev->pUsbIns->pszName, iIf, iAlt, pIf ? pIf->u8AltSetting : 0xbeef));
1529	if (pIf)
1530	{
1531	/* Avoid SetAlternateInterface when possible as it will recreate the pipes. */
1532	if (iAlt != pIf->u8AltSetting)
1533	{
1534	irc = (*pIf->ppIfI)->SetAlternateInterface(pIf->ppIfI, iAlt);
1535	if (irc == kIOReturnSuccess)
1536	{
1537	usbProxyDarwinGetPipeProperties(pDevOsX, pIf);
1538	return VINF_SUCCESS;
1539	}
1540	}
1541	else
1542	{
1543	/*
1544	* Just send the request anyway?
1545	*/
1546	IOUSBDevRequest Req;
1547	Req.bmRequestType = 0x01;
1548	Req.bRequest = 0x0b; /* SET_INTERFACE */
1549	Req.wIndex = iIf;
1550	Req.wValue = iAlt;
1551	Req.wLength = 0;
1552	Req.wLenDone = 0;
1553	Req.pData = NULL;
1554	irc = (*pDevOsX->ppDevI)->DeviceRequest(pDevOsX->ppDevI, &Req);
1555	Log(("usbProxyDarwinSetInterface: SET_INTERFACE(%d,%d) -> irc=%#x\n", iIf, iAlt, irc));
1556	return VINF_SUCCESS;
1557	}
1558	}
1559
1560	LogFlow(("usbProxyDarwinSetInterface: pProxyDev=%s eiIf=%#x iAlt=%#x - failure - pIf=%p irc=%#x\n",
1561	pProxyDev->pUsbIns->pszName, iIf, iAlt, pIf, irc));
1562	return RTErrConvertFromDarwin(irc);
1563	}
1564
1565
1566	/**
1567	* Clears the halted endpoint 'EndPt'.
1568	*/
1569	static DECLCALLBACK(int) usbProxyDarwinClearHaltedEp(PUSBPROXYDEV pProxyDev, unsigned int EndPt)
1570	{
1571	PUSBPROXYDEVOSX pDevOsX = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVOSX);
1572	LogFlow(("usbProxyDarwinClearHaltedEp: pProxyDev=%s EndPt=%#x\n", pProxyDev->pUsbIns->pszName, EndPt));
1573
1574	/*
1575	* Clearing the zero control pipe doesn't make sense and isn't
1576	* supported by the API. Just ignore it.
1577	*/
1578	if (EndPt == 0)
1579	return VINF_SUCCESS;
1580
1581	/*
1582	* Find the interface/pipe combination and invoke the ClearPipeStallBothEnds
1583	* method. (The ResetPipe and ClearPipeStall methods will not send the
1584	* CLEAR_FEATURE(ENDPOINT_HALT) request that this method implements.)
1585	*/
1586	IOReturn irc = kIOReturnSuccess;
1587	uint8_t u8PipeRef;
1588	PUSBPROXYIFOSX pIf = usbProxyDarwinGetInterfaceForEndpoint(pDevOsX, EndPt, &u8PipeRef, NULL);
1589	if (pIf)
1590	{
1591	irc = (*pIf->ppIfI)->ClearPipeStallBothEnds(pIf->ppIfI, u8PipeRef);
1592	if (irc == kIOReturnSuccess)
1593	return VINF_SUCCESS;
1594	AssertMsg(irc == kIOReturnNoDevice \|\| irc == kIOReturnNotResponding, ("irc=#x (control pipe?)\n", irc));
1595	}
1596
1597	LogFlow(("usbProxyDarwinClearHaltedEp: pProxyDev=%s EndPt=%#x - failure - pIf=%p irc=%#x\n",
1598	pProxyDev->pUsbIns->pszName, EndPt, pIf, irc));
1599	return RTErrConvertFromDarwin(irc);
1600	}
1601
1602
1603	/**
1604	* @interface_method_impl{USBPROXYBACK,pfnUrbQueue}
1605	*/
1606	static DECLCALLBACK(int) usbProxyDarwinUrbQueue(PUSBPROXYDEV pProxyDev, PVUSBURB pUrb)
1607	{
1608	PUSBPROXYDEVOSX pDevOsX = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVOSX);
1609	LogFlow(("%s: usbProxyDarwinUrbQueue: pProxyDev=%s pUrb=%p EndPt=%d cbData=%d\n",
1610	pUrb->pszDesc, pProxyDev->pUsbIns->pszName, pUrb, pUrb->EndPt, pUrb->cbData));
1611
1612	/*
1613	* Find the target interface / pipe.
1614	*/
1615	uint8_t u8PipeRef = 0xff;
1616	PUSBPROXYIFOSX pIf = NULL;
1617	PUSBPROXYPIPEOSX pPipe = NULL;
1618	if (pUrb->EndPt)
1619	{
1620	/* Make sure the interface is there. */
1621	const uint8_t EndPt = pUrb->EndPt \| (pUrb->enmDir == VUSBDIRECTION_IN ? 0x80 : 0);
1622	pIf = usbProxyDarwinGetInterfaceForEndpoint(pDevOsX, EndPt, &u8PipeRef, &pPipe);
1623	if (!pIf)
1624	{
1625	LogFlow(("%s: usbProxyDarwinUrbQueue: pProxyDev=%s EndPt=%d cbData=%d - can't find interface / pipe!!!\n",
1626	pUrb->pszDesc, pProxyDev->pUsbIns->pszName, pUrb->EndPt, pUrb->cbData));
1627	return VERR_NOT_FOUND;
1628	}
1629	}
1630	/* else: pIf == NULL -> default control pipe.*/
1631
1632	/*
1633	* Allocate a Darwin urb.
1634	*/
1635	PUSBPROXYURBOSX pUrbOsX = usbProxyDarwinUrbAlloc(pDevOsX);
1636	if (!pUrbOsX)
1637	return VERR_NO_MEMORY;
1638
1639	pUrbOsX->u64SubmitTS = RTTimeMilliTS();
1640	pUrbOsX->pVUsbUrb = pUrb;
1641	pUrbOsX->pDevOsX = pDevOsX;
1642	pUrbOsX->enmType = pUrb->enmType;
1643
1644	/*
1645	* Submit the request.
1646	*/
1647	IOReturn irc = kIOReturnError;
1648	switch (pUrb->enmType)
1649	{
1650	case VUSBXFERTYPE_MSG:
1651	{
1652	AssertMsgBreak(pUrb->cbData >= sizeof(VUSBSETUP), ("cbData=%d\n", pUrb->cbData));
1653	PVUSBSETUP pSetup = (PVUSBSETUP)&pUrb->abData[0];
1654	pUrbOsX->u.ControlMsg.bmRequestType = pSetup->bmRequestType;
1655	pUrbOsX->u.ControlMsg.bRequest = pSetup->bRequest;
1656	pUrbOsX->u.ControlMsg.wValue = pSetup->wValue;
1657	pUrbOsX->u.ControlMsg.wIndex = pSetup->wIndex;
1658	pUrbOsX->u.ControlMsg.wLength = pSetup->wLength;
1659	pUrbOsX->u.ControlMsg.pData = pSetup + 1;
1660	pUrbOsX->u.ControlMsg.wLenDone = pSetup->wLength;
1661
1662	if (pIf)
1663	irc = (*pIf->ppIfI)->ControlRequestAsync(pIf->ppIfI, u8PipeRef, &pUrbOsX->u.ControlMsg,
1664	usbProxyDarwinUrbAsyncComplete, pUrbOsX);
1665	else
1666	irc = (*pDevOsX->ppDevI)->DeviceRequestAsync(pDevOsX->ppDevI, &pUrbOsX->u.ControlMsg,
1667	usbProxyDarwinUrbAsyncComplete, pUrbOsX);
1668	break;
1669	}
1670
1671	case VUSBXFERTYPE_BULK:
1672	case VUSBXFERTYPE_INTR:
1673	{
1674	AssertBreak(pIf);
1675	Assert(pUrb->enmDir == VUSBDIRECTION_IN \|\| pUrb->enmDir == VUSBDIRECTION_OUT);
1676	if (pUrb->enmDir == VUSBDIRECTION_OUT)
1677	irc = (*pIf->ppIfI)->WritePipeAsync(pIf->ppIfI, u8PipeRef, pUrb->abData, pUrb->cbData,
1678	usbProxyDarwinUrbAsyncComplete, pUrbOsX);
1679	else
1680	irc = (*pIf->ppIfI)->ReadPipeAsync(pIf->ppIfI, u8PipeRef, pUrb->abData, pUrb->cbData,
1681	usbProxyDarwinUrbAsyncComplete, pUrbOsX);
1682
1683	break;
1684	}
1685
1686	case VUSBXFERTYPE_ISOC:
1687	{
1688	AssertBreak(pIf);
1689	Assert(pUrb->enmDir == VUSBDIRECTION_IN \|\| pUrb->enmDir == VUSBDIRECTION_OUT);
1690
1691	#ifdef USE_LOW_LATENCY_API
1692	/* Allocate an isochronous buffer and copy over the data. */
1693	AssertBreak(pUrb->cbData <= 8192);
1694	int rc = usbProxyDarwinUrbAllocIsocBuf(pUrbOsX, pIf);
1695	AssertRCBreak(rc);
1696	if (pUrb->enmDir == VUSBDIRECTION_OUT)
1697	memcpy(pUrbOsX->u.Isoc.pBuf->pvBuf, pUrb->abData, pUrb->cbData);
1698	else
1699	memset(pUrbOsX->u.Isoc.pBuf->pvBuf, 0xfe, pUrb->cbData);
1700	#endif
1701
1702	/* Get the current frame number (+2) and make sure it doesn't
1703	overlap with the previous request. See WARNING in
1704	ApplUSBUHCI::CreateIsochTransfer for details on the +2. */
1705	UInt64 FrameNo;
1706	AbsoluteTime FrameTime;
1707	irc = (*pIf->ppIfI)->GetBusFrameNumber(pIf->ppIfI, &FrameNo, &FrameTime);
1708	AssertMsg(irc == kIOReturnSuccess, ("GetBusFrameNumber -> %#x\n", irc));
1709	FrameNo += 2;
1710	if (FrameNo <= pPipe->u64NextFrameNo)
1711	FrameNo = pPipe->u64NextFrameNo;
1712
1713	for (unsigned j = 0; ; j++)
1714	{
1715	unsigned i;
1716	for (i = 0; i < pUrb->cIsocPkts; i++)
1717	{
1718	pUrbOsX->u.Isoc.aFrames[i].frReqCount = pUrb->aIsocPkts[i].cb;
1719	pUrbOsX->u.Isoc.aFrames[i].frActCount = 0;
1720	pUrbOsX->u.Isoc.aFrames[i].frStatus = kIOUSBNotSent1Err;
1721	#ifdef USE_LOW_LATENCY_API
1722	pUrbOsX->u.Isoc.aFrames[i].frTimeStamp.hi = 0;
1723	pUrbOsX->u.Isoc.aFrames[i].frTimeStamp.lo = 0;
1724	#endif
1725	}
1726	for (; i < RT_ELEMENTS(pUrbOsX->u.Isoc.aFrames); i++)
1727	{
1728	pUrbOsX->u.Isoc.aFrames[i].frReqCount = 0;
1729	pUrbOsX->u.Isoc.aFrames[i].frActCount = 0;
1730	pUrbOsX->u.Isoc.aFrames[i].frStatus = kIOReturnError;
1731	#ifdef USE_LOW_LATENCY_API
1732	pUrbOsX->u.Isoc.aFrames[i].frTimeStamp.hi = 0;
1733	pUrbOsX->u.Isoc.aFrames[i].frTimeStamp.lo = 0;
1734	#endif
1735	}
1736
1737	#ifdef USE_LOW_LATENCY_API
1738	if (pUrb->enmDir == VUSBDIRECTION_OUT)
1739	irc = (*pIf->ppIfI)->LowLatencyWriteIsochPipeAsync(pIf->ppIfI, u8PipeRef,
1740	pUrbOsX->u.Isoc.pBuf->pvBuf, FrameNo, pUrb->cIsocPkts, 0, pUrbOsX->u.Isoc.aFrames,
1741	usbProxyDarwinUrbAsyncComplete, pUrbOsX);
1742	else
1743	irc = (*pIf->ppIfI)->LowLatencyReadIsochPipeAsync(pIf->ppIfI, u8PipeRef,
1744	pUrbOsX->u.Isoc.pBuf->pvBuf, FrameNo, pUrb->cIsocPkts, 0, pUrbOsX->u.Isoc.aFrames,
1745	usbProxyDarwinUrbAsyncComplete, pUrbOsX);
1746	#else
1747	if (pUrb->enmDir == VUSBDIRECTION_OUT)
1748	irc = (*pIf->ppIfI)->WriteIsochPipeAsync(pIf->ppIfI, u8PipeRef,
1749	pUrb->abData, FrameNo, pUrb->cIsocPkts, &pUrbOsX->u.Isoc.aFrames[0],
1750	usbProxyDarwinUrbAsyncComplete, pUrbOsX);
1751	else
1752	irc = (*pIf->ppIfI)->ReadIsochPipeAsync(pIf->ppIfI, u8PipeRef,
1753	pUrb->abData, FrameNo, pUrb->cIsocPkts, &pUrbOsX->u.Isoc.aFrames[0],
1754	usbProxyDarwinUrbAsyncComplete, pUrbOsX);
1755	#endif
1756	if ( irc != kIOReturnIsoTooOld
1757	\|\| j >= 5)
1758	{
1759	Log(("%s: usbProxyDarwinUrbQueue: isoc: u64NextFrameNo=%RX64 FrameNo=%RX64 #Frames=%d j=%d (pipe=%d)\n",
1760	pUrb->pszDesc, pPipe->u64NextFrameNo, FrameNo, pUrb->cIsocPkts, j, u8PipeRef));
1761	if (irc == kIOReturnSuccess)
1762	{
1763	if (pPipe->fIsFullSpeed)
1764	pPipe->u64NextFrameNo = FrameNo + pUrb->cIsocPkts;
1765	else
1766	pPipe->u64NextFrameNo = FrameNo + 1;
1767	}
1768	break;
1769	}
1770
1771	/* try again... */
1772	irc = (*pIf->ppIfI)->GetBusFrameNumber(pIf->ppIfI, &FrameNo, &FrameTime);
1773	if (FrameNo <= pPipe->u64NextFrameNo)
1774	FrameNo = pPipe->u64NextFrameNo;
1775	FrameNo += j;
1776	}
1777	break;
1778	}
1779
1780	default:
1781	AssertMsgFailed(("%s: enmType=%#x\n", pUrb->pszDesc, pUrb->enmType));
1782	break;
1783	}
1784
1785	/*
1786	* Success?
1787	*/
1788	if (RT_LIKELY(irc == kIOReturnSuccess))
1789	{
1790	Log(("%s: usbProxyDarwinUrbQueue: success\n", pUrb->pszDesc));
1791	return VINF_SUCCESS;
1792	}
1793	switch (irc)
1794	{
1795	case kIOUSBPipeStalled:
1796	{
1797	/* Increment in flight counter because the completion handler will decrease it always. */
1798	usbProxyDarwinUrbAsyncComplete(pUrbOsX, kIOUSBPipeStalled, 0);
1799	Log(("%s: usbProxyDarwinUrbQueue: pProxyDev=%s EndPt=%d cbData=%d - failed irc=%#x! (stall)\n",
1800	pUrb->pszDesc, pProxyDev->pUsbIns->pszName, pUrb->EndPt, pUrb->cbData, irc));
1801	return VINF_SUCCESS;
1802	}
1803	}
1804
1805	usbProxyDarwinUrbFree(pDevOsX, pUrbOsX);
1806	Log(("%s: usbProxyDarwinUrbQueue: pProxyDev=%s EndPt=%d cbData=%d - failed irc=%#x!\n",
1807	pUrb->pszDesc, pProxyDev->pUsbIns->pszName, pUrb->EndPt, pUrb->cbData, irc));
1808	return RTErrConvertFromDarwin(irc);
1809	}
1810
1811
1812	/**
1813	* Reap URBs in-flight on a device.
1814	*
1815	* @returns Pointer to a completed URB.
1816	* @returns NULL if no URB was completed.
1817	* @param pProxyDev The device.
1818	* @param cMillies Number of milliseconds to wait. Use 0 to not wait at all.
1819	*/
1820	static DECLCALLBACK(PVUSBURB) usbProxyDarwinUrbReap(PUSBPROXYDEV pProxyDev, RTMSINTERVAL cMillies)
1821	{
1822	PVUSBURB pUrb = NULL;
1823	PUSBPROXYDEVOSX pDevOsX = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVOSX);
1824	CFRunLoopRef hRunLoopRef = CFRunLoopGetCurrent();
1825
1826	Assert(!pDevOsX->hRunLoopReaping);
1827
1828	/*
1829	* If the last seen runloop for reaping differs we have to check whether the
1830	* the runloop sources are in the new runloop.
1831	*/
1832	if (pDevOsX->hRunLoopReapingLast != hRunLoopRef)
1833	{
1834	RTCritSectEnter(&pDevOsX->CritSect);
1835
1836	/* Every pipe. */
1837	if (!pDevOsX->pIfHead)
1838	usbProxyDarwinSeizeAllInterfaces(pDevOsX, true /* make the best out of it */);
1839
1840	PUSBPROXYIFOSX pIf;
1841	for (pIf = pDevOsX->pIfHead; pIf; pIf = pIf->pNext)
1842	{
1843	if (!CFRunLoopContainsSource(hRunLoopRef, pIf->RunLoopSrcRef, g_pRunLoopMode))
1844	usbProxyDarwinAddRunLoopRef(&pIf->HeadOfRunLoopLst, pIf->RunLoopSrcRef);
1845	}
1846
1847	/* Default control pipe. */
1848	if (!CFRunLoopContainsSource(hRunLoopRef, pDevOsX->RunLoopSrcRef, g_pRunLoopMode))
1849	usbProxyDarwinAddRunLoopRef(&pDevOsX->HeadOfRunLoopLst, pDevOsX->RunLoopSrcRef);
1850
1851	/* Runloop wakeup source. */
1852	if (!CFRunLoopContainsSource(hRunLoopRef, pDevOsX->hRunLoopSrcWakeRef, g_pRunLoopMode))
1853	usbProxyDarwinAddRunLoopRef(&pDevOsX->HeadOfRunLoopWakeLst, pDevOsX->hRunLoopSrcWakeRef);
1854	RTCritSectLeave(&pDevOsX->CritSect);
1855
1856	pDevOsX->hRunLoopReapingLast = hRunLoopRef;
1857	}
1858
1859	ASMAtomicXchgPtr((void * volatile *)&pDevOsX->hRunLoopReaping, hRunLoopRef);
1860
1861	if (ASMAtomicXchgBool(&pDevOsX->fReapingThreadWake, false))
1862	{
1863	/* Return immediately. */
1864	ASMAtomicXchgPtr((void * volatile *)&pDevOsX->hRunLoopReaping, NULL);
1865	return NULL;
1866	}
1867
1868	/*
1869	* Excercise the runloop until we get an URB or we time out.
1870	*/
1871	if ( !pDevOsX->pTaxingHead
1872	&& cMillies)
1873	CFRunLoopRunInMode(g_pRunLoopMode, cMillies / 1000.0, true);
1874
1875	ASMAtomicXchgPtr((void * volatile *)&pDevOsX->hRunLoopReaping, NULL);
1876	ASMAtomicXchgBool(&pDevOsX->fReapingThreadWake, false);
1877
1878	/*
1879	* Any URBs pending delivery?
1880	*/
1881	while ( pDevOsX->pTaxingHead
1882	&& !pUrb)
1883	{
1884	RTCritSectEnter(&pDevOsX->CritSect);
1885
1886	PUSBPROXYURBOSX pUrbOsX = pDevOsX->pTaxingHead;
1887	if (pUrbOsX)
1888	{
1889	/*
1890	* Remove from the taxing list.
1891	*/
1892	if (pUrbOsX->pNext)
1893	pUrbOsX->pNext->pPrev = pUrbOsX->pPrev;
1894	else if (pDevOsX->pTaxingTail == pUrbOsX)
1895	pDevOsX->pTaxingTail = pUrbOsX->pPrev;
1896
1897	if (pUrbOsX->pPrev)
1898	pUrbOsX->pPrev->pNext = pUrbOsX->pNext;
1899	else if (pDevOsX->pTaxingHead == pUrbOsX)
1900	pDevOsX->pTaxingHead = pUrbOsX->pNext;
1901	else
1902	AssertFailed();
1903
1904	pUrb = pUrbOsX->pVUsbUrb;
1905	if (pUrb)
1906	{
1907	pUrb->Dev.pvPrivate = NULL;
1908	usbProxyDarwinUrbFree(pDevOsX, pUrbOsX);
1909	}
1910	}
1911	RTCritSectLeave(&pDevOsX->CritSect);
1912	}
1913
1914	if (pUrb)
1915	LogFlowFunc(("LEAVE: %s: pProxyDev=%s returns %p\n", pUrb->pszDesc, pProxyDev->pUsbIns->pszName, pUrb));
1916	else
1917	LogFlowFunc(("LEAVE: NULL pProxyDev=%s returns NULL\n", pProxyDev->pUsbIns->pszName));
1918
1919	return pUrb;
1920	}
1921
1922
1923	/**
1924	* Cancels a URB.
1925	*
1926	* The URB requires reaping, so we don't change its state.
1927	*
1928	* @remark There isn't any way to cancel a specific async request
1929	* on darwin. The interface only supports the aborting of
1930	* all URBs pending on an interface / pipe pair. Provided
1931	* the card does the URB cancelling before submitting new
1932	* requests, we should probably be fine...
1933	*/
1934	static DECLCALLBACK(int) usbProxyDarwinUrbCancel(PUSBPROXYDEV pProxyDev, PVUSBURB pUrb)
1935	{
1936	PUSBPROXYDEVOSX pDevOsX = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVOSX);
1937	LogFlow(("%s: usbProxyDarwinUrbCancel: pProxyDev=%s EndPt=%d\n",
1938	pUrb->pszDesc, pProxyDev->pUsbIns->pszName, pUrb->EndPt));
1939
1940	/*
1941	* Determine the interface / endpoint ref and invoke AbortPipe.
1942	*/
1943	IOReturn irc = kIOReturnSuccess;
1944	if (!pUrb->EndPt)
1945	irc = (*pDevOsX->ppDevI)->USBDeviceAbortPipeZero(pDevOsX->ppDevI);
1946	else
1947	{
1948	uint8_t u8PipeRef;
1949	const uint8_t EndPt = pUrb->EndPt \| (pUrb->enmDir == VUSBDIRECTION_IN ? 0x80 : 0);
1950	PUSBPROXYIFOSX pIf = usbProxyDarwinGetInterfaceForEndpoint(pDevOsX, EndPt, &u8PipeRef, NULL);
1951	if (pIf)
1952	irc = (*pIf->ppIfI)->AbortPipe(pIf->ppIfI, u8PipeRef);
1953	else /* this may happen if a device reset, set configuration or set interface has been performed. */
1954	Log(("usbProxyDarwinUrbCancel: pProxyDev=%s pUrb=%p EndPt=%d - cannot find the interface / pipe!\n",
1955	pProxyDev->pUsbIns->pszName, pUrb, pUrb->EndPt));
1956	}
1957
1958	int rc = VINF_SUCCESS;
1959	if (irc != kIOReturnSuccess)
1960	{
1961	Log(("usbProxyDarwinUrbCancel: pProxyDev=%s pUrb=%p EndPt=%d -> %#x!\n",
1962	pProxyDev->pUsbIns->pszName, pUrb, pUrb->EndPt, irc));
1963	rc = RTErrConvertFromDarwin(irc);
1964	}
1965
1966	return rc;
1967	}
1968
1969
1970	static DECLCALLBACK(int) usbProxyDarwinWakeup(PUSBPROXYDEV pProxyDev)
1971	{
1972	PUSBPROXYDEVOSX pDevOsX = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVOSX);
1973
1974	LogFlow(("usbProxyDarwinWakeup: pProxyDev=%p\n", pProxyDev));
1975
1976	ASMAtomicXchgBool(&pDevOsX->fReapingThreadWake, true);
1977	usbProxyDarwinReaperKick(pDevOsX);
1978	return VINF_SUCCESS;
1979	}
1980
1981
1982	/**
1983	* The Darwin USB Proxy Backend.
1984	*/
1985	extern const USBPROXYBACK g_USBProxyDeviceHost =
1986	{
1987	/* pszName */
1988	"host",
1989	/* cbBackend */
1990	sizeof(USBPROXYDEVOSX),
1991	usbProxyDarwinOpen,
1992	NULL,
1993	usbProxyDarwinClose,
1994	usbProxyDarwinReset,
1995	usbProxyDarwinSetConfig,
1996	usbProxyDarwinClaimInterface,
1997	usbProxyDarwinReleaseInterface,
1998	usbProxyDarwinSetInterface,
1999	usbProxyDarwinClearHaltedEp,
2000	usbProxyDarwinUrbQueue,
2001	usbProxyDarwinUrbCancel,
2002	usbProxyDarwinUrbReap,
2003	usbProxyDarwinWakeup,
2004	0
2005	};
2006

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

source: vbox/trunk/src/VBox/Devices/USB/darwin/USBProxyDevice-darwin.cpp@ 69498

Download in other formats: