/*
* darwin backend for libusb 1.0
- * Copyright (C) 2008-2010 Nathan Hjelm <hjelmn@users.sourceforge.net>
+ * Copyright (C) 2008-2011 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
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
+#include <libkern/OSAtomic.h>
#include <mach/clock.h>
#include <mach/clock_types.h>
#include <mach/mach_host.h>
-
#include <mach/mach_port.h>
+
+#include <AvailabilityMacros.h>
+#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
+ #include <objc/objc-auto.h>
+#endif
+
#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 */
+/* async event thread */
+static pthread_mutex_t libusb_darwin_at_mutex;
+static pthread_cond_t libusb_darwin_at_cond;
+
+static clock_serv_t clock_realtime;
+static clock_serv_t clock_monotonic;
+
static CFRunLoopRef libusb_darwin_acfl = NULL; /* async cf loop */
-static int initCount = 0;
+static volatile int32_t initCount = 0;
/* async event thread */
static pthread_t libusb_darwin_at;
struct darwin_device_handle_priv *priv = (struct darwin_device_handle_priv *)dev_handle->os_priv;
/* current interface */
- struct __darwin_interface *cInterface;
+ struct darwin_interface *cInterface;
int8_t i, iface;
return -1;
}
-static int usb_setup_device_iterator (io_iterator_t *deviceIterator) {
- return IOServiceGetMatchingServices(libusb_darwin_mp, IOServiceMatching(kIOUSBDeviceClassName), deviceIterator);
+static int usb_setup_device_iterator (io_iterator_t *deviceIterator, long location) {
+ CFMutableDictionaryRef matchingDict = IOServiceMatching(kIOUSBDeviceClassName);
+
+ if (!matchingDict)
+ return kIOReturnError;
+
+ if (location) {
+ CFMutableDictionaryRef propertyMatchDict = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
+ &kCFTypeDictionaryKeyCallBacks,
+ &kCFTypeDictionaryValueCallBacks);
+
+ if (propertyMatchDict) {
+ CFTypeRef locationCF = CFNumberCreate (NULL, kCFNumberLongType, &location);
+
+ CFDictionarySetValue (propertyMatchDict, CFSTR(kUSBDevicePropertyLocationID), locationCF);
+ /* release our reference to the CFNumber (CFDictionarySetValue retains it) */
+ CFRelease (locationCF);
+
+ CFDictionarySetValue (matchingDict, CFSTR(kIOPropertyMatchKey), propertyMatchDict);
+ /* release out reference to the CFMutableDictionaryRef (CFDictionarySetValue retains it) */
+ CFRelease (propertyMatchDict);
+ }
+ /* else we can still proceed as long as the caller accounts for the possibility of other devices in the iterator */
+ }
+
+ return IOServiceGetMatchingServices(kIOMasterPortDefault, matchingDict, deviceIterator);
}
static usb_device_t **usb_get_next_device (io_iterator_t deviceIterator, UInt32 *locationp) {
result = IOCreatePlugInInterfaceForService(usbDevice, kIOUSBDeviceUserClientTypeID,
kIOCFPlugInInterfaceID, &plugInInterface,
&score);
+
+ /* we are done with the usb_device_t */
+ (void)IOObjectRelease(usbDevice);
if (kIOReturnSuccess == result && plugInInterface)
break;
if (!usbDevice)
return NULL;
- (void)IOObjectRelease(usbDevice);
(void)(*plugInInterface)->QueryInterface(plugInInterface, CFUUIDGetUUIDBytes(DeviceInterfaceID),
(LPVOID)&device);
UInt32 location;
io_iterator_t deviceIterator;
- kresult = usb_setup_device_iterator (&deviceIterator);
+ kresult = usb_setup_device_iterator (&deviceIterator, dev_location);
if (kresult)
return kresult;
io_service_t device;
long location;
+ bool locationValid;
CFTypeRef locationCF;
UInt32 message;
/* get the location from the i/o registry */
locationCF = IORegistryEntryCreateCFProperty (device, CFSTR(kUSBDevicePropertyLocationID), kCFAllocatorDefault, 0);
- CFNumberGetValue(locationCF, kCFNumberLongType, &location);
- CFRelease (locationCF);
IOObjectRelease (device);
+ if (!locationCF)
+ continue;
+
+ locationValid = CFGetTypeID(locationCF) == CFNumberGetTypeID() &&
+ CFNumberGetValue(locationCF, kCFNumberLongType, &location);
+
+ CFRelease (locationCF);
+
+ if (!locationValid)
+ continue;
+
usbi_mutex_lock(&ctx->open_devs_lock);
list_for_each_entry(handle, &ctx->open_devs, list, struct libusb_device_handle) {
dpriv = (struct darwin_device_priv *)handle->dev->os_priv;
static void *event_thread_main (void *arg0) {
IOReturn kresult;
struct libusb_context *ctx = (struct libusb_context *)arg0;
+ CFRunLoopRef runloop;
+
+ /* Set this thread's name, so it can be seen in the debugger
+ and crash reports. */
+#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
+ pthread_setname_np ("org.libusb.device-detach");
+#endif
+
+ /* Tell the Objective-C garbage collector about this thread.
+ This is required because, unlike NSThreads, pthreads are
+ not automatically registered. Although we don't use
+ Objective-C, we use CoreFoundation, which does. */
+#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
+ objc_registerThreadWithCollector();
+#endif
/* hotplug (device removal) source */
CFRunLoopSourceRef libusb_notification_cfsource;
usbi_info (ctx, "creating hotplug event source");
- CFRetain (CFRunLoopGetCurrent ());
+ runloop = CFRunLoopGetCurrent ();
+ CFRetain (runloop);
/* add the notification port to the run loop */
- libusb_notification_port = IONotificationPortCreate (libusb_darwin_mp);
+ libusb_notification_port = IONotificationPortCreate (kIOMasterPortDefault);
libusb_notification_cfsource = IONotificationPortGetRunLoopSource (libusb_notification_port);
- CFRunLoopAddSource(CFRunLoopGetCurrent (), libusb_notification_cfsource, kCFRunLoopDefaultMode);
+ CFRunLoopAddSource(runloop, libusb_notification_cfsource, kCFRunLoopDefaultMode);
/* create notifications for removed devices */
kresult = IOServiceAddMatchingNotification (libusb_notification_port, kIOTerminatedNotification,
if (kresult != kIOReturnSuccess) {
usbi_err (ctx, "could not add hotplug event source: %s", darwin_error_str (kresult));
- pthread_exit ((void *)kresult);
+ pthread_exit (NULL);
}
/* arm notifiers */
darwin_clear_iterator (libusb_rem_device_iterator);
- /* let the main thread know about the async runloop */
- libusb_darwin_acfl = CFRunLoopGetCurrent ();
-
usbi_info (ctx, "thread ready to receive events");
+ /* signal the main thread */
+ pthread_mutex_lock (&libusb_darwin_at_mutex);
+ libusb_darwin_acfl = runloop;
+ pthread_cond_signal (&libusb_darwin_at_cond);
+ pthread_mutex_unlock (&libusb_darwin_at_mutex);
+
/* run the runloop */
CFRunLoopRun();
usbi_info (ctx, "thread exiting");
/* delete notification port */
- CFRunLoopSourceInvalidate (libusb_notification_cfsource);
IONotificationPortDestroy (libusb_notification_port);
+ IOObjectRelease (libusb_rem_device_iterator);
- CFRelease (CFRunLoopGetCurrent ());
+ CFRelease (runloop);
libusb_darwin_acfl = NULL;
- pthread_exit (0);
+ pthread_exit (NULL);
}
static int darwin_init(struct libusb_context *ctx) {
- IOReturn kresult;
+ host_name_port_t host_self;
- if (!(initCount++)) {
- /* Create the master port for talking to IOKit */
- if (!libusb_darwin_mp) {
- kresult = IOMasterPort (MACH_PORT_NULL, &libusb_darwin_mp);
+ if (OSAtomicIncrement32Barrier(&initCount) == 1) {
+ /* create the clocks that will be used */
- if (kresult != kIOReturnSuccess || !libusb_darwin_mp)
- return darwin_to_libusb (kresult);
- }
+ host_self = mach_host_self();
+ host_get_clock_service(host_self, CALENDAR_CLOCK, &clock_realtime);
+ host_get_clock_service(host_self, SYSTEM_CLOCK, &clock_monotonic);
+ mach_port_deallocate(mach_task_self(), host_self);
+
+ pthread_mutex_init (&libusb_darwin_at_mutex, NULL);
+ pthread_cond_init (&libusb_darwin_at_cond, NULL);
pthread_create (&libusb_darwin_at, NULL, event_thread_main, (void *)ctx);
+ pthread_mutex_lock (&libusb_darwin_at_mutex);
while (!libusb_darwin_acfl)
- usleep (10);
+ pthread_cond_wait (&libusb_darwin_at_cond, &libusb_darwin_at_mutex);
+ pthread_mutex_unlock (&libusb_darwin_at_mutex);
}
return 0;
}
static void darwin_exit (void) {
- if (!(--initCount)) {
- void *ret;
+ if (OSAtomicDecrement32Barrier(&initCount) == 0) {
+ mach_port_deallocate(mach_task_self(), clock_realtime);
+ mach_port_deallocate(mach_task_self(), clock_monotonic);
/* 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;
+ pthread_join (libusb_darwin_at, NULL);
}
}
return 0;
}
-static int process_new_device (struct libusb_context *ctx, usb_device_t **device, UInt32 locationID, struct discovered_devs **_discdevs) {
+static int darwin_cache_device_descriptor (struct libusb_context *ctx, struct libusb_device *dev, usb_device_t **device) {
struct darwin_device_priv *priv;
- struct libusb_device *dev;
- struct discovered_devs *discdevs;
- UInt16 address, idVendor, idProduct;
- UInt8 bDeviceClass, bDeviceSubClass;
- IOUSBDevRequest req;
- int ret = 0, need_unref = 0;
+ int retries = 5, delay = 30000;
+ int unsuspended = 0, try_unsuspend = 1, try_reconfigure = 1;
+ int is_open = 0;
+ int ret = 0, ret2;
+ IOUSBDevRequest req;
+ UInt8 bDeviceClass;
+ UInt16 idProduct, idVendor;
- do {
- dev = usbi_get_device_by_session_id(ctx, locationID);
- if (!dev) {
- usbi_info (ctx, "allocating new device for location 0x%08x", locationID);
- dev = usbi_alloc_device(ctx, locationID);
- need_unref = 1;
- } else
- usbi_info (ctx, "using existing device for location 0x%08x", locationID);
+ (*device)->GetDeviceClass (device, &bDeviceClass);
+ (*device)->GetDeviceProduct (device, &idProduct);
+ (*device)->GetDeviceVendor (device, &idVendor);
- if (!dev) {
- ret = LIBUSB_ERROR_NO_MEM;
- break;
- }
+ priv = (struct darwin_device_priv *)dev->os_priv;
- priv = (struct darwin_device_priv *)dev->os_priv;
+ /* try to open the device (we can usually continue even if this fails) */
+ is_open = ((*device)->USBDeviceOpenSeize(device) == kIOReturnSuccess);
+ /**** retrieve device descriptor ****/
+ do {
/* Set up request for device descriptor */
+ memset (&(priv->dev_descriptor), 0, sizeof(IOUSBDeviceDescriptor));
req.bmRequestType = USBmakebmRequestType(kUSBIn, kUSBStandard, kUSBDevice);
req.bRequest = kUSBRqGetDescriptor;
req.wValue = kUSBDeviceDesc << 8;
req.wIndex = 0;
- req.wLength = sizeof(IOUSBDeviceDescriptor);
+ req.wLength = sizeof(priv->dev_descriptor);
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 ****/
/* according to Apple's documentation the device must be open for DeviceRequest but we may not be able to open some
- * devices and Apple's USB Prober doesn't bother to open the device before issuing a descriptor request */
+ * devices and Apple's USB Prober doesn't bother to open the device before issuing a descriptor request. Still,
+ * to follow the spec as closely as possible, try opening the device */
+
ret = (*(device))->DeviceRequest (device, &req);
- if (ret != kIOReturnSuccess) {
- int try_unsuspend = 1;
+
+ if (kIOReturnOverrun == ret && kUSBDeviceDesc == priv->dev_descriptor.bDescriptorType)
+ /* received an overrun error but we still received a device descriptor */
+ ret = kIOReturnSuccess;
+
+ if (kIOReturnSuccess == ret && (0 == priv->dev_descriptor.idProduct ||
+ 0 == priv->dev_descriptor.bNumConfigurations ||
+ 0 == priv->dev_descriptor.bcdUSB)) {
+ /* work around for incorrectly configured devices */
+ if (try_reconfigure && is_open) {
+ usbi_dbg("descriptor appears to be invalid. resetting configuration before trying again...");
+
+ /* set the first configuration */
+ (*device)->SetConfiguration(device, 1);
+
+ /* don't try to reconfigure again */
+ try_reconfigure = 0;
+ }
+
+ ret = kIOUSBPipeStalled;
+ }
+
+ if (kIOReturnSuccess != ret && is_open && try_unsuspend) {
+ /* device may be suspended. unsuspend it and try again */
#if DeviceVersion >= 320
UInt32 info;
- /* device may be suspended. unsuspend it and try again */
/* 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
- /* the device should be open before to device is unsuspended */
- (void) (*device)->USBDeviceOpenSeize(device);
-
if (try_unsuspend) {
/* resume the device */
- (void)(*device)->USBDeviceSuspend (device, 0);
-
- ret = (*(device))->DeviceRequest (device, &req);
-
- /* resuspend the device */
- (void)(*device)->USBDeviceSuspend (device, 1);
+ ret2 = (*device)->USBDeviceSuspend (device, 0);
+ if (kIOReturnSuccess != ret2) {
+ /* prevent log spew from poorly behaving devices. this indicates the
+ os actually had trouble communicating with the device */
+ usbi_dbg("could not retrieve device descriptor. failed to unsuspend: %s",darwin_error_str(ret2));
+ } else
+ unsuspended = 1;
+
+ try_unsuspend = 0;
}
-
- (*device)->USBDeviceClose (device);
}
- if (ret != kIOReturnSuccess) {
- usbi_warn (ctx, "could not retrieve device descriptor: %s. skipping device", darwin_error_str (ret));
- ret = -1;
- break;
+ if (kIOReturnSuccess != ret) {
+ usbi_dbg("kernel responded with code: 0x%08x. sleeping for %d ms before trying again", ret, delay/1000);
+ /* sleep for a little while before trying again */
+ usleep (delay);
}
+ } while (kIOReturnSuccess != ret && retries--);
+
+ if (unsuspended)
+ /* resuspend the device */
+ (void)(*device)->USBDeviceSuspend (device, 1);
+
+ if (is_open)
+ (void) (*device)->USBDeviceClose (device);
+
+ if (ret != kIOReturnSuccess) {
+ /* a debug message was already printed out for this error */
+ if (LIBUSB_CLASS_HUB == bDeviceClass)
+ usbi_dbg ("could not retrieve device descriptor %.4x:%.4x: %s. skipping device", idVendor, idProduct, darwin_error_str (ret));
+ else
+ usbi_warn (ctx, "could not retrieve device descriptor %.4x:%.4x: %s. skipping device", idVendor, idProduct, darwin_error_str (ret));
+
+ return -1;
+ }
+
+ usbi_dbg ("device descriptor:");
+ usbi_dbg (" bDescriptorType: 0x%02x", priv->dev_descriptor.bDescriptorType);
+ usbi_dbg (" bcdUSB: 0x%04x", priv->dev_descriptor.bcdUSB);
+ usbi_dbg (" bDeviceClass: 0x%02x", priv->dev_descriptor.bDeviceClass);
+ usbi_dbg (" bDeviceSubClass: 0x%02x", priv->dev_descriptor.bDeviceSubClass);
+ usbi_dbg (" bDeviceProtocol: 0x%02x", priv->dev_descriptor.bDeviceProtocol);
+ usbi_dbg (" bMaxPacketSize0: 0x%02x", priv->dev_descriptor.bMaxPacketSize0);
+ usbi_dbg (" idVendor: 0x%04x", priv->dev_descriptor.idVendor);
+ usbi_dbg (" idProduct: 0x%04x", priv->dev_descriptor.idProduct);
+ usbi_dbg (" bcdDevice: 0x%04x", priv->dev_descriptor.bcdDevice);
+ usbi_dbg (" iManufacturer: 0x%02x", priv->dev_descriptor.iManufacturer);
+ usbi_dbg (" iProduct: 0x%02x", priv->dev_descriptor.iProduct);
+ usbi_dbg (" iSerialNumber: 0x%02x", priv->dev_descriptor.iSerialNumber);
+ usbi_dbg (" bNumConfigurations: 0x%02x", priv->dev_descriptor.bNumConfigurations);
+
+ /* 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_warn (ctx, "idProduct from iokit (%04x) does not match idProduct in descriptor (%04x). skipping device",
+ idProduct, libusb_le16_to_cpu (priv->dev_descriptor.idProduct));
+ return -1;
+ }
- /**** end: retrieve device descriptors ****/
+ return 0;
+}
- /* 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_warn (ctx, "idProduct from iokit (%04x) does not match idProduct in descriptor (%04x). skipping device",
- idProduct, libusb_le16_to_cpu (priv->dev_descriptor.idProduct));
- ret = -1;
+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;
+ UInt8 devSpeed;
+ int ret = 0, need_unref = 0;
+
+ do {
+ dev = usbi_get_device_by_session_id(ctx, locationID);
+ if (!dev) {
+ usbi_info (ctx, "allocating new device for location 0x%08x", locationID);
+ dev = usbi_alloc_device(ctx, locationID);
+ need_unref = 1;
+ } else
+ usbi_info (ctx, "using existing device for location 0x%08x", locationID);
+
+ if (!dev) {
+ ret = LIBUSB_ERROR_NO_MEM;
break;
}
- dev->bus_number = locationID >> 24;
- dev->device_address = address;
+ priv = (struct darwin_device_priv *)dev->os_priv;
+
+ (*device)->GetDeviceAddress (device, (USBDeviceAddress *)&address);
+
+ ret = darwin_cache_device_descriptor (ctx, dev, device);
+ if (ret < 0)
+ break;
/* check current active configuration (and cache the first configuration value-- which may be used by claim_interface) */
ret = darwin_check_configuration (ctx, dev, device);
if (ret < 0)
break;
+ dev->bus_number = locationID >> 24;
+ dev->device_address = address;
+
+ (*device)->GetDeviceSpeed (device, &devSpeed);
+
+ switch (devSpeed) {
+ case kUSBDeviceSpeedLow: dev->speed = LIBUSB_SPEED_LOW; break;
+ case kUSBDeviceSpeedFull: dev->speed = LIBUSB_SPEED_FULL; break;
+ case kUSBDeviceSpeedHigh: dev->speed = LIBUSB_SPEED_HIGH; break;
+ default:
+ usbi_warn (ctx, "Got unknown device speed %d", devSpeed);
+ }
+
/* 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);
+ snprintf(priv->sys_path, 20, "%03i-%04x-%04x-%02x-%02x", address, priv->dev_descriptor.idVendor, priv->dev_descriptor.idProduct,
+ priv->dev_descriptor.bDeviceClass, priv->dev_descriptor.bDeviceSubClass);
ret = usbi_sanitize_device (dev);
if (ret < 0)
kern_return_t kresult;
UInt32 location;
- if (!libusb_darwin_mp)
- return LIBUSB_ERROR_INVALID_PARAM;
-
- kresult = usb_setup_device_iterator (&deviceIterator);
+ kresult = usb_setup_device_iterator (&deviceIterator, 0);
if (kresult != kIOReturnSuccess)
return darwin_to_libusb (kresult);
struct darwin_device_handle_priv *priv = (struct darwin_device_handle_priv *)dev_handle->os_priv;
/* current interface */
- struct __darwin_interface *cInterface = &priv->interfaces[iface];
+ struct darwin_interface *cInterface = &priv->interfaces[iface];
kern_return_t kresult;
SInt32 score;
/* current interface */
- struct __darwin_interface *cInterface = &priv->interfaces[iface];
+ struct darwin_interface *cInterface = &priv->interfaces[iface];
kresult = darwin_get_interface (dpriv->device, iface, &usbInterface);
if (kresult != kIOReturnSuccess)
/* get an interface to the device's interface */
kresult = IOCreatePlugInInterfaceForService (usbInterface, kIOUSBInterfaceUserClientTypeID,
kIOCFPlugInInterfaceID, &plugInInterface, &score);
+
+ /* ignore release error */
+ (void)IOObjectRelease (usbInterface);
+
if (kresult) {
usbi_err (HANDLE_CTX (dev_handle), "IOCreatePlugInInterfaceForService: %s", darwin_error_str(kresult));
return darwin_to_libusb (kresult);
return LIBUSB_ERROR_NOT_FOUND;
}
- /* ignore release error */
- (void)IOObjectRelease (usbInterface);
-
/* Do the actual claim */
kresult = (*plugInInterface)->QueryInterface(plugInInterface,
CFUUIDGetUUIDBytes(kIOUSBInterfaceInterfaceID),
(LPVOID)&cInterface->interface);
+ /* We no longer need the intermediate plug-in */
+ IODestroyPlugInInterface (plugInInterface);
if (kresult || !cInterface->interface) {
usbi_err (HANDLE_CTX (dev_handle), "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) {
IOReturn kresult;
/* current interface */
- struct __darwin_interface *cInterface = &priv->interfaces[iface];
+ struct darwin_interface *cInterface = &priv->interfaces[iface];
/* Check to see if an interface is open */
if (!cInterface->interface)
IOReturn kresult;
/* current interface */
- struct __darwin_interface *cInterface = &priv->interfaces[iface];
+ struct darwin_interface *cInterface = &priv->interfaces[iface];
if (!cInterface->interface)
return LIBUSB_ERROR_NO_DEVICE;
struct darwin_device_handle_priv *priv = (struct darwin_device_handle_priv *)dev_handle->os_priv;
/* current interface */
- struct __darwin_interface *cInterface;
+ struct darwin_interface *cInterface;
uint8_t pipeRef, iface;
IOReturn kresult;
/* 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) {
+ (void)dev_handle;
+ (void)interface;
return LIBUSB_ERROR_NOT_SUPPORTED;
}
static int darwin_detach_kernel_driver (struct libusb_device_handle *dev_handle, int interface) {
+ (void)dev_handle;
+ (void)interface;
return LIBUSB_ERROR_NOT_SUPPORTED;
}
static void darwin_destroy_device(struct libusb_device *dev) {
+ (void)dev;
}
static int submit_bulk_transfer(struct usbi_transfer *itransfer) {
- struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_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 direction, number, interval, pipeRef, iface;
uint16_t maxPacketSize;
- struct __darwin_interface *cInterface;
+ struct darwin_interface *cInterface;
/* are we reading or writing? */
is_read = transfer->endpoint & LIBUSB_ENDPOINT_IN;
}
static int submit_iso_transfer(struct usbi_transfer *itransfer) {
- struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_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;
AbsoluteTime atTime;
int i;
- struct __darwin_interface *cInterface;
+ 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;
+ /* construct an array of IOUSBIsocFrames, reuse the old one if possible */
+ if (tpriv->isoc_framelist && tpriv->num_iso_packets != transfer->num_iso_packets) {
+ free(tpriv->isoc_framelist);
+ tpriv->isoc_framelist = NULL;
+ }
+
+ if (!tpriv->isoc_framelist) {
+ tpriv->num_iso_packets = transfer->num_iso_packets;
+ 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++)
}
/* schedule for a frame a little in the future */
- frame += 2;
+ frame += 4;
+
+ if (cInterface->frames[transfer->endpoint] && frame < cInterface->frames[transfer->endpoint])
+ frame = cInterface->frames[transfer->endpoint];
/* submit the request */
if (is_read)
transfer->num_iso_packets, tpriv->isoc_framelist, darwin_async_io_callback,
itransfer);
+ cInterface->frames[transfer->endpoint] = frame + transfer->num_iso_packets / 8;
+
if (kresult != kIOReturnSuccess) {
usbi_err (TRANSFER_CTX (transfer), "isochronous transfer failed (dir: %s): %s", is_read ? "In" : "Out",
darwin_error_str(kresult));
}
static int submit_control_transfer(struct usbi_transfer *itransfer) {
- struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_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_device_handle_priv *priv = (struct darwin_device_handle_priv *)transfer->dev_handle->os_priv;
/* all transfers in libusb-1.0 are async */
if (transfer->endpoint) {
- struct __darwin_interface *cInterface;
+ struct darwin_interface *cInterface;
uint8_t pipeRef, iface;
if (ep_to_pipeRef (transfer->dev_handle, transfer->endpoint, &pipeRef, &iface) != 0) {
}
static int darwin_submit_transfer(struct usbi_transfer *itransfer) {
- struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+ struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
switch (transfer->type) {
case LIBUSB_TRANSFER_TYPE_CONTROL:
}
static int cancel_control_transfer(struct usbi_transfer *itransfer) {
- struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_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_info (ITRANSFER_CTX (itransfer), "WARNING: aborting all transactions control pipe");
+ if (!dpriv->device)
+ return LIBUSB_ERROR_NO_DEVICE;
+
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 libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+ struct darwin_device_priv *dpriv = (struct darwin_device_priv *)transfer->dev_handle->dev->os_priv;
struct darwin_device_handle_priv *priv = (struct darwin_device_handle_priv *)transfer->dev_handle->os_priv;
- struct __darwin_interface *cInterface;
+ struct darwin_interface *cInterface;
uint8_t pipeRef, iface;
IOReturn kresult;
cInterface = &priv->interfaces[iface];
+ if (!dpriv->device)
+ return LIBUSB_ERROR_NO_DEVICE;
+
usbi_info (ITRANSFER_CTX (itransfer), "WARNING: aborting all transactions on interface %d pipe %d", iface, pipeRef);
/* abort transactions */
}
static int darwin_cancel_transfer(struct usbi_transfer *itransfer) {
- struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
+ struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
switch (transfer->type) {
case LIBUSB_TRANSFER_TYPE_CONTROL:
}
static void darwin_clear_transfer_priv (struct usbi_transfer *itransfer) {
- struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_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) {
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 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;
+ UInt32 message, size;
usbi_info (ITRANSFER_CTX (itransfer), "an async io operation has completed");
+ size = (UInt32) arg0;
+
/* 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));
+ write (priv->fds[1], &size, sizeof (size));
}
static int darwin_transfer_status (struct usbi_transfer *itransfer, kern_return_t result) {
}
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);
+ struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
struct darwin_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
int isIsoc = LIBUSB_TRANSFER_TYPE_ISOCHRONOUS == transfer->type;
int isBulk = LIBUSB_TRANSFER_TYPE_BULK == transfer->type;
usbi_handle_transfer_completion (itransfer, darwin_transfer_status (itransfer, result));
}
-static int op_handle_events(struct libusb_context *ctx, struct pollfd *fds, nfds_t nfds, int num_ready) {
+static int op_handle_events(struct libusb_context *ctx, struct pollfd *fds, POLL_NFDS_TYPE nfds, int num_ready) {
struct usbi_transfer *itransfer;
UInt32 io_size;
IOReturn kresult;
- int i = 0, ret;
+ POLL_NFDS_TYPE i = 0;
+ ssize_t ret;
UInt32 message;
usbi_mutex_lock(&ctx->open_devs_lock);
if (!(pollfd->revents & POLLERR)) {
ret = read (hpriv->fds[0], &message, sizeof (message));
- if (ret < sizeof (message))
+ if (ret < (ssize_t)sizeof (message))
continue;
} else
/* could not poll the device-- response is to delete the device (this seems a little heavy-handed) */
switch (clk_id) {
case USBI_CLOCK_REALTIME:
/* CLOCK_REALTIME represents time since the epoch */
- host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &clock_ref);
+ clock_ref = clock_realtime;
break;
case USBI_CLOCK_MONOTONIC:
/* use system boot time as reference for the monotonic clock */
- host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &clock_ref);
+ clock_ref = clock_monotonic;
break;
default:
return LIBUSB_ERROR_INVALID_PARAM;
projects / platform / upstream / libusb.git / blobdiff