diff --git a/AUTHORS b/AUTHORS
index 06fc76b..cac71c2 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -1,5 +1,6 @@
 Copyright (C) 2007-2008 Daniel Drake <dsd@gentoo.org>
 Copyright (c) 2001 Johannes Erdfelt <johannes@erdfelt.com>
+Copyright (C) 2008-2009 Nathan Hjelm <hjelmn@users.sourceforge.net>
 
 Other contributors:
 Artem Egorkine
diff --git a/autogen.sh b/autogen.sh
index 4f5e612..d5c6a19 100755
--- a/autogen.sh
+++ b/autogen.sh
@@ -1,5 +1,9 @@
 #!/bin/sh
-libtoolize --copy --force || exit 1
+
+# use glibtoolize if it is available (darwin)
+(glibtoolize --version) < /dev/null > /dev/null 2>&1 && LIBTOOLIZE=glibtoolize || LIBTOOLIZE=libtoolize
+
+$LIBTOOLIZE --copy --force || exit 1
 aclocal || exit 1
 autoheader || exit 1
 autoconf || exit 1
diff --git a/configure.ac b/configure.ac
index 2e344f7..0b586bc 100644
--- a/configure.ac
+++ b/configure.ac
@@ -18,12 +18,21 @@
 	AC_MSG_RESULT([Linux])
 	backend="linux"
 	AC_CHECK_LIB(rt, clock_gettime)
+	AM_LDFLAGS=""
+	;;
+*-darwin*)
+	AC_DEFINE(OS_DARWIN, [], [Darwin backend])
+	AC_SUBST(OS_DARWIN)
+	AC_MSG_RESULT([Darwin/MacOS X])
+	backend="darwin"
+	AM_LDFLAGS="-Wl,-framework -Wl,IOKit -Wl,-framework -Wl,CoreFoundation -Wl,-prebind -no-undefined"
 	;;
 *)
 	AC_MSG_ERROR([unsupported operating system])
 esac
 
 AM_CONDITIONAL([OS_LINUX], [test "x$backend" == "xlinux"])
+AM_CONDITIONAL([OS_DARWIN], [test "x$backend" == "xdarwin"])
 
 # Library versioning
 lt_major="0"
@@ -64,7 +73,9 @@
 
 AC_DEFINE([API_EXPORTED], [__attribute__((visibility("default")))], [Default visibility])
 AM_CFLAGS="-std=gnu99 $inline_cflags -Wall -Wundef -Wunused -Wstrict-prototypes -Werror-implicit-function-declaration -Wno-pointer-sign -Wshadow"
+
 AC_SUBST(AM_CFLAGS)
+AC_SUBST(AM_LDFLAGS)
 
 AC_CONFIG_FILES([libusb-1.0.pc] [Makefile] [libusb/Makefile] [examples/Makefile] [doc/Makefile] [doc/doxygen.cfg])
 AC_OUTPUT
diff --git a/libusb/Makefile.am b/libusb/Makefile.am
index 9ad8ec5..3551603 100644
--- a/libusb/Makefile.am
+++ b/libusb/Makefile.am
@@ -1,13 +1,19 @@
 lib_LTLIBRARIES = libusb-1.0.la
 
 LINUX_USBFS_SRC = os/linux_usbfs.h os/linux_usbfs.c
+DARWIN_USB_SRC = os/darwin_usb.h os/darwin_usb.c
 
-EXTRA_DIST = $(LINUX_USBFS_SRC)
+EXTRA_DIST = $(LINUX_USBFS_SRC) $(DARWIN_USB_SRC)
 
 if OS_LINUX
 OS_SRC = $(LINUX_USBFS_SRC)
 endif
 
+if OS_DARWIN
+OS_SRC = $(DARWIN_USB_SRC)
+AM_CFLAGS_EXT = -no-cpp-precomp
+endif
+
 libusb_1_0_la_CFLAGS = -fvisibility=hidden $(AM_CFLAGS) -pthread
 libusb_1_0_la_SOURCES = libusbi.h core.c descriptor.c io.c sync.c $(OS_SRC)
 
diff --git a/libusb/core.c b/libusb/core.c
index 5970aee..b188a38 100644
--- a/libusb/core.c
+++ b/libusb/core.c
@@ -32,8 +32,10 @@
 #include "libusb.h"
 #include "libusbi.h"
 
-#ifdef OS_LINUX
+#if defined(OS_LINUX)
 const struct usbi_os_backend * const usbi_backend = &linux_usbfs_backend;
+#elif defined(OS_DARWIN)
+const struct usbi_os_backend * const usbi_backend = &darwin_backend;
 #else
 #error "Unsupported OS"
 #endif
diff --git a/libusb/libusbi.h b/libusb/libusbi.h
index da636b2..9813c4d 100644
--- a/libusb/libusbi.h
+++ b/libusb/libusbi.h
@@ -774,6 +774,7 @@
 extern const struct usbi_os_backend * const usbi_backend;
 
 extern const struct usbi_os_backend linux_usbfs_backend;
+extern const struct usbi_os_backend darwin_backend;
 
 #endif
 
diff --git a/libusb/os/darwin_usb.c b/libusb/os/darwin_usb.c
new file mode 100644
index 0000000..3a0f0be
--- /dev/null
+++ b/libusb/os/darwin_usb.c
@@ -0,0 +1,1449 @@
+/*
+ * darwin backend for libusb 1.0
+ * Copyright (C) 2008-2009 Nathan Hjelm <hjelmn@users.sourceforge.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <config.h>
+#include <ctype.h>
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <mach/clock.h>
+#include <mach/clock_types.h>
+#include <mach/mach_host.h>
+
+#include <mach/mach_port.h>
+#include <IOKit/IOCFBundle.h>
+#include <IOKit/usb/IOUSBLib.h>
+#include <IOKit/IOCFPlugIn.h>
+
+#include "darwin_usb.h"
+
+static mach_port_t  libusb_darwin_mp = 0; /* master port */
+static CFRunLoopRef libusb_darwin_acfl = NULL; /* async cf loop */
+
+/* async event thread */
+static pthread_t libusb_darwin_at;
+
+static int darwin_get_config_descriptor(struct libusb_device *dev, uint8_t config_index, unsigned char *buffer, size_t len, int *host_endian);
+static int darwin_claim_interface(struct libusb_device_handle *dev_handle, int iface);
+static int darwin_release_interface(struct libusb_device_handle *dev_handle, int iface);
+static int darwin_reset_device(struct libusb_device_handle *dev_handle);
+static void darwin_bulk_callback (struct usbi_transfer *itransfer, kern_return_t result, UInt32 io_size);
+static void darwin_isoc_callback (struct usbi_transfer *itransfer, kern_return_t result);
+static void darwin_control_callback (struct usbi_transfer *itransfer, kern_return_t result, UInt32 io_size);
+static void darwin_async_io_callback (void *refcon, IOReturn result, void *arg0);
+
+static char *darwin_error_str (int result) {
+  switch (result) {
+  case kIOReturnSuccess:
+    return "no error";
+  case kIOReturnNotOpen:
+    return "device not opened for exclusive access";
+  case kIOReturnNoDevice:
+    return "no connection to an IOService";
+  case kIOUSBNoAsyncPortErr:
+    return "no async port has been opened for interface";
+  case kIOReturnExclusiveAccess:
+    return "another process has device opened for exclusive access";
+  case kIOUSBPipeStalled:
+    return "pipe is stalled";
+  case kIOReturnError:
+    return "could not establish a connection to the Darwin kernel";
+  case kIOUSBTransactionTimeout:
+    return "transaction timed out";
+  case kIOReturnBadArgument:
+    return "invalid argument";
+  case kIOReturnAborted:
+    return "transaction aborted";
+  case kIOReturnNotResponding:
+    return "device not responding";
+  default:
+    return "unknown error";
+  }
+}
+
+static int darwin_to_libusb (int result) {
+  switch (result) {
+  case kIOReturnSuccess:
+    return LIBUSB_SUCCESS;
+  case kIOReturnNotOpen:
+  case kIOReturnNoDevice:
+    return LIBUSB_ERROR_NO_DEVICE;
+  case kIOReturnExclusiveAccess:
+    return LIBUSB_ERROR_ACCESS;
+  case kIOUSBPipeStalled:
+    return LIBUSB_ERROR_PIPE;
+  case kIOReturnBadArgument:
+    return LIBUSB_ERROR_INVALID_PARAM;
+  case kIOUSBTransactionTimeout:
+    return LIBUSB_ERROR_TIMEOUT;
+  case kIOReturnNotResponding:
+  case kIOReturnAborted:
+  case kIOReturnError:
+  case kIOUSBNoAsyncPortErr:
+  default:
+    return LIBUSB_ERROR_OTHER;
+  }
+}
+
+
+static int ep_to_pipeRef(struct libusb_device_handle *dev_handle, uint8_t ep, uint8_t *pipep, uint8_t *ifcp) {
+  struct darwin_device_handle_priv *priv = (struct darwin_device_handle_priv *)dev_handle->os_priv;
+
+  /* current interface */
+  struct __darwin_interface *cInterface;
+
+  int8_t i, iface;
+
+  _usbi_log (HANDLE_CTX(dev_handle), LOG_LEVEL_INFO, "converting ep address 0x%02x to pipeRef and interface", ep);
+
+  for (iface = 0 ; iface < USB_MAXINTERFACES ; iface++) {
+    cInterface = &priv->interfaces[iface];
+
+    if (dev_handle->claimed_interfaces & (1 << iface)) {
+      for (i = 0 ; i < cInterface->num_endpoints ; i++) {
+	if (cInterface->endpoint_addrs[i] == ep) {
+	  *pipep = i + 1;
+	  *ifcp = iface;
+	  _usbi_log (HANDLE_CTX(dev_handle), LOG_LEVEL_INFO, "pipe %d on interface %d matches", *pipep, *ifcp);
+	  return 0;
+	}
+      }
+    }
+  }
+
+  /* No pipe found with the correct endpoint address */
+  _usbi_log (HANDLE_CTX(dev_handle), LOG_LEVEL_WARNING, "no pipeRef found with endpoint address 0x%02x.", ep);
+  
+  return -1;
+}
+
+static int usb_setup_device_iterator (io_iterator_t *deviceIterator) {
+  return IOServiceGetMatchingServices(libusb_darwin_mp, IOServiceMatching(kIOUSBDeviceClassName), deviceIterator);
+}
+
+static usb_device_t **usb_get_next_device (io_iterator_t deviceIterator, UInt32 *locationp) {
+  io_cf_plugin_ref_t *plugInInterface = NULL;
+  usb_device_t **device;
+  io_service_t usbDevice;
+  long result, score;
+
+  if (!IOIteratorIsValid (deviceIterator) || !(usbDevice = IOIteratorNext(deviceIterator)))
+    return NULL;
+  
+  result = IOCreatePlugInInterfaceForService(usbDevice, kIOUSBDeviceUserClientTypeID,
+					     kIOCFPlugInInterfaceID, &plugInInterface,
+					     &score);
+  
+  if (result || !plugInInterface) {
+    usbi_dbg ("libusb/darwin.c usb_get_next_device: could not set up plugin for service: %s\n", darwin_error_str (result));
+
+    return NULL;
+  }
+
+  (void)IOObjectRelease(usbDevice);
+  (void)(*plugInInterface)->QueryInterface(plugInInterface, CFUUIDGetUUIDBytes(DeviceInterfaceID),
+					   (LPVOID)&device);
+
+  (*plugInInterface)->Stop(plugInInterface);
+  IODestroyPlugInInterface (plugInInterface);
+  
+  (*(device))->GetLocationID(device, locationp);
+
+  return device;
+}
+
+static kern_return_t darwin_get_device (uint32_t dev_location, usb_device_t ***darwin_device) {
+  kern_return_t kresult;
+  UInt32        location;
+  io_iterator_t deviceIterator;
+
+  kresult = usb_setup_device_iterator (&deviceIterator);
+  if (kresult)
+    return kresult;
+
+  /* This port of libusb uses locations to keep track of devices. */
+  while ((*darwin_device = usb_get_next_device (deviceIterator, &location)) != NULL) {
+    if (location == dev_location)
+      break;
+
+    (**darwin_device)->Release(*darwin_device);
+  }
+
+  IOObjectRelease (deviceIterator);
+
+  if (!(*darwin_device))
+    return kIOReturnNoDevice;
+
+  return kIOReturnSuccess;
+}
+
+
+
+static void darwin_devices_detached (void *ptr, io_iterator_t rem_devices) {  
+  struct libusb_context *ctx = (struct libusb_context *)ptr;
+  struct libusb_device_handle *handle;
+  struct darwin_device_priv *dpriv;
+  struct darwin_device_handle_priv *priv;
+
+  io_service_t device;
+  long location;
+  CFTypeRef locationCF;
+  UInt32 message;
+
+  _usbi_log (ctx, LOG_LEVEL_INFO, "a device has been detached");
+
+  while ((device = IOIteratorNext (rem_devices)) != 0) {
+    /* get the location from the i/o registry */
+    locationCF = IORegistryEntryCreateCFProperty (device, CFSTR(kUSBDevicePropertyLocationID), kCFAllocatorDefault, 0);
+
+    CFNumberGetValue(locationCF, kCFNumberLongType, &location);
+    CFRelease (locationCF);
+    IOObjectRelease (device);
+
+    list_for_each_entry(handle, &ctx->open_devs, list) {
+      dpriv = (struct darwin_device_priv *)handle->dev->os_priv;
+      if (dpriv->location == location)
+	break;
+    }
+
+    if (handle) {
+      priv  = (struct darwin_device_handle_priv *)handle->os_priv;
+
+      message = MESSAGE_DEVICE_GONE;
+      write (priv->fds[1], &message, sizeof (message));
+
+      CFRunLoopRemoveSource (libusb_darwin_acfl, priv->cfSource, kCFRunLoopDefaultMode);
+      CFRelease (priv->cfSource);
+      priv->cfSource = NULL;
+    }
+  }
+}
+
+static void darwin_clear_iterator (io_iterator_t iter) {
+  io_service_t device;
+
+  while ((device = IOIteratorNext (iter)) != 0)
+    IOObjectRelease (device);
+}
+
+static void *event_thread_main (void *arg0) {
+  IOReturn kresult;
+  struct libusb_context *ctx = (struct libusb_context *)arg0;
+
+  /* hotplug (device removal) source */
+  CFRunLoopSourceRef     libusb_notification_cfsource;
+  io_notification_port_t libusb_notification_port;
+  io_iterator_t          libusb_rem_device_iterator;
+
+  _usbi_log (ctx, LOG_LEVEL_INFO, "creating hotplug event source");
+
+  /* add the notification port to the run loop */
+  libusb_notification_port     = IONotificationPortCreate (libusb_darwin_mp);
+  libusb_notification_cfsource = IONotificationPortGetRunLoopSource (libusb_notification_port);
+  CFRunLoopAddSource(CFRunLoopGetCurrent (), libusb_notification_cfsource, kCFRunLoopDefaultMode);
+
+  /* create notifications for removed devices */
+  kresult = IOServiceAddMatchingNotification (libusb_notification_port, kIOTerminatedNotification,
+					      IOServiceMatching(kIOUSBDeviceClassName),
+					      (IOServiceMatchingCallback)darwin_devices_detached,
+					      (void *)ctx, &libusb_rem_device_iterator);
+ 
+  if (kresult != kIOReturnSuccess) {
+    _usbi_log (ctx, LOG_LEVEL_ERROR, "could not add hotplug event source: %s", darwin_error_str (kresult));
+
+    pthread_exit ((void *)kresult);
+  }
+
+  /* arm notifiers */
+  darwin_clear_iterator (libusb_rem_device_iterator);
+
+  /* let the main thread know about the async runloop */
+  libusb_darwin_acfl = CFRunLoopGetCurrent ();
+
+  _usbi_log (ctx, LOG_LEVEL_INFO, "libopenusb/darwin.c event_thread_main: thread ready to receive events");
+
+  /* run the runloop */
+  CFRunLoopRun();
+
+  _usbi_log (ctx, LOG_LEVEL_INFO, "libopenusb/darwin.c event_thread_main: thread exiting");
+
+  /* delete notification port */
+  CFRunLoopSourceInvalidate (libusb_notification_cfsource);
+  IONotificationPortDestroy (libusb_notification_port);
+  
+  libusb_darwin_acfl = NULL;
+
+  pthread_exit (0);
+}
+
+static int darwin_init(struct libusb_context *ctx) {
+  IOReturn kresult;
+
+  /* Create the master port for talking to IOKit */
+  if (!libusb_darwin_mp) {
+    kresult = IOMasterPort (MACH_PORT_NULL, &libusb_darwin_mp);
+
+    if (kresult != kIOReturnSuccess || !libusb_darwin_mp)
+      return darwin_to_libusb (kresult);
+  }
+
+  pthread_create (&libusb_darwin_at, NULL, event_thread_main, (void *)ctx);
+
+  while (!libusb_darwin_acfl)
+    usleep (10);
+
+  return 0;
+}
+
+static void darwin_exit (void) {
+  void *ret;
+
+  /* stop the async runloop */
+  CFRunLoopStop (libusb_darwin_acfl);
+  pthread_join (libusb_darwin_at, &ret);
+
+  if (libusb_darwin_mp)
+    mach_port_deallocate(mach_task_self(), libusb_darwin_mp);
+
+  libusb_darwin_mp = 0;
+}
+
+static int darwin_get_device_descriptor(struct libusb_device *dev, unsigned char *buffer, int *host_endian) {
+  struct darwin_device_priv *priv = (struct darwin_device_priv *)dev->os_priv;
+
+  /* return cached copy */
+  memmove (buffer, &(priv->dev_descriptor), DEVICE_DESC_LENGTH);
+
+  *host_endian = 0;
+
+  return 0;
+}
+
+static int darwin_get_active_config_descriptor(struct libusb_device *dev, unsigned char *buffer, size_t len, int *host_endian) {
+  struct darwin_device_priv *priv = (struct darwin_device_priv *)dev->os_priv;
+  UInt8 configNum;
+  IOReturn kresult;
+
+  kresult = (*(priv->device))->GetConfiguration (priv->device, &configNum);
+  if (kresult != kIOReturnSuccess)
+    return darwin_to_libusb (kresult);
+
+  return darwin_get_config_descriptor (dev, configNum, buffer, len, host_endian);
+}
+
+static int darwin_get_config_descriptor(struct libusb_device *dev, uint8_t config_index, unsigned char *buffer, size_t len, int *host_endian) {
+  struct darwin_device_priv *priv = (struct darwin_device_priv *)dev->os_priv;
+  IOUSBConfigurationDescriptorPtr desc;
+  IOReturn kresult;
+
+  kresult = (*(priv->device))->GetConfigurationDescriptorPtr (priv->device, config_index, &desc);
+  if (kresult != kIOReturnSuccess)
+    return darwin_to_libusb (kresult);
+
+  /* sanity check. is the buffer larger than the returned descriptor */
+  if (len > sizeof (*desc))
+    len = sizeof (*desc);
+
+  memmove (buffer, desc, len);
+
+  /* GetConfigurationDescriptorPtr returns the descriptor is USB bus order */
+  *host_endian = 0;
+
+  return 0;
+}
+
+static int process_new_device (struct libusb_context *ctx, usb_device_t **device, UInt32 locationID, struct discovered_devs **_discdevs) {
+  struct darwin_device_priv *priv;
+  struct libusb_device *dev; 
+  struct discovered_devs *discdevs;
+  UInt16                address, idVendor, idProduct;
+  UInt8                 bDeviceClass, bDeviceSubClass;
+  IOUSBDevRequest      req;
+  int ret;
+
+  dev = usbi_get_device_by_session_id(ctx, locationID);
+  if (!dev) {
+    _usbi_log (ctx, LOG_LEVEL_INFO, "allocating new device for location 0x%08x", locationID);
+    dev = usbi_alloc_device(ctx, locationID);
+    if (!dev)
+      return LIBUSB_ERROR_NO_MEM;
+
+    priv = (struct darwin_device_priv *)dev->os_priv;
+
+    /* Set up request for device descriptor */
+    req.bmRequestType = USBmakebmRequestType(kUSBIn, kUSBStandard, kUSBDevice);
+    req.bRequest      = kUSBRqGetDescriptor;
+    req.wValue        = kUSBDeviceDesc << 8;
+    req.wIndex        = 0;
+    req.wLength       = sizeof(IOUSBDeviceDescriptor);
+    req.pData         = &(priv->dev_descriptor);
+    
+    (*(device))->GetDeviceAddress (device, (USBDeviceAddress *)&address);
+    (*(device))->GetDeviceProduct (device, &idProduct);
+    (*(device))->GetDeviceVendor (device, &idVendor);
+    (*(device))->GetDeviceClass (device, &bDeviceClass);
+    (*(device))->GetDeviceSubClass (device, &bDeviceSubClass);
+
+    /**** retrieve device descriptors ****/
+    /* device must be open for DeviceRequest */
+    (*device)->USBDeviceOpen(device);
+    
+    ret = (*(device))->DeviceRequest (device, &req);
+    if (ret != kIOReturnSuccess) {
+      int try_unsuspend = 1;
+      UInt32 info;
+
+      /* device may be suspended. unsuspend it and try again */
+#if DeviceVersion >= 320
+      /* IOUSBFamily 320+ provides a way to detect device suspension but earlier versions do not */
+      (void)(*device)->GetUSBDeviceInformation (device, &info);
+
+      try_unsuspend = info & (1 << kUSBInformationDeviceIsSuspendedBit);
+#endif
+
+      if (try_unsuspend) {
+	/* resume the device */
+	(void)(*device)->USBDeviceSuspend (device, 0);
+
+	ret = (*(device))->DeviceRequest (device, &req);
+
+	/* resuspend the device */
+	(void)(*device)->USBDeviceSuspend (device, 1);
+      }
+    }
+
+    (*device)->USBDeviceClose (device);
+
+    if (ret != kIOReturnSuccess) {
+      _usbi_log (ctx, LOG_LEVEL_WARNING, "could not retrieve device descriptor: %s. skipping device", darwin_error_str (ret));
+      libusb_unref_device(dev);
+      return -1;
+    }
+    /**** end: retrieve device descriptors ****/
+    
+    /* catch buggy hubs (which appear to be virtual). Apple's own USB prober has problems with these devices. */
+    if (libusb_le16_to_cpu (priv->dev_descriptor.idProduct) != idProduct) {
+      /* not a valid device */
+      _usbi_log (ctx, LOG_LEVEL_WARNING, "idProduct from iokit (%04x) does not match idProduct in descriptor (%04x). skipping device",
+		 idProduct, libusb_le16_to_cpu (priv->dev_descriptor.idProduct));
+      libusb_unref_device(dev);
+      return -1;
+    }
+
+    dev->bus_number     = locationID >> 24;
+    dev->device_address = address;
+
+    /* save our location, we'll need this later */
+    priv->location = locationID;
+    snprintf(priv->sys_path, 20, "%03i-%04x-%04x-%02x-%02x", address, idVendor, idProduct, bDeviceClass, bDeviceSubClass);
+
+    ret = usbi_sanitize_device(dev);
+
+    if (ret < 0) {
+      libusb_unref_device(dev);
+      return -1;
+    }
+  } else {
+    priv = (struct darwin_device_priv *)dev->os_priv;
+
+    _usbi_log (ctx, LOG_LEVEL_INFO, "using existing device for location 0x%08x", locationID);
+  }
+
+  /* append the device to the list of discovered devices */
+  discdevs = discovered_devs_append(*_discdevs, dev);
+  if (!discdevs)
+    return LIBUSB_ERROR_NO_MEM;
+    
+  *_discdevs = discdevs;
+  
+  _usbi_log (ctx, LOG_LEVEL_INFO, "found device with address %d at %s", dev->device_address, priv->sys_path);
+  
+  return 0;
+}
+
+static int darwin_get_device_list(struct libusb_context *ctx, struct discovered_devs **_discdevs) {
+  io_iterator_t        deviceIterator;
+  usb_device_t         **device;
+  kern_return_t        kresult;
+  UInt32               location;
+
+  if (!libusb_darwin_mp)
+    return LIBUSB_ERROR_INVALID_PARAM;
+  
+  kresult = usb_setup_device_iterator (&deviceIterator);
+  if (kresult != kIOReturnSuccess)
+    return darwin_to_libusb (kresult);
+
+  while ((device = usb_get_next_device (deviceIterator, &location)) != NULL) {
+    (void) process_new_device (ctx, device, location, _discdevs);
+
+    (*(device))->Release(device);
+  }
+
+  IOObjectRelease(deviceIterator);
+
+  return 0;
+}
+
+static int darwin_open (struct libusb_device_handle *dev_handle) {
+  struct darwin_device_handle_priv *priv = (struct darwin_device_handle_priv *)dev_handle->os_priv;
+  struct darwin_device_priv *dpriv = (struct darwin_device_priv *)dev_handle->dev->os_priv;
+  usb_device_t  **darwin_device;
+  IOReturn kresult;
+
+  kresult = darwin_get_device (dpriv->location, &darwin_device);
+  if (kresult) {
+    _usbi_log (HANDLE_CTX (dev_handle), LOG_LEVEL_ERROR, "could not find device: %s", darwin_error_str (kresult));
+    return darwin_to_libusb (kresult);
+  }
+
+  dpriv->device = darwin_device;
+
+  /* try to open the device */
+  kresult = (*(dpriv->device))->USBDeviceOpenSeize (dpriv->device);
+
+  if (kresult != kIOReturnSuccess) {
+    _usbi_log (HANDLE_CTX (dev_handle), LOG_LEVEL_ERROR, "USBDeviceOpen: %s", darwin_error_str(kresult));
+
+    switch (kresult) {
+    case kIOReturnExclusiveAccess:
+      /* it is possible to perform some actions on a device that is not open so do not return an error */
+      priv->is_open = 0;
+
+      break;
+    default:
+      (*(dpriv->device))->Release (dpriv->device);
+      dpriv->device = NULL;
+      return darwin_to_libusb (kresult);
+    }
+  } else {
+    priv->is_open = 1;
+
+    /* create async event source */
+    kresult = (*(dpriv->device))->CreateDeviceAsyncEventSource (dpriv->device, &priv->cfSource);
+
+    CFRetain (libusb_darwin_acfl);
+
+    /* add the cfSource to the aync run loop */
+    CFRunLoopAddSource(libusb_darwin_acfl, priv->cfSource, kCFRunLoopCommonModes);
+  }
+
+  /* create a file descriptor for notifications */
+  pipe (priv->fds);
+
+  /* set the pipe to be non-blocking */
+  fcntl (priv->fds[1], F_SETFD, O_NONBLOCK);
+
+  usbi_add_pollfd(HANDLE_CTX(dev_handle), priv->fds[0], POLLIN);
+
+  _usbi_log (HANDLE_CTX (dev_handle), LOG_LEVEL_INFO, "device open for access");
+
+  return 0;
+}
+
+static void darwin_close (struct libusb_device_handle *dev_handle) {
+  struct darwin_device_handle_priv *priv = (struct darwin_device_handle_priv *)dev_handle->os_priv;
+  struct darwin_device_priv *dpriv = (struct darwin_device_priv *)dev_handle->dev->os_priv;
+  IOReturn kresult;
+  int i;
+
+  /* make sure all interfaces are released */
+  for (i = 0 ; i < USB_MAXINTERFACES ; i++)
+    if (dev_handle->claimed_interfaces & (1 << i))
+      libusb_release_interface (dev_handle, i);
+
+  if (priv->is_open) {
+    /* delete the device's async event source */
+    if (priv->cfSource) {
+      CFRunLoopRemoveSource (libusb_darwin_acfl, priv->cfSource, kCFRunLoopDefaultMode);
+      CFRelease (priv->cfSource);
+    }
+
+    /* close the device */
+    kresult = (*(dpriv->device))->USBDeviceClose(dpriv->device);
+    if (kresult) {
+      /* Log the fact that we had a problem closing the file, however failing a
+       * close isn't really an error, so return success anyway */
+      _usbi_log (HANDLE_CTX (dev_handle), LOG_LEVEL_ERROR, "USBDeviceClose: %s", darwin_error_str(kresult));
+    }
+  }
+  
+  kresult = (*(dpriv->device))->Release(dpriv->device);
+  if (kresult) {
+    /* Log the fact that we had a problem closing the file, however failing a
+     * close isn't really an error, so return success anyway */
+    _usbi_log (HANDLE_CTX (dev_handle), LOG_LEVEL_ERROR, "Release: %s", darwin_error_str(kresult));
+  }
+
+  usbi_remove_pollfd (HANDLE_CTX (dev_handle), priv->fds[0]);
+  close (priv->fds[1]);
+  close (priv->fds[0]);
+}
+
+static int darwin_get_configuration(struct libusb_device_handle *dev_handle, int *config) {
+  struct darwin_device_priv *dpriv = (struct darwin_device_priv *)dev_handle->dev->os_priv;
+  UInt8 configNum;
+  IOReturn kresult;
+
+  kresult = (*(dpriv->device))->GetConfiguration (dpriv->device, &configNum);
+  if (kresult != kIOReturnSuccess)
+    return darwin_to_libusb (kresult);
+
+  *config = (int) configNum;
+
+  return 0;
+}
+
+static int darwin_set_configuration(struct libusb_device_handle *dev_handle, int config) {
+  struct darwin_device_priv *dpriv = (struct darwin_device_priv *)dev_handle->dev->os_priv;
+  IOReturn kresult;
+  int i;
+
+  /* Setting configuration will invalidate the interface, so we need
+     to reclaim it. First, dispose of existing interfaces, if any. */
+  for (i = 0 ; i < USB_MAXINTERFACES ; i++)
+    if (dev_handle->claimed_interfaces & (1 << i))
+      darwin_release_interface (dev_handle, i);
+
+  kresult = (*(dpriv->device))->SetConfiguration (dpriv->device, config);
+  if (kresult != kIOReturnSuccess)
+    return darwin_to_libusb (kresult);
+
+  /* Reclaim any interfaces. */
+  for (i = 0 ; i < USB_MAXINTERFACES ; i++)
+    if (dev_handle->claimed_interfaces & (1 << i))
+      darwin_claim_interface (dev_handle, i);
+
+  return 0;
+}
+
+static int darwin_get_interface (usb_device_t **darwin_device, uint8_t ifc, io_service_t *usbInterfacep) {
+  IOUSBFindInterfaceRequest request;
+  uint8_t                   current_interface;
+  kern_return_t             kresult;
+  io_iterator_t             interface_iterator;
+
+  *usbInterfacep = IO_OBJECT_NULL;
+  
+  /* Setup the Interface Request */
+  request.bInterfaceClass    = kIOUSBFindInterfaceDontCare;
+  request.bInterfaceSubClass = kIOUSBFindInterfaceDontCare;
+  request.bInterfaceProtocol = kIOUSBFindInterfaceDontCare;
+  request.bAlternateSetting  = kIOUSBFindInterfaceDontCare;
+
+  kresult = (*(darwin_device))->CreateInterfaceIterator(darwin_device, &request, &interface_iterator);
+  if (kresult)
+    return kresult;
+
+  for ( current_interface = 0 ; current_interface <= ifc ; current_interface++ )
+    *usbInterfacep = IOIteratorNext(interface_iterator);
+  
+  /* done with the interface iterator */
+  IOObjectRelease(interface_iterator);
+  
+  return 0;
+}
+
+static int get_endpoints (struct libusb_device_handle *dev_handle, int iface) {
+  struct darwin_device_handle_priv *priv = (struct darwin_device_handle_priv *)dev_handle->os_priv;
+
+  /* current interface */
+  struct __darwin_interface *cInterface = &priv->interfaces[iface];
+
+  kern_return_t kresult;
+
+  u_int8_t numep, direction, number;
+  u_int8_t dont_care1, dont_care3;
+  u_int16_t dont_care2;
+  int i;
+
+  _usbi_log (HANDLE_CTX (dev_handle), LOG_LEVEL_INFO, "building table of endpoints.");
+  
+  /* retrieve the total number of endpoints on this interface */
+  kresult = (*(cInterface->interface))->GetNumEndpoints(cInterface->interface, &numep);
+  if (kresult) {
+    _usbi_log (HANDLE_CTX (dev_handle), LOG_LEVEL_ERROR, "can't get number of endpoints for interface: %s", darwin_error_str(kresult));
+    return darwin_to_libusb (kresult);
+  }
+
+  /* iterate through pipe references */
+  for (i = 1 ; i <= numep ; i++) {
+    kresult = (*(cInterface->interface))->GetPipeProperties(cInterface->interface, i, &direction, &number, &dont_care1,
+							    &dont_care2, &dont_care3);
+
+    if (kresult != kIOReturnSuccess) {
+      _usbi_log (HANDLE_CTX (dev_handle), LOG_LEVEL_ERROR, "error getting pipe information for pipe %d: %s", i, darwin_error_str(kresult));
+
+      return darwin_to_libusb (kresult);
+    }
+
+    _usbi_log (HANDLE_CTX (dev_handle), LOG_LEVEL_INFO, "interface: %i pipe %i: dir: %i number: %i", iface, i, direction, number);
+
+    cInterface->endpoint_addrs[i - 1] = ((direction << 7 & LIBUSB_ENDPOINT_DIR_MASK) | (number & LIBUSB_ENDPOINT_ADDRESS_MASK));
+  }
+
+  cInterface->num_endpoints = numep;
+  
+  return 0;
+}
+
+static int darwin_claim_interface(struct libusb_device_handle *dev_handle, int iface) {
+  struct darwin_device_priv *dpriv = (struct darwin_device_priv *)dev_handle->dev->os_priv;
+  struct darwin_device_handle_priv *priv = (struct darwin_device_handle_priv *)dev_handle->os_priv;
+  io_service_t          usbInterface = IO_OBJECT_NULL;
+  IOReturn kresult;
+  IOCFPlugInInterface **plugInInterface = NULL;
+  long                  score;
+  uint8_t               new_config;
+
+  /* current interface */
+  struct __darwin_interface *cInterface = &priv->interfaces[iface];
+
+  kresult = darwin_get_interface (dpriv->device, iface, &usbInterface);
+  if (kresult != kIOReturnSuccess)
+    return darwin_to_libusb (kresult);
+
+  /* make sure we have an interface */
+  if (!usbInterface) {
+    u_int8_t nConfig;     /* Index of configuration to use */
+    IOUSBConfigurationDescriptorPtr configDesc; /* to describe which configuration to select */
+    /* Only a composite class device with no vendor-specific driver will
+       be configured. Otherwise, we need to do it ourselves, or there
+       will be no interfaces for the device. */
+
+    _usbi_log (HANDLE_CTX (dev_handle), LOG_LEVEL_INFO, "no interface found; selecting configuration" );
+
+    kresult = (*(dpriv->device))->GetNumberOfConfigurations (dpriv->device, &nConfig);
+    if (kresult != kIOReturnSuccess) {
+      _usbi_log (HANDLE_CTX (dev_handle), LOG_LEVEL_ERROR, "GetNumberOfConfigurations: %s", darwin_error_str(kresult));
+      return darwin_to_libusb(kresult);
+    }
+    
+    if (nConfig < 1) {
+      _usbi_log (HANDLE_CTX (dev_handle), LOG_LEVEL_ERROR, "GetNumberOfConfigurations: no configurations");
+      return LIBUSB_ERROR_OTHER;
+    }
+
+    _usbi_log (HANDLE_CTX (dev_handle), LOG_LEVEL_INFO, "device has %d configuration%s. using the first",
+	      (int)nConfig, (nConfig > 1 ? "s" : "") );
+
+    /* Always use the first configuration */
+    kresult = (*(dpriv->device))->GetConfigurationDescriptorPtr (dpriv->device, 0, &configDesc);
+    if (kresult != kIOReturnSuccess) {
+      _usbi_log (HANDLE_CTX (dev_handle), LOG_LEVEL_ERROR, "GetConfigurationDescriptorPtr: %s",
+		darwin_error_str(kresult));
+
+      new_config = 1;
+    } else
+      new_config = configDesc->bConfigurationValue;
+
+    _usbi_log (HANDLE_CTX (dev_handle), LOG_LEVEL_INFO, "new configuration value is %d", new_config);
+
+    /* set the configuration */
+    kresult = darwin_set_configuration (dev_handle, new_config);
+    if (kresult != LIBUSB_SUCCESS) {
+      _usbi_log (HANDLE_CTX (dev_handle), LOG_LEVEL_ERROR, "could not set configuration");
+      return kresult;
+    }
+
+    kresult = darwin_get_interface (dpriv->device, iface, &usbInterface);
+    if (kresult) {
+      _usbi_log (HANDLE_CTX (dev_handle), LOG_LEVEL_ERROR, "darwin_get_interface: %s", darwin_error_str(kresult));
+      return darwin_to_libusb (kresult);
+    }
+  }
+
+  if (!usbInterface) {
+    _usbi_log (HANDLE_CTX (dev_handle), LOG_LEVEL_ERROR, "interface not found");
+    return LIBUSB_ERROR_NOT_FOUND;
+  }
+  
+  /* get an interface to the device's interface */
+  kresult = IOCreatePlugInInterfaceForService (usbInterface, kIOUSBInterfaceUserClientTypeID,
+					       kIOCFPlugInInterfaceID, &plugInInterface, &score);
+  kresult = IOObjectRelease(usbInterface);
+  if (kresult || !plugInInterface)
+    return darwin_to_libusb (kresult);
+  
+  /* Do the actual claim */
+  kresult = (*plugInInterface)->QueryInterface(plugInInterface,
+					       CFUUIDGetUUIDBytes(kIOUSBInterfaceInterfaceID),
+					       (LPVOID)&cInterface->interface);
+  if (kresult || !cInterface->interface) {
+    _usbi_log (HANDLE_CTX (dev_handle), LOG_LEVEL_ERROR, "QueryInterface: %s", darwin_error_str(kresult));
+    return darwin_to_libusb (kresult);
+  }
+  
+  /* We no longer need the intermediate plug-in */
+  (*plugInInterface)->Release(plugInInterface);
+
+  /* claim the interface */
+  kresult = (*(cInterface->interface))->USBInterfaceOpen(cInterface->interface);
+  if (kresult) {
+    _usbi_log(HANDLE_CTX (dev_handle), LOG_LEVEL_ERROR, "USBInterfaceOpen: %s", darwin_error_str(kresult));
+    return darwin_to_libusb (kresult);
+  }
+
+  /* update list of endpoints */
+  kresult = get_endpoints (dev_handle, iface);
+  if (kresult) {
+    /* this should not happen */
+    darwin_release_interface (dev_handle, iface);
+    _usbi_log (HANDLE_CTX (dev_handle), LOG_LEVEL_ERROR, "could not build endpoint table");
+    return kresult;
+  }
+
+  /* create async event source */
+  kresult = (*(cInterface->interface))->CreateInterfaceAsyncEventSource (cInterface->interface, &cInterface->cfSource);
+  
+  /* add the cfSource to the aync run loop */
+  CFRetain (libusb_darwin_acfl);
+  CFRunLoopAddSource(libusb_darwin_acfl, cInterface->cfSource, kCFRunLoopDefaultMode);
+
+  _usbi_log (HANDLE_CTX (dev_handle), LOG_LEVEL_INFO, "interface opened");
+
+  return 0;
+}
+
+static int darwin_release_interface(struct libusb_device_handle *dev_handle, int iface) {
+  struct darwin_device_handle_priv *priv = (struct darwin_device_handle_priv *)dev_handle->os_priv;
+  IOReturn kresult;
+
+  /* current interface */
+  struct __darwin_interface *cInterface = &priv->interfaces[iface];
+
+  /* Check to see if an interface is open */
+  if (!cInterface->interface)
+    return LIBUSB_SUCCESS;
+
+  /* clean up endpoint data */
+  cInterface->num_endpoints = 0;
+  
+  /* delete the interface's async event source */
+  CFRunLoopRemoveSource (libusb_darwin_acfl, cInterface->cfSource, kCFRunLoopDefaultMode);
+  CFRelease (cInterface->cfSource);
+
+  kresult = (*(cInterface->interface))->USBInterfaceClose(cInterface->interface);
+  if (kresult)
+    _usbi_log (HANDLE_CTX (dev_handle), LOG_LEVEL_ERROR, "USBInterfaceClose: %s", darwin_error_str(kresult));
+
+  kresult = (*(cInterface->interface))->Release(cInterface->interface);
+  if (kresult != kIOReturnSuccess)
+    _usbi_log (HANDLE_CTX (dev_handle), LOG_LEVEL_ERROR, "Release: %s", darwin_error_str(kresult));
+
+  cInterface->interface = IO_OBJECT_NULL;
+
+  return darwin_to_libusb (kresult);
+}
+
+static int darwin_set_interface_altsetting(struct libusb_device_handle *dev_handle, int iface, int altsetting) {
+  struct darwin_device_handle_priv *priv = (struct darwin_device_handle_priv *)dev_handle->os_priv;
+  IOReturn kresult;
+
+  /* current interface */
+  struct __darwin_interface *cInterface = &priv->interfaces[iface];
+
+  if (!cInterface->interface)
+    return LIBUSB_ERROR_NO_DEVICE;
+
+  kresult = (*(cInterface->interface))->SetAlternateInterface (cInterface->interface, altsetting);
+  if (kresult != kIOReturnSuccess)
+    darwin_reset_device (dev_handle);
+
+  return darwin_to_libusb (kresult);
+}
+
+static int darwin_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint) {
+  struct darwin_device_handle_priv *priv = (struct darwin_device_handle_priv *)dev_handle->os_priv;
+
+  /* current interface */
+  struct __darwin_interface *cInterface;
+  uint8_t pipeRef, iface;
+  IOReturn kresult;
+
+  /* determine the interface/endpoint to use */
+  if (ep_to_pipeRef (dev_handle, endpoint, &pipeRef, &iface) != 0) {
+    _usbi_log (HANDLE_CTX (dev_handle), LOG_LEVEL_ERROR, "endpoint not found on any open interface");
+
+    return LIBUSB_ERROR_NOT_FOUND;
+  }
+
+  cInterface = &priv->interfaces[iface];
+
+#if (InterfaceVersion < 190)
+  kresult = (*(cInterface->interface))->ClearPipeStall(cInterface->interface, pipeRef);
+#else
+  /* newer versions of darwin support clearing additional bits on the device's endpoint */
+  kresult = (*(cInterface->interface))->ClearPipeStallBothEnds(cInterface->interface, pipeRef);
+#endif
+  if (kresult)
+    _usbi_log (HANDLE_CTX (dev_handle), LOG_LEVEL_ERROR, "ClearPipeStall: %s", darwin_error_str (kresult));
+
+  return darwin_to_libusb (kresult);
+}
+
+static int darwin_reset_device(struct libusb_device_handle *dev_handle) {
+  struct darwin_device_priv *dpriv = (struct darwin_device_priv *)dev_handle->dev->os_priv;
+  IOReturn kresult;
+
+  kresult = (*(dpriv->device))->ResetDevice (dpriv->device);
+  if (kresult)
+    _usbi_log (HANDLE_CTX (dev_handle), LOG_LEVEL_ERROR, "ResetDevice: %s", darwin_error_str (kresult));
+
+  return darwin_to_libusb (kresult);
+}
+
+static int darwin_kernel_driver_active(struct libusb_device_handle *dev_handle, int interface) {
+  struct darwin_device_priv *dpriv = (struct darwin_device_priv *)dev_handle->dev->os_priv;
+  io_service_t usbInterface;
+  CFTypeRef driver;
+  IOReturn kresult;
+
+  kresult = darwin_get_interface (dpriv->device, interface, &usbInterface);
+  if (kresult) {
+    _usbi_log (HANDLE_CTX (dev_handle), LOG_LEVEL_ERROR, "darwin_get_interface: %s", darwin_error_str(kresult));
+
+    return darwin_to_libusb (kresult);
+  }
+  
+  driver = IORegistryEntryCreateCFProperty (usbInterface, kIOBundleIdentifierKey, kCFAllocatorDefault, 0);
+  IOObjectRelease (usbInterface);
+
+  if (driver) {
+    CFRelease (driver);
+
+    return 1;
+  }
+
+  /* no driver */
+  return 0;
+}
+
+/* attaching/detaching kernel drivers is not currently supported (maybe in the future?) */
+static int darwin_attach_kernel_driver (struct libusb_device_handle *dev_handle, int interface) {
+  return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int darwin_detach_kernel_driver (struct libusb_device_handle *dev_handle, int interface) {
+  return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static void darwin_destroy_device(struct libusb_device *dev) {
+}
+
+static int submit_bulk_transfer(struct usbi_transfer *itransfer) {
+  struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+  struct darwin_device_handle_priv *priv = (struct darwin_device_handle_priv *)transfer->dev_handle->os_priv;
+
+  IOReturn               ret;
+  uint8_t                is_read; /* 0 = we're reading, 1 = we're writing */
+  uint8_t                transferType;
+  /* None of the values below are used in libusb for bulk transfers */
+  uint8_t                direction, number, interval, pipeRef, iface;
+  uint16_t               maxPacketSize;
+
+  struct __darwin_interface *cInterface;
+
+  /* are we reading or writing? */
+  is_read = transfer->endpoint & LIBUSB_ENDPOINT_IN;
+  
+  if (ep_to_pipeRef (transfer->dev_handle, transfer->endpoint, &pipeRef, &iface) != 0) {
+    _usbi_log (TRANSFER_CTX (transfer), LOG_LEVEL_ERROR, "endpoint not found on any open interface");
+
+    return LIBUSB_ERROR_NOT_FOUND;
+  }
+
+  cInterface = &priv->interfaces[iface];
+
+  (*(cInterface->interface))->GetPipeProperties (cInterface->interface, pipeRef, &direction, &number,
+						 &transferType, &maxPacketSize, &interval);
+  
+  /* submit the request */
+  /* timeouts are unavailable on interrupt endpoints */
+  if (transferType == kUSBInterrupt) {
+    if (is_read)
+      ret = (*(cInterface->interface))->ReadPipeAsync(cInterface->interface, pipeRef, transfer->buffer,
+						      transfer->length, darwin_async_io_callback, itransfer);
+    else
+      ret = (*(cInterface->interface))->WritePipeAsync(cInterface->interface, pipeRef, transfer->buffer,
+						       transfer->length, darwin_async_io_callback, itransfer);
+  } else {
+    if (is_read)
+      ret = (*(cInterface->interface))->ReadPipeAsyncTO(cInterface->interface, pipeRef, transfer->buffer,
+							transfer->length, transfer->timeout, transfer->timeout,
+							darwin_async_io_callback, (void *)itransfer);
+    else
+      ret = (*(cInterface->interface))->WritePipeAsyncTO(cInterface->interface, pipeRef, transfer->buffer,
+							 transfer->length, transfer->timeout, transfer->timeout,
+							 darwin_async_io_callback, (void *)itransfer);
+  }
+
+  if (ret)
+    _usbi_log (TRANSFER_CTX (transfer), LOG_LEVEL_ERROR, "bulk transfer failed (dir = %s): %s", is_read ? "In" : "Out",
+	       darwin_error_str(ret));
+
+  return darwin_to_libusb (ret);
+}
+
+static int submit_iso_transfer(struct usbi_transfer *itransfer) {
+  struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+  struct darwin_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
+  struct darwin_device_handle_priv *priv = (struct darwin_device_handle_priv *)transfer->dev_handle->os_priv;
+
+  IOReturn                kresult;
+  uint8_t                 is_read; /* 0 = we're writing, 1 = we're reading */
+  uint8_t                 pipeRef, iface;
+  UInt64                  frame;
+  AbsoluteTime            atTime;
+  int                     i;
+
+  struct __darwin_interface *cInterface;
+
+  /* are we reading or writing? */
+  is_read = transfer->endpoint & LIBUSB_ENDPOINT_IN;
+  
+  /* construct an array of IOUSBIsocFrames */
+  tpriv->isoc_framelist = (IOUSBIsocFrame*) calloc (transfer->num_iso_packets, sizeof(IOUSBIsocFrame));
+  if (!tpriv->isoc_framelist)
+    return LIBUSB_ERROR_NO_MEM;
+
+  /* copy the frame list from the libusb descriptor (the structures differ only is member order) */
+  for (i = 0 ; i < transfer->num_iso_packets ; i++)
+    tpriv->isoc_framelist[i].frReqCount = transfer->iso_packet_desc[i].length;
+
+  /* determine the interface/endpoint to use */
+  if (ep_to_pipeRef (transfer->dev_handle, transfer->endpoint, &pipeRef, &iface) != 0) {
+    _usbi_log (TRANSFER_CTX (transfer), LOG_LEVEL_ERROR, "endpoint not found on any open interface");
+
+    return LIBUSB_ERROR_NOT_FOUND;
+  }
+
+  cInterface = &priv->interfaces[iface];
+
+  /* Last but not least we need the bus frame number */
+  kresult = (*(cInterface->interface))->GetBusFrameNumber(cInterface->interface, &frame, &atTime);
+  if (kresult) {
+    _usbi_log (TRANSFER_CTX (transfer), LOG_LEVEL_ERROR, "failed to get bus frame number: %d", kresult);
+    free(tpriv->isoc_framelist);
+    tpriv->isoc_framelist = NULL;
+
+    return darwin_to_libusb (kresult);
+  }
+
+  /* schedule for a frame a little in the future */
+  frame += 2;
+	
+  /* submit the request */
+  if (is_read)
+    kresult = (*(cInterface->interface))->ReadIsochPipeAsync(cInterface->interface, pipeRef, transfer->buffer, frame,
+							     transfer->num_iso_packets, tpriv->isoc_framelist, darwin_async_io_callback,
+							     itransfer);
+  else
+    kresult = (*(cInterface->interface))->WriteIsochPipeAsync(cInterface->interface, pipeRef, transfer->buffer, frame,
+							      transfer->num_iso_packets, tpriv->isoc_framelist, darwin_async_io_callback,
+							      itransfer);
+
+  if (kresult != kIOReturnSuccess) {
+    _usbi_log (TRANSFER_CTX (transfer), LOG_LEVEL_ERROR, "isochronous transfer failed (dir: %s): %s", is_read ? "In" : "Out",
+	       darwin_error_str(kresult));
+    free (tpriv->isoc_framelist);
+    tpriv->isoc_framelist = NULL;
+  }
+
+  return darwin_to_libusb (kresult);
+}
+
+static int submit_control_transfer(struct usbi_transfer *itransfer) {  
+  struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+  struct libusb_control_setup *setup = (struct libusb_control_setup *) transfer->buffer;
+  struct darwin_device_priv *dpriv = (struct darwin_device_priv *)transfer->dev_handle->dev->os_priv;
+  struct darwin_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
+
+  IOReturn               kresult;
+
+  bzero(&tpriv->req, sizeof(tpriv->req));
+
+  /* IOUSBDeviceInterface expects the request in cpu endianess */
+  tpriv->req.bmRequestType     = setup->bmRequestType;
+  tpriv->req.bRequest          = setup->bRequest;
+  /* these values should already be in bus order */
+  tpriv->req.wValue            = setup->wValue;
+  tpriv->req.wIndex            = setup->wIndex;
+  tpriv->req.wLength           = setup->wLength;
+  /* data is stored after the libusb control block */
+  tpriv->req.pData             = transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE;
+  tpriv->req.completionTimeout = transfer->timeout;
+  tpriv->req.noDataTimeout     = transfer->timeout;
+
+  /* all transfers in libusb-1.0 are async */
+  kresult = (*(dpriv->device))->DeviceRequestAsyncTO(dpriv->device, &(tpriv->req), darwin_async_io_callback, itransfer);
+
+  if (kresult != kIOReturnSuccess)
+    _usbi_log (TRANSFER_CTX (transfer), LOG_LEVEL_ERROR, "control request failed: %s", darwin_error_str(kresult));
+  
+  return darwin_to_libusb (kresult);
+}
+
+static int darwin_submit_transfer(struct usbi_transfer *itransfer) {
+  struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+  switch (transfer->type) {
+  case LIBUSB_TRANSFER_TYPE_CONTROL:
+    return submit_control_transfer(itransfer);
+  case LIBUSB_TRANSFER_TYPE_BULK:
+  case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+    return submit_bulk_transfer(itransfer);
+  case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+    return submit_iso_transfer(itransfer);
+  default:
+    _usbi_log (TRANSFER_CTX(transfer), LOG_LEVEL_ERROR, "unknown endpoint type %d", transfer->type);
+    return LIBUSB_ERROR_INVALID_PARAM;
+  }
+}
+
+static int cancel_control_transfer(struct usbi_transfer *itransfer) {
+  struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+  struct darwin_device_priv *dpriv = (struct darwin_device_priv *)transfer->dev_handle->dev->os_priv;
+  IOReturn kresult;
+
+  _usbi_log (ITRANSFER_CTX (itransfer), LOG_LEVEL_INFO, "WARNING: aborting all transactions control pipe");
+
+  kresult = (*(dpriv->device))->USBDeviceAbortPipeZero (dpriv->device);
+
+  return darwin_to_libusb (kresult);
+}
+
+static int darwin_abort_transfers (struct usbi_transfer *itransfer) {
+  struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+  struct darwin_device_handle_priv *priv = (struct darwin_device_handle_priv *)transfer->dev_handle->os_priv;
+  struct __darwin_interface *cInterface;
+  uint8_t pipeRef, iface;
+  IOReturn kresult;
+
+  if (ep_to_pipeRef (transfer->dev_handle, transfer->endpoint, &pipeRef, &iface) != 0) {
+    _usbi_log (TRANSFER_CTX (transfer), LOG_LEVEL_ERROR, "endpoint not found on any open interface");
+
+    return LIBUSB_ERROR_NOT_FOUND;
+  }
+
+  cInterface = &priv->interfaces[iface];
+
+  _usbi_log (ITRANSFER_CTX (itransfer), LOG_LEVEL_INFO, "WARNING: aborting all transactions on interface %d pipe %d", iface, pipeRef);
+
+  /* abort transactions */
+  (*(cInterface->interface))->AbortPipe (cInterface->interface, pipeRef);
+  
+  _usbi_log (ITRANSFER_CTX (itransfer), LOG_LEVEL_INFO, "calling clear pipe stall to clear the data toggle bit");
+
+  /* clear the data toggle bit */
+#if (InterfaceVersion < 190)
+  kresult = (*(cInterface->interface))->ClearPipeStall(cInterface->interface, pipeRef);
+#else
+  /* newer versions of darwin support clearing additional bits on the device's endpoint */
+  kresult = (*(cInterface->interface))->ClearPipeStallBothEnds(cInterface->interface, pipeRef);
+#endif
+
+  return darwin_to_libusb (kresult);
+}
+
+static int darwin_cancel_transfer(struct usbi_transfer *itransfer) {
+  struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+  switch (transfer->type) {
+  case LIBUSB_TRANSFER_TYPE_CONTROL:
+    return cancel_control_transfer(itransfer);
+  case LIBUSB_TRANSFER_TYPE_BULK:
+  case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+  case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+    return darwin_abort_transfers (itransfer);
+  default:
+    _usbi_log (TRANSFER_CTX(transfer), LOG_LEVEL_ERROR, "unknown endpoint type %d", transfer->type);
+    return LIBUSB_ERROR_INVALID_PARAM;
+  }
+}
+
+static void darwin_clear_transfer_priv (struct usbi_transfer *itransfer) {
+  struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+  struct darwin_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
+
+  if (transfer->type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS && tpriv->isoc_framelist) {
+    free (tpriv->isoc_framelist);
+    tpriv->isoc_framelist = NULL;
+  }
+}
+
+static void darwin_async_io_callback (void *refcon, IOReturn result, void *arg0) {
+  struct usbi_transfer *itransfer = (struct usbi_transfer *)refcon;
+  struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+  struct darwin_device_handle_priv *priv = (struct darwin_device_handle_priv *)transfer->dev_handle->os_priv;
+  UInt32 message;
+
+  _usbi_log (ITRANSFER_CTX (itransfer), LOG_LEVEL_INFO, "an async io operation has completed");
+
+  /* send a completion message to the device's file descriptor */
+  message = MESSAGE_ASYNC_IO_COMPLETE;
+  write (priv->fds[1], &message, sizeof (message));
+  write (priv->fds[1], &itransfer, sizeof (itransfer));
+  write (priv->fds[1], &result, sizeof (IOReturn));
+  write (priv->fds[1], &arg0, sizeof (UInt32));
+}
+
+static void darwin_bulk_callback (struct usbi_transfer *itransfer, kern_return_t result, UInt32 io_size) {
+  enum libusb_transfer_status status;
+
+  _usbi_log (ITRANSFER_CTX (itransfer), LOG_LEVEL_INFO, "handling bulk completion with status %d", result);
+
+  switch (result) {
+  case kIOReturnSuccess:
+    status = LIBUSB_TRANSFER_COMPLETED;
+    itransfer->transferred += io_size;
+    break;
+  case kIOReturnAborted:
+    usbi_handle_transfer_cancellation(itransfer);
+    return;
+  case kIOUSBPipeStalled:
+    _usbi_log (ITRANSFER_CTX (itransfer), LOG_LEVEL_WARNING, "unsupported control request");
+    status = LIBUSB_TRANSFER_STALL;
+    
+    break;
+  default:
+    _usbi_log (ITRANSFER_CTX (itransfer), LOG_LEVEL_ERROR, "control error = %s", darwin_error_str (result));
+    status = LIBUSB_TRANSFER_ERROR;
+  }
+
+  usbi_handle_transfer_completion(itransfer, status);
+}
+
+static void darwin_isoc_callback (struct usbi_transfer *itransfer, kern_return_t result) {
+  struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+  struct darwin_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
+  int i, status;
+
+  _usbi_log (ITRANSFER_CTX (itransfer), LOG_LEVEL_INFO, "handling isoc completion with status %d", result);
+
+  if (result == kIOReturnSuccess && tpriv->isoc_framelist) {
+    /* copy isochronous results back */
+
+    for (i = 0; i < transfer->num_iso_packets ; i++) {
+      struct libusb_iso_packet_descriptor *lib_desc = transfer->iso_packet_desc;
+      lib_desc->status = darwin_to_libusb (tpriv->isoc_framelist[i].frStatus);
+      lib_desc->actual_length = tpriv->isoc_framelist[i].frActCount;
+    }
+  }
+
+  switch (result) {
+  case kIOReturnSuccess:
+    status = LIBUSB_TRANSFER_COMPLETED;
+    break;
+  case kIOReturnAborted:
+    usbi_handle_transfer_cancellation(itransfer);
+    return;
+  case kIOUSBPipeStalled:
+    _usbi_log (ITRANSFER_CTX (itransfer), LOG_LEVEL_WARNING, "unsupported control request");
+    status = LIBUSB_TRANSFER_STALL;
+
+    break;
+  default:
+    _usbi_log (ITRANSFER_CTX (itransfer), LOG_LEVEL_ERROR, "control error = %s", darwin_error_str (result));
+    status = LIBUSB_TRANSFER_ERROR;
+  }
+
+  usbi_handle_transfer_completion(itransfer, status);
+}
+
+static void darwin_control_callback (struct usbi_transfer *itransfer, kern_return_t result, UInt32 io_size) {
+  int status;
+
+  _usbi_log (ITRANSFER_CTX (itransfer), LOG_LEVEL_INFO, "handling control completion with status %d", result);
+
+  switch (result) {
+  case kIOReturnSuccess:
+    status = LIBUSB_TRANSFER_COMPLETED;
+    itransfer->transferred += io_size;
+    break;
+  case kIOReturnAborted:
+    usbi_handle_transfer_cancellation(itransfer);
+    return;
+  case kIOUSBPipeStalled:
+    _usbi_log (ITRANSFER_CTX (itransfer), LOG_LEVEL_WARNING, "unsupported control request");
+    status = LIBUSB_TRANSFER_STALL;
+    
+    break;
+  default:
+    _usbi_log (ITRANSFER_CTX (itransfer), LOG_LEVEL_ERROR, "control error = %s", darwin_error_str (result));
+    status = LIBUSB_TRANSFER_ERROR;
+  }
+
+  usbi_handle_transfer_completion(itransfer, status);
+}
+
+static void darwin_handle_callback (struct usbi_transfer *itransfer, kern_return_t result, UInt32 io_size) {
+  struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+
+  switch (transfer->type) {
+  case LIBUSB_TRANSFER_TYPE_CONTROL:
+    darwin_control_callback (itransfer, result, io_size);
+    break;
+  case LIBUSB_TRANSFER_TYPE_BULK:
+  case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+    darwin_bulk_callback (itransfer, result, io_size);
+    break;
+  case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+    darwin_isoc_callback (itransfer, result);
+    break;
+  default:
+    _usbi_log (TRANSFER_CTX(transfer), LOG_LEVEL_ERROR, "unknown endpoint type %d", transfer->type);
+  }
+}
+
+static int op_handle_events(struct libusb_context *ctx, struct pollfd *fds, nfds_t nfds, int num_ready) {
+  struct usbi_transfer *itransfer;
+  UInt32 io_size;
+  IOReturn kresult;
+  int i = 0, ret;
+  UInt32 message;
+
+  pthread_mutex_lock(&ctx->open_devs_lock);
+  for (i = 0; i < nfds && num_ready > 0; i++) {
+    struct pollfd *pollfd = &fds[i];
+    struct libusb_device_handle *handle;
+    struct darwin_device_handle_priv *hpriv = NULL;
+
+    _usbi_log (ctx, LOG_LEVEL_INFO, "checking fd %i with revents = %x", fds[i], pollfd->revents);
+
+    if (!pollfd->revents)
+      continue;
+
+    num_ready--;
+    list_for_each_entry(handle, &ctx->open_devs, list) {
+      hpriv =  (struct darwin_device_handle_priv *)handle->os_priv;
+      if (hpriv->fds[0] == pollfd->fd)
+	break;
+    }
+
+    if (pollfd->revents & POLLERR) {
+      usbi_remove_pollfd(HANDLE_CTX(handle), hpriv->fds[0]);
+      usbi_handle_disconnect(handle);
+
+      /* done with this device */
+      continue;
+    }
+
+    ret = read (hpriv->fds[0], &message, sizeof (message));
+    if (ret < sizeof (message))
+      continue;
+
+    switch (message) {
+    case MESSAGE_DEVICE_GONE:
+      usbi_remove_pollfd(HANDLE_CTX(handle), hpriv->fds[0]);
+      usbi_handle_disconnect(handle);
+      
+      /* done with this device */
+      continue;
+    case MESSAGE_ASYNC_IO_COMPLETE:
+      read (hpriv->fds[0], &itransfer, sizeof (itransfer));
+      read (hpriv->fds[0], &kresult, sizeof (IOReturn));
+      read (hpriv->fds[0], &io_size, sizeof (UInt32));
+
+      darwin_handle_callback (itransfer, kresult, io_size);
+      break;
+    default:
+      _usbi_log (ctx, LOG_LEVEL_ERROR, "unknown message received from device pipe");
+    }
+  }
+
+  pthread_mutex_unlock(&ctx->open_devs_lock);
+
+  return 0;
+}
+
+static int darwin_clock_gettime(int clk_id, struct timespec *tp) {
+  mach_timespec_t sys_time;
+  clock_serv_t clock_ref;
+
+  switch (clk_id) {
+  case LIBUSB_CLOCK_REALTIME:
+    /* CLOCK_REALTIME represents time since the epoch */
+    host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &clock_ref);
+    break;
+  case LIBUSB_CLOCK_MONOTONIC:
+    /* use system boot time as reference for the monotonic clock */
+    host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &clock_ref);
+    break;
+  default:
+    return LIBUSB_ERROR_INVALID_PARAM;
+  }
+
+  clock_get_time (clock_ref, &sys_time);
+
+  tp->tv_sec  = sys_time.tv_sec;
+  tp->tv_nsec = sys_time.tv_nsec;
+
+  return 0;
+}
+
+const struct usbi_os_backend darwin_backend = {
+	.name = "Darwin",
+	.init = darwin_init,
+	.exit = darwin_exit,
+	.get_device_list = darwin_get_device_list,
+	.get_device_descriptor = darwin_get_device_descriptor,
+	.get_active_config_descriptor = darwin_get_active_config_descriptor,
+	.get_config_descriptor = darwin_get_config_descriptor,
+
+	.open = darwin_open,
+	.close = darwin_close,
+	.get_configuration = darwin_get_configuration,
+	.set_configuration = darwin_set_configuration,
+	.claim_interface = darwin_claim_interface,
+	.release_interface = darwin_release_interface,
+
+	.set_interface_altsetting = darwin_set_interface_altsetting,
+	.clear_halt = darwin_clear_halt,
+	.reset_device = darwin_reset_device,
+
+	.kernel_driver_active = darwin_kernel_driver_active,
+	.detach_kernel_driver = darwin_detach_kernel_driver,
+	.attach_kernel_driver = darwin_attach_kernel_driver,
+
+	.destroy_device = darwin_destroy_device,
+
+	.submit_transfer = darwin_submit_transfer,
+	.cancel_transfer = darwin_cancel_transfer,
+	.clear_transfer_priv = darwin_clear_transfer_priv,
+
+	.handle_events = op_handle_events,
+
+	.clock_gettime = darwin_clock_gettime,
+
+	.device_priv_size = sizeof(struct darwin_device_priv),
+	.device_handle_priv_size = sizeof(struct darwin_device_handle_priv),
+	.transfer_priv_size = sizeof(struct darwin_transfer_priv),
+	.add_iso_packet_size = 0,
+};
+
diff --git a/libusb/os/darwin_usb.h b/libusb/os/darwin_usb.h
new file mode 100644
index 0000000..bd64f89
--- /dev/null
+++ b/libusb/os/darwin_usb.h
@@ -0,0 +1,160 @@
+/*
+ * darwin backend for libusb 1.0
+ * Copyright (C) 2008-2009 Nathan Hjelm <hjelmn@users.sourceforge.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#if !defined(LIBUSB_DARWIN_H)
+#define LIBUSB_DARWIN_H
+
+#include "libusbi.h"
+
+#include <IOKit/IOCFBundle.h>
+#include <IOKit/usb/IOUSBLib.h>
+#include <IOKit/IOCFPlugIn.h>
+
+/* IOUSBInterfaceInferface */
+#if defined (kIOUSBInterfaceInterfaceID300)
+
+#define usb_interface_t IOUSBInterfaceInterface300
+#define InterfaceInterfaceID kIOUSBInterfaceInterfaceID300
+#define InterfaceVersion 300
+
+#elif defined (kIOUSBInterfaceInterfaceID245)
+
+#define usb_interface_t IOUSBInterfaceInterface245
+#define InterfaceInterfaceID kIOUSBInterfaceInterfaceID245
+#define InterfaceVersion 245
+
+#elif defined (kIOUSBInterfaceInterfaceID220)
+
+#define usb_interface_t IOUSBInterfaceInterface220
+#define InterfaceInterfaceID kIOUSBInterfaceInterfaceID220
+#define InterfaceVersion 220
+
+#elif defined (kIOUSBInterfaceInterfaceID197)
+
+#define usb_interface_t IOUSBInterfaceInterface197
+#define InterfaceInterfaceID kIOUSBInterfaceInterfaceID197
+#define InterfaceVersion 197
+
+#elif defined (kIOUSBInterfaceInterfaceID190)
+
+#define usb_interface_t IOUSBInterfaceInterface190
+#define InterfaceInterfaceID kIOUSBInterfaceInterfaceID190
+#define InterfaceVersion 190
+
+#elif defined (kIOUSBInterfaceInterfaceID182)
+
+#define usb_interface_t IOUSBInterfaceInterface182
+#define InterfaceInterfaceID kIOUSBInterfaceInterfaceID182
+#define InterfaceVersion 182
+
+#else
+
+#error "IOUSBFamily is too old. Please upgrade your OS"
+
+#endif
+
+/* IOUSBDeviceInterface */
+#if defined (kIOUSBDeviceInterfaceID320)
+
+#define usb_device_t    IOUSBDeviceInterface320
+#define DeviceInterfaceID kIOUSBDeviceInterfaceID320
+#define DeviceVersion 320
+
+#elif defined (kIOUSBDeviceInterfaceID300)
+
+#define usb_device_t    IOUSBDeviceInterface300
+#define DeviceInterfaceID kIOUSBDeviceInterfaceID300
+#define DeviceVersion 300
+
+#elif defined (kIOUSBDeviceInterfaceID245)
+
+#define usb_device_t    IOUSBDeviceInterface245
+#define DeviceInterfaceID kIOUSBDeviceInterfaceID245
+#define DeviceVersion 245
+
+#elif defined (kIOUSBDeviceInterfaceID197)
+
+#define usb_device_t    IOUSBDeviceInterface197
+#define DeviceInterfaceID kIOUSBDeviceInterfaceID197
+#define DeviceVersion 197
+
+#elif defined (kIOUSBDeviceInterfaceID187)
+
+#define usb_device_t    IOUSBDeviceInterface187
+#define DeviceInterfaceID kIOUSBDeviceInterfaceID187
+#define DeviceVersion 187
+
+#elif defined (kIOUSBDeviceInterfaceID182)
+
+#define usb_device_t    IOUSBDeviceInterface182
+#define DeviceInterfaceID kIOUSBDeviceInterfaceID182
+#define DeviceVersion 182
+
+#else
+
+#error "IOUSBFamily is too old. Please upgrade your OS"
+
+#endif
+
+typedef IOCFPlugInInterface *io_cf_plugin_ref_t;
+typedef IONotificationPortRef io_notification_port_t;
+
+/* private structures */
+struct darwin_device_priv {
+  IOUSBDeviceDescriptor dev_descriptor;
+  UInt32                location;
+  char                  sys_path[21];
+  usb_device_t        **device;
+};
+
+struct darwin_device_handle_priv {
+  int                  is_open;
+  CFRunLoopSourceRef   cfSource;
+  int                  fds[2];
+
+  struct __darwin_interface {
+    usb_interface_t    **interface;
+    uint8_t              num_endpoints;
+    CFRunLoopSourceRef   cfSource;
+    uint8_t            endpoint_addrs[USB_MAXENDPOINTS];
+  } interfaces[USB_MAXINTERFACES];
+};
+
+struct darwin_transfer_priv {
+  /* Isoc */
+  IOUSBIsocFrame *isoc_framelist;
+
+  /* Control */
+#if !defined (LIBUSB_NO_TIMEOUT_DEVICE)
+  IOUSBDevRequestTO req;
+#else
+  IOUSBDevRequest req;
+#endif
+
+  /* Bulk */
+};
+
+enum {
+  MESSAGE_DEVICE_GONE,
+  MESSAGE_ASYNC_IO_COMPLETE
+};
+
+
+
+#endif