Changeset 2587 in vbox for trunk/src/VBox

Timestamp:

May 11, 2007 3:12:27 AM (18 years ago)

Author:

vboxsync

Message:

Darwin USB (work in progress)...

Location:

trunk/src/VBox/Main

Files:

• HostImpl.cpp (modified) (1 diff)
• Makefile.kmk (modified) (1 diff)
• USBProxyService.cpp (modified) (3 diffs)
• darwin/iokit.cpp (modified) (7 diffs)
• darwin/iokit.h (modified) (2 diffs)
• include/USBProxyService.h (modified) (2 diffs)

trunk/src/VBox/Main/HostImpl.cpp

@@ -113 +113 @@
     mParent = parent;
 
-#if defined (__LINUX__) && defined (VBOX_WITH_USB)
+#if defined (__DARWIN__) && defined (VBOX_WITH_USB)
+    mUSBProxyService = new USBProxyServiceDarwin (this);
+#elif defined (__LINUX__) && defined (VBOX_WITH_USB)
     mUSBProxyService = new USBProxyServiceLinux (this);
 #elif defined (__WIN__) && defined (VBOX_WITH_USB)

trunk/src/VBox/Main/Makefile.kmk

@@ -202 +202 @@
 
 ifdef VBOX_WITH_USB
+VBoxSVC_SOURCES.darwin += darwin/USBProxyServiceDarwin.cpp
 VBoxSVC_SOURCES.linux += linux/USBProxyServiceLinux.cpp
 VBoxSVC_SOURCES.win   += win32/USBProxyServiceWin32.cpp

trunk/src/VBox/Main/USBProxyService.cpp

@@ -288 +288 @@
     USBProxyService *pThis = (USBProxyService *)pvUser;
     LogFlow (("USBProxyService::serviceThread: pThis=%p\n", pThis));
+    pThis->serviceThreadInit();
 
     /*
@@ -300 +301 @@
     }
 
+    pThis->serviceThreadTerm();
     LogFlow (("USBProxyService::serviceThread: returns VINF_SUCCESS\n"));
     return VINF_SUCCESS;
@@ -391 +393 @@
 }
 
+
+void USBProxyService::serviceThreadInit (void)
+{
+}
+
+
+void USBProxyService::serviceThreadTerm (void)
+{
+}
+
+
 /**
  *  The default implementation returns non-NULL to emulate successful insertions

trunk/src/VBox/Main/darwin/iokit.cpp

@@ -34 +34 @@
 #include <IOKit/scsi-commands/SCSITaskLib.h>
 #include <mach/mach_error.h>
+#ifdef VBOX_WITH_USB
+# include <IOKit/usb/IOUSBLib.h>
+#endif
 
 #include <iprt/mem.h>
@@ -40 +43 @@
 
 #include "iokit.h"
+
+
+/*******************************************************************************
+*   Defined Constants And Macros                                               *
+*******************************************************************************/
+/** An attempt at catching reference leaks. */
+#define MY_CHECK_CREFS(cRefs)   do { AssertMsg(cRefs < 25, ("%ld\n", cRefs)); NOREF(cRefs); } while (0)
 
 
@@ -49 +59 @@
 
 
+/**
+ * Lazily opens the master port.
+ * 
+ * @returns true if the port is open, false on failure (very unlikely).
+ */
+static bool darwinOpenMasterPort(void)
+{
+    if (!g_MasterPort)
+    {
+        kern_return_t krc = IOMasterPort(MACH_PORT_NULL, &g_MasterPort);
+        AssertReturn(krc == KERN_SUCCESS, false);
+    }
+    return true;
+}
+
+
+#ifdef VBOX_WITH_USB
+
+/**
+ * Gets an unsigned 8-bit integer value.
+ * 
+ * @returns Success indicator (true/false).
+ * @param   DictRef     The dictionary.
+ * @param   KeyStrRef   The key name.
+ * @param   pu8         Where to store the key value.
+ */
+static bool darwinDictGetU8(CFMutableDictionaryRef DictRef, CFStringRef KeyStrRef, uint8_t *pu8)
+{
+    CFTypeRef ValRef = CFDictionaryGetValue(DictRef, KeyStrRef);
+    if (ValRef)
+    {
+        if (CFNumberGetValue((CFNumberRef)ValRef, kCFNumberSInt8Type, pu8))
+            return true;
+    }
+    *pu8 = 0;
+    return false;
+}
+
+
+/**
+ * Gets an unsigned 16-bit integer value.
+ * 
+ * @returns Success indicator (true/false).
+ * @param   DictRef     The dictionary.
+ * @param   KeyStrRef   The key name.
+ * @param   pu16        Where to store the key value.
+ */
+static bool darwinDictGetU16(CFMutableDictionaryRef DictRef, CFStringRef KeyStrRef, uint16_t *pu16)
+{
+    CFTypeRef ValRef = CFDictionaryGetValue(DictRef, KeyStrRef);
+    if (ValRef)
+    {
+        if (CFNumberGetValue((CFNumberRef)ValRef, kCFNumberSInt16Type, pu16))
+            return true;
+    }
+    *pu16 = 0;
+    return false;
+}
+
+
+/**
+ * Gets an unsigned 32-bit integer value.
+ * 
+ * @returns Success indicator (true/false).
+ * @param   DictRef     The dictionary.
+ * @param   KeyStrRef   The key name.
+ * @param   pu32        Where to store the key value.
+ */
+static bool darwinDictGetU32(CFMutableDictionaryRef DictRef, CFStringRef KeyStrRef, uint32_t *pu32)
+{
+    CFTypeRef ValRef = CFDictionaryGetValue(DictRef, KeyStrRef);
+    if (ValRef)
+    {
+        if (CFNumberGetValue((CFNumberRef)ValRef, kCFNumberSInt32Type, pu32))
+            return true;
+    }
+    *pu32 = 0;
+    return false;
+}
+
+
+/**
+ * Gets an unsigned 64-bit integer value.
+ * 
+ * @returns Success indicator (true/false).
+ * @param   DictRef     The dictionary.
+ * @param   KeyStrRef   The key name.
+ * @param   pu64        Where to store the key value.
+ */
+static bool darwinDictGetU64(CFMutableDictionaryRef DictRef, CFStringRef KeyStrRef, uint64_t *pu64)
+{
+    CFTypeRef ValRef = CFDictionaryGetValue(DictRef, KeyStrRef);
+    if (ValRef)
+    {
+        if (CFNumberGetValue((CFNumberRef)ValRef, kCFNumberSInt64Type, pu64))
+            return true;
+    }
+    *pu64 = 0;
+    return false;
+}
+
+
+/**
+ * Gets string value, converted to UTF-8 and put in a IPRT string buffer.
+ * 
+ * @returns Success indicator (true/false).
+ * @param   DictRef     The dictionary.
+ * @param   KeyStrRef   The key name.
+ * @param   ppsz        Where to store the key value. Free with RTStrFree. Set to NULL on failure.
+ */
+static bool darwinDictGetString(CFMutableDictionaryRef DictRef, CFStringRef KeyStrRef, char **ppsz)
+{
+    CFTypeRef ValRef = CFDictionaryGetValue(DictRef, KeyStrRef);
+    if (ValRef)
+    {
+        char szBuf[512];
+        if (CFStringGetCString((CFStringRef)ValRef, szBuf, sizeof(szBuf), kCFStringEncodingUTF8))
+        {
+            *ppsz = RTStrDup(RTStrStrip(szBuf));
+            if (*ppsz)
+                return true;
+        }
+    }
+    *ppsz = NULL;
+    return false;
+}
+
+
+
+void        DarwinSubscribeUSBNotifications(void)
+{
+
+}
+
+void        DarwinUnsubscribeUSBNotifications(void)
+{
+
+}
+
+
+/**
+ * Enumerate the USB devices returning a FIFO of them.
+ *
+ * @returns Pointer to the head.
+ *          USBProxyService::freeDevice is expected to free each of the list elements.
+ */
+PUSBDEVICE DarwinGetUSBDevices(void)
+{
+    AssertReturn(darwinOpenMasterPort(), NULL);
+
+    /*
+     * Create a matching dictionary for searching for USB Devices in the IOKit.
+     */
+    CFMutableDictionaryRef RefMatchingDict = IOServiceMatching(kIOUSBDeviceClassName);
+    AssertReturn(RefMatchingDict, NULL);
+
+    /*
+     * Perform the search and get a collection of USB Device back.
+     */
+    io_iterator_t USBDevices = NULL;
+    IOReturn rc = IOServiceGetMatchingServices(g_MasterPort, RefMatchingDict, &USBDevices);
+    AssertMsgReturn(rc == kIOReturnSuccess, ("rc=%d\n", rc), NULL);
+    RefMatchingDict = NULL; /* the reference is consumed by IOServiceGetMatchingServices. */
+
+    /*
+     * Enumerate the USB Devices.
+     */
+    PUSBDEVICE pHead = NULL;
+    PUSBDEVICE pTail = NULL;
+    unsigned i = 0;
+    io_object_t USBDevice;
+    while ((USBDevice = IOIteratorNext(USBDevices)) != 0)
+    {
+        /*
+         * Query the device properties from the registry.
+         *
+         * We could alternatively use the device and such, but that will be 
+         * slower and we would have to resort to the registry for the three
+         * string anyway.
+         */
+        CFMutableDictionaryRef PropsRef = 0;
+        kern_return_t krc = IORegistryEntryCreateCFProperties(USBDevice, &PropsRef, kCFAllocatorDefault, kNilOptions);
+        if (krc == KERN_SUCCESS)
+        {
+            bool fOk = false;
+            PUSBDEVICE pCur = (PUSBDEVICE)RTMemAllocZ(sizeof(*pCur));
+            do /* loop for breaking out of on failure. */
+            {
+                AssertBreak(pCur,);
+
+                /* 
+                 * Mandatory 
+                 */
+                pCur->bcdUSB = 0;                                           /* we've no idea. */
+                pCur->enmState = USBDEVICESTATE_USED_BY_HOST_CAPTURABLE;    /* ditto. */
+
+                AssertBreak(darwinDictGetU8(PropsRef,  CFSTR(kUSBDeviceClass),           &pCur->bDeviceClass),);
+                /* skip hubs */
+                if (pCur->bDeviceClass == 0x09 /* hub, find a define! */)
+                    break;
+                AssertBreak(darwinDictGetU8(PropsRef,  CFSTR(kUSBDeviceSubClass),       &pCur->bDeviceSubClass),);
+                AssertBreak(darwinDictGetU8(PropsRef,  CFSTR(kUSBDeviceProtocol),       &pCur->bDeviceProtocol),);
+                AssertBreak(darwinDictGetU16(PropsRef, CFSTR(kUSBVendorID),             &pCur->idVendor),);
+                AssertBreak(darwinDictGetU16(PropsRef, CFSTR(kUSBProductID),            &pCur->idProduct),);
+                AssertBreak(darwinDictGetU16(PropsRef, CFSTR(kUSBDeviceReleaseNumber),  &pCur->bcdDevice),);
+                char szAddress[32];
+#if 0                            
+                uint32_t u32LocationID;
+                AssertBreak(darwinDictGetU32(PropsRef, CFSTR(kUSBDevicePropertyLocationID), &u32LocationID),);
+                RTStrPrintf(szAddress, sizeof(szAddress), "%08RX32", u32LocationID);
+#else
+                uint64_t u64SessionID;
+                AssertBreak(darwinDictGetU64(PropsRef, CFSTR(kUSBDevicePropertyLocationID), &u64SessionID),);
+                RTStrPrintf(szAddress, sizeof(szAddress), "%016RX32", u64SessionID);
+#endif 
+                pCur->pszAddress = RTStrDup(szAddress);  
+                AssertBreak(pCur->pszAddress,);
+
+                /* 
+                 * Optional.
+                 * There are some nameless device in the iMac, apply names to them.
+                 */
+                darwinDictGetString(PropsRef, CFSTR("USB Vendor Name"),     (char **)&pCur->pszManufacturer);
+                if (    !pCur->pszManufacturer 
+                    &&  pCur->idVendor == kIOUSBVendorIDAppleComputer)
+                    pCur->pszManufacturer = RTStrDup("Apple Computer, Inc.");
+                darwinDictGetString(PropsRef, CFSTR("USB Product Name"),    (char **)&pCur->pszProduct);
+                if (    !pCur->pszProduct
+                    &&  pCur->bDeviceClass == 224 /* Wireless */
+                    &&  pCur->bDeviceSubClass == 1 /* Radio Frequency */
+                    &&  pCur->bDeviceProtocol == 1 /* Bluetooth */)
+                    pCur->pszProduct = RTStrDup("Bluetooth");
+                darwinDictGetString(PropsRef, CFSTR("USB Serial Number"),   (char **)&pCur->pszSerialNumber);
+
+#if 0           /* leave the remainder as zero for now. */
+                /*
+                 * Create a plugin interface for the service and query its USB Device interface.
+                 */
+                SInt32 Score = 0;
+                IOCFPlugInInterface **ppPlugInInterface = NULL;
+                rc = IOCreatePlugInInterfaceForService(USBDevice, kIOUSBDeviceUserClientTypeID,
+                                                       kIOCFPlugInInterfaceID, &ppPlugInInterface, &Score);
+                if (rc == kIOReturnSuccess)
+                {
+                    IOUSBDeviceInterface245 **ppUSBDevI = NULL;
+                    HRESULT hrc = (*ppPlugInInterface)->QueryInterface(ppPlugInInterface,
+                                                                       CFUUIDGetUUIDBytes(kIOUSBDeviceInterfaceID245),
+                                                                       (LPVOID *)&ppUSBDevI);
+                    rc = IODestroyPlugInInterface(ppPlugInInterface); Assert(rc == kIOReturnSuccess);
+                    ppPlugInInterface = NULL;
+                    if (hrc == S_OK)
+                    {
+                        /** @todo enumerate configurations and interfaces if we actually need them. */
+                        //IOReturn (*GetNumberOfConfigurations)(void *self, UInt8 *numConfig);
+                        //IOReturn (*GetConfigurationDescriptorPtr)(void *self, UInt8 configIndex, IOUSBConfigurationDescriptorPtr *desc);
+                        //IOReturn (*CreateInterfaceIterator)(void *self, IOUSBFindInterfaceRequest *req, io_iterator_t *iter);
+                    }
+                    long cReft = (*ppUSBDeviceInterface)->Release(ppUSBDeviceInterface); MY_CHECK_CREFS(cRefs);
+                }
+#endif 
+
+                /*
+                 * We're good. Link the device.
+                 */
+                pCur->pPrev = pTail;
+                if (pTail)
+                    pTail = pTail->pNext = pCur;
+                else
+                    pTail = pHead = pCur;
+                fOk = true;
+            } while (0);
+
+            /* cleanup on failure / skipped device. */
+            if (!fOk && pCur)
+            {
+                /** @todo */
+            }
+
+            CFRelease(PropsRef);
+        }
+        else
+            AssertMsgFailed(("krc=%#x\n", krc));
+
+        IOObjectRelease(USBDevice);
+        i++;
+    }
+
+    IOObjectRelease(USBDevices);
+
+    /*
+     * Some post processing. There are a couple of things we have to 
+     * make 100% sure about, and that is that the (Apple) keyboard
+     * and mouse most likely to be in use by the user aren't available
+     * for capturing. If there is no Apple mouse or keyboard we'll
+     * take the first one from another vendor.
+     */
+    PUSBDEVICE pMouse = NULL;
+    PUSBDEVICE pKeyboard = NULL;
+    for (PUSBDEVICE pCur = pHead; pCur; pCur = pCur->pNext)
+        if (pCur->idVendor == kIOUSBVendorIDAppleComputer)
+        {
+            /*
+             * This test is a bit rough, should check device class/protocol but 
+             * we don't have interface info yet so that might be a bit tricky. 
+             */
+            if (    (   !pKeyboard 
+                     || pKeyboard->idVendor != kIOUSBVendorIDAppleComputer)
+                &&  pCur->pszProduct
+                &&  strstr(pCur->pszProduct, " Keyboard"))
+                pKeyboard = pCur;
+            else if (    (   !pMouse
+                          || pMouse->idVendor != kIOUSBVendorIDAppleComputer)
+                     &&  pCur->pszProduct
+                     &&  strstr(pCur->pszProduct, " Mouse")
+                )
+                pMouse = pCur;
+        }
+        else if (!pKeyboard || !pMouse)
+        {
+            if (    pCur->bDeviceClass == 3         /* HID */
+                &&  pCur->bDeviceProtocol == 1      /* Keyboard */)
+                pKeyboard = pCur;
+            else if (   pCur->bDeviceClass == 3     /* HID */
+                     && pCur->bDeviceProtocol == 2  /* Mouse */)
+                pMouse = pCur;
+            /** @todo examin interfaces */
+        }
+
+    if (pKeyboard)
+        pKeyboard->enmState = USBDEVICESTATE_USED_BY_HOST;
+    if (pMouse)
+        pMouse->enmState = USBDEVICESTATE_USED_BY_HOST;
+
+    return pHead;
+}
+
+#endif /* VBOX_WITH_USB */
+
 
 /**
@@ -58 +406 @@
 PDARWINDVD DarwinGetDVDDrives(void)
 {
-    PDARWINDVD pHead = NULL;
-    PDARWINDVD pTail = NULL;
-
-    /*
-     * Open the master port on the first invocation.
-     */
-    if (!g_MasterPort)
-    {
-        kern_return_t krc = IOMasterPort(MACH_PORT_NULL, &g_MasterPort);
-        AssertReturn(krc == KERN_SUCCESS, NULL);
-    }
+    AssertReturn(darwinOpenMasterPort(), NULL);
 
     /*
@@ -83 +421 @@
 
     /*
-     * do the search and get a collection of keyboards.
+     * Perform the search and get a collection of DVD services.
      */
     io_iterator_t DVDServices = NULL;
@@ -91 +429 @@
 
     /*
-     * Enumerate the DVD drives (services).
+     * Enumerate the DVD services.
      * (This enumeration must be identical to the one performed in DrvHostBase.cpp.)
      */
+    PDARWINDVD pHead = NULL;
+    PDARWINDVD pTail = NULL;
     unsigned i = 0;
     io_object_t DVDService;
@@ -186 +526 @@
     return pHead;
 }
+

trunk/src/VBox/Main/darwin/iokit.h

@@ -25 +25 @@
 #include <iprt/cdefs.h>
 #include <iprt/types.h>
+#ifdef VBOX_WITH_USB
+# include <VBox/usb.h>
+#endif 
 
 /**
@@ -37 +40 @@
 } DARWINDVD, *PDARWINDVD;
 
+/** The run loop mode string used by iokit.cpp when it registers 
+ * notifications events. */
+#define VBOX_IOKIT_MODE_STRING "VBoxIOKitMode"
 
 __BEGIN_DECLS
-PDARWINDVD DarwinGetDVDDrives(void);
+PDARWINDVD  DarwinGetDVDDrives(void);
+#ifdef VBOX_WITH_USB
+void        DarwinSubscribeUSBNotifications(void);
+void        DarwinUnsubscribeUSBNotifications(void);
+PUSBDEVICE  DarwinGetUSBDevices(void);
+#endif
 __END_DECLS
-
 
 #endif

trunk/src/VBox/Main/include/USBProxyService.h

@@ -149 +149 @@
     virtual PUSBDEVICE getDevices (void);
 
+    /**
+     * First call made on the service thread, use it to do 
+     * thread initialization.
+     */
+    virtual void serviceThreadInit (void);
+
+    /**
+     * First call made on the service thread, use it to do 
+     * thread termination.
+     */
+    virtual void serviceThreadTerm (void);
+
 public:
     /**
@@ -190 +202 @@
 #ifdef VBOX_WITH_USB
 
+# ifdef __DARWIN__
+#  include <VBox/param.h>
+#  undef PAGE_SHIFT
+#  undef PAGE_SIZE
+#  define OSType Carbon_OSType
+#  include <Carbon/Carbon.h>
+#  undef OSType
+
+/**
+ * The Darwin hosted USB Proxy Service.
+ */
+class USBProxyServiceDarwin : public USBProxyService
+{
+public:
+    USBProxyServiceDarwin (Host *aHost);
+    ~USBProxyServiceDarwin();
+
+    virtual int captureDevice (HostUSBDevice *aDevice);
+    virtual int holdDevice (HostUSBDevice *aDevice);
+    virtual int releaseDevice (HostUSBDevice *aDevice);
+    virtual int resetDevice (HostUSBDevice *aDevice);
+
+protected:
+    virtual int wait (unsigned aMillies);
+    virtual int interruptWait (void);
+    virtual PUSBDEVICE getDevices (void);
+    virtual void serviceThreadInit (void);
+    virtual void serviceThreadTerm (void);
+
+private:
+    /** Reference to the runloop of the service thread. 
+     * This is NULL if the service thread isn't running. */
+    CFRunLoopRef mServiceRunLoopRef;
+
+};
+# endif /* __DARWIN__ */
+
+
 # ifdef __LINUX__
 #  include <stdio.h>