Setup program version 4:

	Exchange pyusb with extracted modules from python-libusb1 project.
	Add generating .exe file for win32 platform with py2exe.
	
Controller test application version 2:
	Port application to win32 platform.

Added win32 binary distribution generation.
Update README and HISTORY.

1 files changed, 917 insertions, 0 deletions

diff --git a/df10ch_setup_pkg/libusb1.py b/df10ch_setup_pkg/libusb1.py
new file mode 100644
index 0000000..3cf408f
--- /dev/null
+++ b/df10ch_setup_pkg/libusb1.py
@@ -0,0 +1,917 @@
+"""
+Pythonic wrapper for libusb-1.0.
+
+This file has been extracted from the python-libusb1 project:
+  http://github.com/vpelletier/python-libusb1
+ 
+"""
+
+from ctypes import Structure, \
+                   CFUNCTYPE, POINTER, addressof, sizeof, cast, \
+                   c_short, c_int, c_uint, c_size_t, c_long, \
+                   c_uint8, c_uint16, \
+                   c_void_p, c_char, c_char_p, py_object, string_at
+from ctypes.util import find_library
+import platform
+import os.path
+import sys
+
+class Enum(object):
+    def __init__(self, member_dict):
+        forward_dict = {}
+        reverse_dict = {}
+        module_globals = globals()
+        next_value = 0
+        for name, value in member_dict.iteritems():
+            if value is None:
+                value = next_value
+                next_value += 1
+            forward_dict[name] = value
+            if value in reverse_dict:
+                raise ValueError('Multiple names for value %r: %r, %r' %
+                    (value, reverse_dict[value], name))
+            reverse_dict[value] = name
+            module_globals[name] = value
+        self.forward_dict = forward_dict
+        self.reverse_dict = reverse_dict
+
+    def __call__(self, value):
+        return self.reverse_dict[value]
+
+    def get(self, value, default=None):
+        return self.reverse_dict.get(value, default)
+
+class USBError(Exception):
+    def __init__(self, value):
+        Exception.__init__(self)
+        self.value = value
+
+    def __str__(self):
+        return '%s [%s]' % (libusb_error.get(self.value, 'Unknown error'),
+                            self.value)
+
+c_uchar = c_uint8
+c_int_p = POINTER(c_int)
+
+PATH_MAX = 4096 # XXX: True on linux, no idea about others.
+LITTLE_ENDIAN = sys.byteorder == 'little'
+
+class timeval(Structure):
+    _fields_ = [('tv_sec', c_long),
+                ('tv_usec', c_long)]
+timeval_p = POINTER(timeval)
+
+def _loadLibrary():
+    system = platform.system()
+    if system == 'Windows':
+        from ctypes import WinDLL as dll_loader
+        libusb_path = find_library("libusb-1.0.dll")
+    else:
+        from ctypes import CDLL as dll_loader
+        libusb_path = find_library("usb-1.0")
+        if libusb_path is None and system == 'Darwin':
+            # macport standard library path
+            libusb_path = '/opt/local/lib/libusb-1.0.dylib'
+            if not os.path.isfile(libusb_path):
+                libusb_path = None
+    if libusb_path is None:
+        raise Exception('Can\'t locate usb-1.0 library')
+    loader_kw = {}
+    if sys.version_info[:2] >= (2, 6):
+        loader_kw['use_errno'] = True
+        loader_kw['use_last_error'] = True
+    return dll_loader(libusb_path, **loader_kw)
+
+libusb = _loadLibrary()
+
+# libusb.h
+def bswap16(x):
+    return (((x & 0xff) << 8) | (x >> 8))
+
+if LITTLE_ENDIAN:
+    def libusb_cpu_to_le16(x):
+        return x
+    def libusb_le16_to_cpu(x):
+        return x
+else:
+    libusb_cpu_to_le16 = bswap16
+    libusb_le16_to_cpu = bswap16
+
+# standard USB stuff
+
+# Device and/or Interface Class codes
+libusb_class_code = Enum({
+# In the context of a device descriptor,
+# this bDeviceClass value indicates that each interface specifies its
+# own class information and all interfaces operate independently.
+'LIBUSB_CLASS_PER_INTERFACE': 0,
+# Audio class
+'LIBUSB_CLASS_AUDIO': 1,
+# Communications class
+'LIBUSB_CLASS_COMM': 2,
+# Human Interface Device class
+'LIBUSB_CLASS_HID': 3,
+# Printer dclass
+'LIBUSB_CLASS_PRINTER': 7,
+# Picture transfer protocol class
+'LIBUSB_CLASS_PTP': 6,
+# Mass storage class
+'LIBUSB_CLASS_MASS_STORAGE': 8,
+# Hub class
+'LIBUSB_CLASS_HUB': 9,
+# Data class
+'LIBUSB_CLASS_DATA': 10,
+# Wireless class
+'LIBUSB_CLASS_WIRELESS': 0xe0,
+# Application class
+'LIBUSB_CLASS_APPLICATION': 0xfe,
+# Class is vendor-specific
+'LIBUSB_CLASS_VENDOR_SPEC': 0xff
+})
+
+# Descriptor types as defined by the USB specification.
+libusb_descriptor_type = Enum({
+# Device descriptor. See libusb_device_descriptor. 
+'LIBUSB_DT_DEVICE': 0x01,
+# Configuration descriptor. See libusb_config_descriptor.
+'LIBUSB_DT_CONFIG': 0x02,
+# String descriptor
+'LIBUSB_DT_STRING': 0x03,
+# Interface descriptor. See libusb_interface_descriptor.
+'LIBUSB_DT_INTERFACE': 0x04,
+# Endpoint descriptor. See libusb_endpoint_descriptor.
+'LIBUSB_DT_ENDPOINT': 0x05,
+# HID descriptor
+'LIBUSB_DT_HID': 0x21,
+# HID report descriptor
+'LIBUSB_DT_REPORT': 0x22,
+# Physical descriptor
+'LIBUSB_DT_PHYSICAL': 0x23,
+# Hub descriptor
+'LIBUSB_DT_HUB': 0x29
+})
+
+# Descriptor sizes per descriptor type
+LIBUSB_DT_DEVICE_SIZE         = 18
+LIBUSB_DT_CONFIG_SIZE         = 9
+LIBUSB_DT_INTERFACE_SIZE      = 9
+LIBUSB_DT_ENDPOINT_SIZE       = 7
+LIBUSB_DT_ENDPOINT_AUDIO_SIZE = 9 # Audio extension
+LIBUSB_DT_HUB_NONVAR_SIZE     = 7
+
+USB_ENDPOINT_ADDRESS_MASK     = 0x0f # in bEndpointAddress
+USB_ENDPOINT_DIR_MASK         = 0x80
+
+# Endpoint direction. Values for bit 7 of the endpoint address scheme.
+libusb_endpoint_direction = Enum({
+# In: device-to-host
+'LIBUSB_ENDPOINT_IN': 0x80,
+# Out: host-to-device
+'LIBUSB_ENDPOINT_OUT': 0x00
+})
+
+LIBUSB_TRANSFER_TYPE_MASK = 0x03 # in bmAttributes
+
+# Endpoint transfer type. Values for bits 0:1 of the endpoint attributes field.
+libusb_transfer_type = Enum({
+# Control endpoint
+'LIBUSB_TRANSFER_TYPE_CONTROL': 0,
+# Isochronous endpoint
+'LIBUSB_TRANSFER_TYPE_ISOCHRONOUS': 1,
+# Bulk endpoint
+'LIBUSB_TRANSFER_TYPE_BULK': 2,
+# Interrupt endpoint
+'LIBUSB_TRANSFER_TYPE_INTERRUPT': 3
+})
+
+# Standard requests, as defined in table 9-3 of the USB2 specifications
+libusb_standard_request = Enum({
+# Request status of the specific recipient
+'LIBUSB_REQUEST_GET_STATUS': 0x00,
+# Clear or disable a specific feature
+'LIBUSB_REQUEST_CLEAR_FEATURE': 0x01,
+# 0x02 is reserved
+# Set or enable a specific feature
+'LIBUSB_REQUEST_SET_FEATURE': 0x03,
+# 0x04 is reserved
+# Set device address for all future accesses
+'LIBUSB_REQUEST_SET_ADDRESS': 0x05,
+# Get the specified descriptor
+'LIBUSB_REQUEST_GET_DESCRIPTOR': 0x06,
+# Used to update existing descriptors or add new descriptors
+'LIBUSB_REQUEST_SET_DESCRIPTOR': 0x07,
+# Get the current device configuration value
+'LIBUSB_REQUEST_GET_CONFIGURATION': 0x08,
+# Set device configuration
+'LIBUSB_REQUEST_SET_CONFIGURATION': 0x09,
+# Return the selected alternate setting for the specified interface
+'LIBUSB_REQUEST_GET_INTERFACE': 0x0a,
+# Select an alternate interface for the specified interface
+'LIBUSB_REQUEST_SET_INTERFACE': 0x0b,
+# Set then report an endpoint's synchronization frame
+'LIBUSB_REQUEST_SYNCH_FRAME': 0x0c
+})
+
+# Request type bits of the bmRequestType field in control transfers.
+libusb_request_type = Enum({
+# Standard
+'LIBUSB_TYPE_STANDARD': (0x00 << 5),
+# Class
+'LIBUSB_TYPE_CLASS': (0x01 << 5),
+# Vendor
+'LIBUSB_TYPE_VENDOR': (0x02 << 5),
+# Reserved
+'LIBUSB_TYPE_RESERVED': (0x03 << 5)
+})
+
+# Recipient bits of the bmRequestType field in control transfers. Values 4
+# through 31 are reserved.
+libusb_request_recipient = Enum({
+# Device
+'LIBUSB_RECIPIENT_DEVICE': 0x00,
+# Interface
+'LIBUSB_RECIPIENT_INTERFACE': 0x01,
+# Endpoint
+'LIBUSB_RECIPIENT_ENDPOINT': 0x02,
+# Other
+'LIBUSB_RECIPIENT_OTHER': 0x03
+})
+
+LIBUSB_ISO_SYNC_TYPE_MASK = 0x0c
+
+# Synchronization type for isochronous endpoints. Values for bits 2:3 of the
+# bmAttributes field in libusb_endpoint_descriptor.
+libusb_iso_sync_type = Enum({
+# No synchronization
+'LIBUSB_ISO_SYNC_TYPE_NONE': 0,
+# Asynchronous
+'LIBUSB_ISO_SYNC_TYPE_ASYNC': 1,
+# Adaptive
+'LIBUSB_ISO_SYNC_TYPE_ADAPTIVE': 2,
+# Synchronous
+'LIBUSB_ISO_SYNC_TYPE_SYNC': 3
+})
+
+LIBUSB_ISO_USAGE_TYPE_MASK = 0x30
+
+# Usage type for isochronous endpoints. Values for bits 4:5 of the
+# bmAttributes field in libusb_endpoint_descriptor.
+libusb_iso_usage_type = Enum({
+# Data endpoint
+'LIBUSB_ISO_USAGE_TYPE_DATA': 0,
+# Feedback endpoint
+'LIBUSB_ISO_USAGE_TYPE_FEEDBACK': 1,
+# Implicit feedback Data endpoint
+'LIBUSB_ISO_USAGE_TYPE_IMPLICIT': 2
+})
+
+# A structure representing the standard USB device descriptor. This
+# descriptor is documented in section 9.6.1 of the USB 2.0 specification.
+# All multiple-byte fields are represented in host-endian format.
+class libusb_device_descriptor(Structure):
+    _fields_ = [# Size of this descriptor (in bytes)
+                ('bLength', c_uint8),
+                # Descriptor type. Will have value LIBUSB_DT_DEVICE in this
+                # context.
+                ('bDescriptorType', c_uint8),
+                # USB specification release number in binary-coded decimal. A
+                # value of 0x0200 indicates USB 2.0, 0x0110 indicates USB 1.1,
+                # etc.
+                ('bcdUSB', c_uint16),
+                # USB-IF class code for the device. See libusb_class_code.
+                ('bDeviceClass', c_uint8),
+                # USB-IF subclass code for the device, qualified by the
+                # bDeviceClass value
+                ('bDeviceSubClass', c_uint8),
+                # USB-IF protocol code for the device, qualified by the
+                # bDeviceClass and bDeviceSubClass values
+                ('bDeviceProtocol', c_uint8),
+                # Maximum packet size for endpoint 0
+                ('bMaxPacketSize0', c_uint8),
+                # USB-IF vendor ID
+                ('idVendor', c_uint16),
+                # USB-IF product ID
+                ('idProduct', c_uint16),
+                # Device release number in binary-coded decimal
+                ('bcdDevice', c_uint16),
+                # Index of string descriptor describing manufacturer
+                ('iManufacturer', c_uint8),
+                # Index of string descriptor describing product
+                ('iProduct', c_uint8),
+                # Index of string descriptor containing device serial number
+                ('iSerialNumber', c_uint8),
+                # Number of possible configurations
+                ('bNumConfigurations', c_uint8)]
+libusb_device_descriptor_p = POINTER(libusb_device_descriptor)
+
+class libusb_endpoint_descriptor(Structure):
+    _fields_ = [('bLength', c_uint8),
+                ('bDescriptorType', c_uint8),
+                ('bEndpointAddress', c_uint8),
+                ('bmAttributes', c_uint8),
+                ('wMaxPacketSize', c_uint16),
+                ('bInterval', c_uint8),
+                ('bRefresh', c_uint8),
+                ('bSynchAddress', c_uint8),
+                ('extra', c_void_p),
+                ('extra_length', c_int)]
+libusb_endpoint_descriptor_p = POINTER(libusb_endpoint_descriptor)
+
+class libusb_interface_descriptor(Structure):
+    _fields_ = [('bLength', c_uint8),
+                ('bDescriptorType', c_uint8),
+                ('bInterfaceNumber', c_uint8),
+                ('bAlternateSetting', c_uint8),
+                ('bNumEndpoints', c_uint8),
+                ('bInterfaceClass', c_uint8),
+                ('bInterfaceSubClass', c_uint8),
+                ('bInterfaceProtocol', c_uint8),
+                ('iInterface', c_uint8),
+                ('endpoint', libusb_endpoint_descriptor_p),
+                ('extra', c_void_p),
+                ('extra_length', c_int)]
+libusb_interface_descriptor_p = POINTER(libusb_interface_descriptor)
+
+class libusb_interface(Structure):
+    _fields_ = [('altsetting', libusb_interface_descriptor_p),
+                ('num_altsetting', c_int)]
+libusb_interface_p = POINTER(libusb_interface)
+
+class libusb_config_descriptor(Structure):
+    _fields_ = [('bLength', c_uint8),
+                ('bDescriptorType', c_uint8),
+                ('wTotalLength', c_uint16),
+                ('bNumInterfaces', c_uint8),
+                ('bConfigurationValue', c_uint8),
+                ('iConfiguration', c_uint8),
+                ('bmAttributes', c_uint8),
+                ('MaxPower', c_uint8),
+                ('interface', libusb_interface_p),
+                ('extra', c_void_p),
+                ('extra_length', c_int)]
+libusb_config_descriptor_p = POINTER(libusb_config_descriptor)
+libusb_config_descriptor_p_p = POINTER(libusb_config_descriptor_p)
+
+class libusb_control_setup(Structure):
+    _fields_ = [('bRequestType', c_uint8),
+                ('bRequest', c_uint8),
+                ('wValue', c_uint16),
+                ('wIndex', c_uint16),
+                ('wLength', c_uint16)]
+libusb_control_setup_p = POINTER(libusb_control_setup)
+
+LIBUSB_CONTROL_SETUP_SIZE = sizeof(libusb_control_setup)
+
+# Structure representing a libusb session. The concept of individual libusb
+# sessions allows for your program to use two libraries (or dynamically
+# load two modules) which both independently use libusb. This will prevent
+# interference between the individual libusb users - for example
+# libusb_set_debug() will not affect the other user of the library, and
+# libusb_exit() will not destroy resources that the other user is still
+# using.
+#
+# Sessions are created by libusb_init() and destroyed through libusb_exit().
+# If your application is guaranteed to only ever include a single libusb
+# user (i.e. you), you do not have to worry about contexts: pass NULL in
+# every function call where a context is required. The default context
+# will be used.
+#
+# For more information, see \ref contexts.
+class libusb_context(Structure):
+    pass
+libusb_context_p = POINTER(libusb_context)
+libusb_context_p_p = POINTER(libusb_context_p)
+
+# Structure representing a USB device detected on the system. This is an
+# opaque type for which you are only ever provided with a pointer, usually
+# originating from libusb_get_device_list().
+#
+# Certain operations can be performed on a device, but in order to do any
+# I/O you will have to first obtain a device handle using libusb_open().
+#
+# Devices are reference counted with libusb_device_ref() and
+# libusb_device_unref(), and are freed when the reference count reaches 0.
+# New devices presented by libusb_get_device_list() have a reference count of
+# 1, and libusb_free_device_list() can optionally decrease the reference count
+# on all devices in the list. libusb_open() adds another reference which is
+# later destroyed by libusb_close().
+class libusb_device(Structure):
+    pass
+libusb_device_p = POINTER(libusb_device)
+libusb_device_p_p = POINTER(libusb_device_p)
+libusb_device_p_p_p = POINTER(libusb_device_p_p)
+
+# Structure representing a handle on a USB device. This is an opaque type for
+# which you are only ever provided with a pointer, usually originating from
+# libusb_open().
+#
+# A device handle is used to perform I/O and other operations. When finished
+# with a device handle, you should call libusb_close().
+class libusb_device_handle(Structure):
+    pass
+libusb_device_handle_p = POINTER(libusb_device_handle)
+libusb_device_handle_p_p = POINTER(libusb_device_handle_p)
+
+# Error codes. Most libusb functions return 0 on success or one of these
+# codes on failure.
+libusb_error = Enum({
+# Success (no error)
+'LIBUSB_SUCCESS': 0,
+# Input/output error
+'LIBUSB_ERROR_IO': -1,
+# Invalid parameter
+'LIBUSB_ERROR_INVALID_PARAM': -2,
+# Access denied (insufficient permissions)
+'LIBUSB_ERROR_ACCESS': -3,
+# No such device (it may have been disconnected)
+'LIBUSB_ERROR_NO_DEVICE': -4,
+# Entity not found
+'LIBUSB_ERROR_NOT_FOUND': -5,
+# Resource busy
+'LIBUSB_ERROR_BUSY': -6,
+# Operation timed out
+'LIBUSB_ERROR_TIMEOUT': -7,
+# Overflow
+'LIBUSB_ERROR_OVERFLOW': -8,
+# Pipe error
+'LIBUSB_ERROR_PIPE': -9,
+# System call interrupted (perhaps due to signal)
+'LIBUSB_ERROR_INTERRUPTED': -10,
+# Insufficient memory
+'LIBUSB_ERROR_NO_MEM': -11,
+# Operation not supported or unimplemented on this platform
+'LIBUSB_ERROR_NOT_SUPPORTED': -12,
+# Other error
+'LIBUSB_ERROR_OTHER': -99
+})
+
+# Transfer status codes
+libusb_transfer_status = Enum({
+# Transfer completed without error. Note that this does not indicate
+# that the entire amount of requested data was transferred.
+'LIBUSB_TRANSFER_COMPLETED': 0,
+# Transfer failed
+'LIBUSB_TRANSFER_ERROR': 1,
+# Transfer timed out
+'LIBUSB_TRANSFER_TIMED_OUT': 2,
+# Transfer was cancelled
+'LIBUSB_TRANSFER_CANCELLED': 3,
+# For bulk/interrupt endpoints: halt condition detected (endpoint
+# stalled). For control endpoints: control request not supported.
+'LIBUSB_TRANSFER_STALL': 4,
+# Device was disconnected
+'LIBUSB_TRANSFER_NO_DEVICE': 5,
+# Device sent more data than requested
+'LIBUSB_TRANSFER_OVERFLOW': 6
+})
+
+# libusb_transfer.flags values
+libusb_transfer_flags = Enum({
+# Report short frames as errors
+'LIBUSB_TRANSFER_SHORT_NOT_OK': 1<<0,
+# Automatically free() transfer buffer during libusb_free_transfer()
+'LIBUSB_TRANSFER_FREE_BUFFER': 1<<1,
+# Automatically call libusb_free_transfer() after callback returns.
+# If this flag is set, it is illegal to call libusb_free_transfer()
+# from your transfer callback, as this will result in a double-free
+# when this flag is acted upon.
+'LIBUSB_TRANSFER_FREE_TRANSFER': 1<<2
+})
+
+# Isochronous packet descriptor.
+class libusb_iso_packet_descriptor(Structure):
+    _fields_ = [('length', c_uint),
+                ('actual_length', c_uint),
+                ('status', c_int)] # enum libusb_transfer_status
+libusb_iso_packet_descriptor_p = POINTER(libusb_iso_packet_descriptor)
+
+class libusb_transfer(Structure):
+    pass
+libusb_transfer_p = POINTER(libusb_transfer)
+
+libusb_transfer_cb_fn_p = CFUNCTYPE(None, libusb_transfer_p)
+
+libusb_transfer._fields_ = [('dev_handle', libusb_device_handle_p),
+                            ('flags', c_uint8),
+                            ('endpoint', c_uchar),
+                            ('type', c_uchar),
+                            ('timeout', c_uint),
+                            ('status', c_int), # enum libusb_transfer_status
+                            ('length', c_int),
+                            ('actual_length', c_int),
+                            ('callback', libusb_transfer_cb_fn_p),
+                            ('user_data', py_object),
+                            ('buffer', c_void_p),
+                            ('num_iso_packets', c_int),
+                            ('iso_packet_desc', libusb_iso_packet_descriptor)
+]
+
+#int libusb_init(libusb_context **ctx);
+libusb_init = libusb.libusb_init
+libusb_init.argtypes = [libusb_context_p_p]
+#void libusb_exit(libusb_context *ctx);
+libusb_exit = libusb.libusb_exit
+libusb_exit.argtypes = [libusb_context_p]
+libusb_exit.restype = None
+#void libusb_set_debug(libusb_context *ctx, int level);
+libusb_set_debug = libusb.libusb_set_debug
+libusb_set_debug.argtypes = [libusb_context_p, c_int]
+libusb_set_debug.restype = None
+try:
+    #char *libusb_strerror(enum libusb_error errcode);
+    libusb_strerror = libusb.libusb_strerror
+except AttributeError:
+    # Place holder
+    def libusb_strerror(errcode):
+        return None
+else:
+    libusb_strerror.argtypes = [c_int]
+    libusb_strerror.restype = c_char_p
+
+#ssize_t libusb_get_device_list(libusb_context *ctx,
+#        libusb_device ***list);
+libusb_get_device_list = libusb.libusb_get_device_list
+libusb_get_device_list.argtypes = [libusb_context_p, libusb_device_p_p_p]
+libusb_get_device_list.restype = c_size_t
+#void libusb_free_device_list(libusb_device **list, int unref_devices);
+libusb_free_device_list = libusb.libusb_free_device_list
+libusb_free_device_list.argtypes = [libusb_device_p_p, c_int]
+libusb_free_device_list.restype = None
+#libusb_device *libusb_ref_device(libusb_device *dev);
+libusb_ref_device = libusb.libusb_ref_device
+libusb_ref_device.argtypes = [libusb_device_p]
+libusb_ref_device.restype = libusb_device_p
+#void libusb_unref_device(libusb_device *dev);
+libusb_unref_device = libusb.libusb_unref_device
+libusb_unref_device.argtypes = [libusb_device_p]
+libusb_unref_device.restype = None
+
+#int libusb_get_configuration(libusb_device_handle *dev, int *config);
+libusb_get_configuration = libusb.libusb_get_configuration
+libusb_get_configuration.argtypes = [libusb_device_handle_p, c_int_p]
+#int libusb_get_device_descriptor(libusb_device *dev,
+#        struct libusb_device_descriptor *desc);
+libusb_get_device_descriptor = libusb.libusb_get_device_descriptor
+libusb_get_device_descriptor.argtypes = [libusb_device_p,
+                                         libusb_device_descriptor_p]
+#int libusb_get_active_config_descriptor(libusb_device *dev,
+#        struct libusb_config_descriptor **config);
+libusb_get_active_config_descriptor = libusb.libusb_get_active_config_descriptor
+libusb_get_active_config_descriptor.argtypes = [libusb_device_p,
+                                                libusb_config_descriptor_p_p]
+#int libusb_get_config_descriptor(libusb_device *dev, uint8_t config_index,
+#        struct libusb_config_descriptor **config);
+libusb_get_config_descriptor = libusb.libusb_get_config_descriptor
+libusb_get_config_descriptor.argtypes = [libusb_device_p, c_uint8,
+                                         libusb_config_descriptor_p_p]
+#int libusb_get_config_descriptor_by_value(libusb_device *dev,
+#        uint8_t bConfigurationValue, struct libusb_config_descriptor **config);
+libusb_get_config_descriptor_by_value = \
+    libusb.libusb_get_config_descriptor_by_value
+libusb_get_config_descriptor_by_value.argtypes = [libusb_device_p, c_uint8,
+                                                  libusb_config_descriptor_p_p]
+#void libusb_free_config_descriptor(struct libusb_config_descriptor *config);
+libusb_free_config_descriptor = libusb.libusb_free_config_descriptor
+libusb_free_config_descriptor.argtypes = [libusb_config_descriptor_p]
+libusb_free_config_descriptor.restype = None
+#uint8_t libusb_get_bus_number(libusb_device *dev);
+libusb_get_bus_number = libusb.libusb_get_bus_number
+libusb_get_bus_number.argtypes = [libusb_device_p]
+libusb_get_bus_number.restype = c_uint8
+#uint8_t libusb_get_device_address(libusb_device *dev);
+libusb_get_device_address = libusb.libusb_get_device_address
+libusb_get_device_address.argtypes = [libusb_device_p]
+libusb_get_device_address.restype = c_uint8
+#int libusb_get_max_packet_size(libusb_device *dev, unsigned char endpoint);
+libusb_get_max_packet_size = libusb.libusb_get_max_packet_size
+libusb_get_max_packet_size.argtypes = [libusb_device_p, c_uchar]
+#int libusb_get_max_iso_packet_size(libusb_device *dev, unsigned char endpoint);
+libusb_get_max_iso_packet_size = libusb.libusb_get_max_iso_packet_size
+libusb_get_max_iso_packet_size.argtypes = [libusb_device_p, c_uchar]
+
+#int libusb_open(libusb_device *dev, libusb_device_handle **handle);
+libusb_open = libusb.libusb_open
+libusb_open.argtypes = [libusb_device_p, libusb_device_handle_p_p]
+#void libusb_close(libusb_device_handle *dev_handle);
+libusb_close = libusb.libusb_close
+libusb_close.argtypes = [libusb_device_handle_p]
+libusb_close.restype = None
+#libusb_device *libusb_get_device(libusb_device_handle *dev_handle);
+libusb_get_device = libusb.libusb_get_device
+libusb_get_device.argtypes = [libusb_device_handle_p]
+libusb_get_device.restype = libusb_device_p
+
+#int libusb_set_configuration(libusb_device_handle *dev, int configuration);
+libusb_set_configuration = libusb.libusb_set_configuration
+libusb_set_configuration.argtypes = [libusb_device_handle_p, c_int]
+#int libusb_claim_interface(libusb_device_handle *dev, int iface);
+libusb_claim_interface = libusb.libusb_claim_interface
+libusb_claim_interface.argtypes = [libusb_device_handle_p, c_int]
+#int libusb_release_interface(libusb_device_handle *dev, int iface);
+libusb_release_interface = libusb.libusb_release_interface
+libusb_release_interface.argtypes = [libusb_device_handle_p, c_int]
+
+#libusb_device_handle *libusb_open_device_with_vid_pid(libusb_context *ctx,
+#        uint16_t vendor_id, uint16_t product_id);
+libusb_open_device_with_vid_pid = libusb.libusb_open_device_with_vid_pid
+libusb_open_device_with_vid_pid.argtypes = [libusb_context_p, c_uint16,
+                                            c_uint16]
+libusb_open_device_with_vid_pid.restype = libusb_device_handle_p
+
+#int libusb_set_interface_alt_setting(libusb_device_handle *dev,
+#        int interface_number, int alternate_setting);
+libusb_set_interface_alt_setting = libusb.libusb_set_interface_alt_setting
+libusb_set_interface_alt_setting.argtypes = [libusb_device_handle_p, c_int,
+                                             c_int]
+#int libusb_clear_halt(libusb_device_handle *dev, unsigned char endpoint);
+libusb_clear_halt = libusb.libusb_clear_halt
+libusb_clear_halt.argtypes = [libusb_device_handle_p, c_uchar]
+#int libusb_reset_device(libusb_device_handle *dev);
+libusb_reset_device = libusb.libusb_reset_device
+libusb_reset_device.argtypes = [libusb_device_handle_p]
+
+#int libusb_kernel_driver_active(libusb_device_handle *dev, int interface);
+libusb_kernel_driver_active = libusb.libusb_kernel_driver_active
+libusb_kernel_driver_active.argtypes = [libusb_device_handle_p, c_int]
+#int libusb_detach_kernel_driver(libusb_device_handle *dev, int interface);
+libusb_detach_kernel_driver = libusb.libusb_detach_kernel_driver
+libusb_detach_kernel_driver.argtypes = [libusb_device_handle_p, c_int]
+#int libusb_attach_kernel_driver(libusb_device_handle *dev, int interface);
+libusb_attach_kernel_driver = libusb.libusb_attach_kernel_driver
+libusb_attach_kernel_driver.argtypes = [libusb_device_handle_p, c_int]
+
+# Get the data section of a control transfer. This convenience function is here
+# to remind you that the data does not start until 8 bytes into the actual
+# buffer, as the setup packet comes first.
+#
+# Calling this function only makes sense from a transfer callback function,
+# or situations where you have already allocated a suitably sized buffer at
+# transfer->buffer.
+#
+# \param transfer a transfer
+# \returns pointer to the first byte of the data section
+
+def libusb_control_transfer_get_data(transfer_p):
+    transfer = transfer_p.contents
+    return string_at(transfer.buffer, transfer.length)[
+        LIBUSB_CONTROL_SETUP_SIZE:]
+
+def libusb_control_transfer_get_setup(transfer_p):
+    return cast(transfer_p.contents.buffer, libusb_control_setup_p)
+
+def libusb_fill_control_setup(setup_p, bmRequestType, bRequest, wValue, wIndex,
+                              wLength):
+    setup = cast(setup_p, libusb_control_setup_p).contents
+    setup.bmRequestType = bmRequestType
+    setup.bRequest = bRequest
+    setup.wValue = libusb_cpu_to_le16(wValue)
+    setup.wIndex = libusb_cpu_to_le16(wIndex)
+    setup.wLength = libusb_cpu_to_le16(wLength)
+
+#struct libusb_transfer *libusb_alloc_transfer(int iso_packets);
+libusb_alloc_transfer = libusb.libusb_alloc_transfer
+libusb_alloc_transfer.argtypes = [c_int]
+libusb_alloc_transfer.restype = libusb_transfer_p
+#int libusb_submit_transfer(struct libusb_transfer *transfer);
+libusb_submit_transfer = libusb.libusb_submit_transfer
+libusb_submit_transfer.argtypes = [libusb_transfer_p]
+#int libusb_cancel_transfer(struct libusb_transfer *transfer);
+libusb_cancel_transfer = libusb.libusb_cancel_transfer
+libusb_cancel_transfer.argtypes = [libusb_transfer_p]
+#void libusb_free_transfer(struct libusb_transfer *transfer);
+libusb_free_transfer = libusb.libusb_free_transfer
+libusb_free_transfer.argtypes = [libusb_transfer_p]
+libusb_free_transfer.restype = None
+
+def libusb_fill_control_transfer(transfer_p, dev_handle, buffer, callback,
+                                 user_data, timeout):
+    transfer = transfer_p.contents
+    transfer.dev_handle = dev_handle
+    transfer.endpoint = 0
+    transfer.type = LIBUSB_TRANSFER_TYPE_CONTROL
+    transfer.timeout = timeout
+    transfer.buffer = cast(buffer, c_void_p)
+    if buffer is not None:
+        setup = cast(buffer, libusb_control_setup_p).contents
+        transfer.length = LIBUSB_CONTROL_SETUP_SIZE + \
+                          libusb_le16_to_cpu(setup.wLength)
+    transfer.user_data = user_data
+    transfer.callback = callback
+
+def libusb_fill_bulk_transfer(transfer_p, dev_handle, endpoint, buffer, length,
+                              callback, user_data, timeout):
+    transfer = transfer_p.contents
+    transfer.dev_handle = dev_handle
+    transfer.endpoint = endpoint
+    transfer.type = LIBUSB_TRANSFER_TYPE_BULK
+    transfer.timeout = timeout
+    transfer.buffer = cast(buffer, c_void_p)
+    transfer.length = length
+    transfer.user_data = user_data
+    transfer.callback = callback
+
+def libusb_fill_interrupt_transfer(transfer_p, dev_handle, endpoint, buffer,
+                                   length, callback, user_data, timeout):
+    transfer = transfer_p.contents
+    transfer.dev_handle = dev_handle
+    transfer.endpoint = endpoint
+    transfer.type = LIBUSB_TRANSFER_TYPE_INTERRUPT
+    transfer.timeout = timeout
+    transfer.buffer = cast(buffer, c_void_p)
+    transfer.length = length
+    transfer.user_data = user_data
+    transfer.callback = callback
+
+def libusb_fill_iso_transfer(transfer_p, dev_handle, endpoint, buffer, length,
+                             num_iso_packets, callback, user_data, timeout):
+    transfer = transfer_p.contents
+    transfer.dev_handle = dev_handle
+    transfer.endpoint = endpoint
+    transfer.type = LIBUSB_TRANSFER_TYPE_ISOCHRONOUS
+    transfer.timeout = timeout
+    transfer.buffer = cast(buffer, c_void_p)
+    transfer.length = length
+    transfer.num_iso_packets = num_iso_packets
+    transfer.user_data = user_data
+    transfer.callback = callback
+
+def _get_iso_packet_list(transfer):
+    list_type = libusb_iso_packet_descriptor * transfer.num_iso_packets
+    return list_type.from_address(addressof(transfer.iso_packet_desc))
+
+def get_iso_packet_list(transfer_p):
+    """
+    Python-specific helper extracting a list of iso packet descriptors,
+    because it's not as straight-forward as in C.
+    """
+    return _get_iso_packet_list(transfer_p.contents)
+
+def _get_iso_packet_buffer(transfer, offset, length):
+    return string_at(addressof(transfer.buffer) + offset, length)
+
+def get_iso_packet_buffer_list(transfer_p):
+    """
+    Python-specific helper extracting a list of iso packet buffers.
+    """
+    transfer = transfer_p.contents
+    offset = 0
+    result = []
+    append = result.append
+    for iso_transfer in _get_iso_packet_list(transfer):
+        length = iso_transfer.length
+        append(_get_iso_packet_buffer(transfer, offset, length))
+        offset += length
+    return result
+
+def get_extra(descriptor):
+    """
+    Python-specific helper to access "extra" field of descriptors,
+    because it's not as straight-forward as in C.
+    Returns a list, where each entry is an individual extra descriptor.
+    """
+    result = []
+    extra_length = descriptor.extra_length
+    if extra_length:
+        extra = string_at(descriptor.extra, extra_length)
+        append = result.append
+        while extra:
+            length = ord(extra[0])
+            if not (0 < length <= len(extra)):
+                raise ValueError('Extra descriptor %i is incomplete/invalid' % (
+                    len(result), ))
+            append(extra[:length])
+            extra = extra[length:]
+    return result
+
+def libusb_set_iso_packet_lengths(transfer_p, length):
+    transfer = transfer_p.contents
+    for iso_packet_desc in _get_iso_packet_list(transfer):
+        iso_packet_desc.length = length
+
+def libusb_get_iso_packet_buffer(transfer_p, packet):
+    transfer = transfer_p.contents
+    offset = 0
+    if packet >= transfer.num_iso_packets:
+        return None
+    iso_packet_desc_list = _get_iso_packet_list(transfer)
+    for i in xrange(packet):
+        offset += iso_packet_desc_list[i].length
+    return _get_iso_packet_buffer(transfer, offset,
+        iso_packet_desc_list[packet].length)
+
+def libusb_get_iso_packet_buffer_simple(transfer_p, packet):
+    transfer = transfer_p.contents
+    if packet >= transfer.num_iso_packets:
+        return None
+    iso_length = transfer.iso_packet_desc.length
+    return _get_iso_packet_buffer(transfer, iso_length * packet, iso_length)
+ 
+# sync I/O
+
+#int libusb_control_transfer(libusb_device_handle *dev_handle,
+#        uint8_t request_type, uint8_t request, uint16_t value, uint16_t index,
+#        unsigned char *data, uint16_t length, unsigned int timeout);
+libusb_control_transfer = libusb.libusb_control_transfer
+libusb_control_transfer.argtypes = [libusb_device_handle_p, c_uint8, c_uint8,
+                                    c_uint16, c_uint16, c_void_p, c_uint16,
+                                    c_uint]
+
+#int libusb_bulk_transfer(libusb_device_handle *dev_handle,
+#        unsigned char endpoint, unsigned char *data, int length,
+#        int *actual_length, unsigned int timeout);
+libusb_bulk_transfer = libusb.libusb_bulk_transfer
+libusb_bulk_transfer.argtypes = [libusb_device_handle_p, c_uchar, c_void_p,
+                                 c_int, c_int_p, c_uint]
+
+#int libusb_interrupt_transfer(libusb_device_handle *dev_handle,
+#        unsigned char endpoint, unsigned char *data, int length,
+#        int *actual_length, unsigned int timeout);
+libusb_interrupt_transfer = libusb.libusb_interrupt_transfer
+libusb_interrupt_transfer.argtypes = [libusb_device_handle_p, c_uchar,
+                                      c_void_p, c_int, c_int_p, c_uint]
+
+def libusb_get_descriptor(dev, desc_type, desc_index, data, length):
+    return libusb_control_transfer(dev, LIBUSB_ENDPOINT_IN,
+                                   LIBUSB_REQUEST_GET_DESCRIPTOR,
+                                   (desc_type << 8) | desc_index, 0, data,
+                                   length, 1000)
+
+def libusb_get_string_descriptor(dev, desc_index, langid, data, length):
+    return libusb_control_transfer(dev, LIBUSB_ENDPOINT_IN,
+                                   LIBUSB_REQUEST_GET_DESCRIPTOR,
+                                   (LIBUSB_DT_STRING << 8) | desc_index,
+                                   langid, data, length, 1000)
+
+#int libusb_get_string_descriptor_ascii(libusb_device_handle *dev,
+#        uint8_t index, unsigned char *data, int length);
+libusb_get_string_descriptor_ascii = libusb.libusb_get_string_descriptor_ascii
+libusb_get_string_descriptor_ascii.argtypes = [libusb_device_handle_p,
+                                               c_uint8, c_void_p, c_int]
+
+# polling and timeouts
+
+#int libusb_try_lock_events(libusb_context *ctx);
+libusb_try_lock_events = libusb.libusb_try_lock_events
+libusb_try_lock_events.argtypes = [libusb_context_p]
+#void libusb_lock_events(libusb_context *ctx);
+libusb_lock_events = libusb.libusb_lock_events
+libusb_lock_events.argtypes = [libusb_context_p]
+#void libusb_unlock_events(libusb_context *ctx);
+libusb_unlock_events = libusb.libusb_unlock_events
+libusb_unlock_events.argtypes = [libusb_context_p]
+libusb_unlock_events.restype = None
+#int libusb_event_handling_ok(libusb_context *ctx);
+libusb_event_handling_ok = libusb.libusb_event_handling_ok
+libusb_event_handling_ok.argtypes = [libusb_context_p]
+#int libusb_event_handler_active(libusb_context *ctx);
+libusb_event_handler_active = libusb.libusb_event_handler_active
+libusb_event_handler_active.argtypes = [libusb_context_p]
+#void libusb_lock_event_waiters(libusb_context *ctx);
+libusb_lock_event_waiters = libusb.libusb_lock_event_waiters
+libusb_lock_event_waiters.argtypes = [libusb_context_p]
+libusb_lock_event_waiters.restype = None
+#void libusb_unlock_event_waiters(libusb_context *ctx);
+libusb_unlock_event_waiters = libusb.libusb_unlock_event_waiters
+libusb_unlock_event_waiters.argtypes = []
+libusb_unlock_event_waiters.restype = None
+#int libusb_wait_for_event(libusb_context *ctx, struct timeval *tv);
+libusb_wait_for_event = libusb.libusb_wait_for_event
+libusb_wait_for_event.argtypes = [libusb_context_p, timeval_p]
+
+#int libusb_handle_events_timeout(libusb_context *ctx, struct timeval *tv);
+libusb_handle_events_timeout = libusb.libusb_handle_events_timeout
+libusb_handle_events_timeout.argtypes = [libusb_context_p, timeval_p]
+#int libusb_handle_events(libusb_context *ctx);
+libusb_handle_events = libusb.libusb_handle_events
+libusb_handle_events.argtypes = [libusb_context_p]
+#int libusb_handle_events_locked(libusb_context *ctx, struct timeval *tv);
+libusb_handle_events_locked = libusb.libusb_handle_events_locked
+libusb_handle_events_locked.argtypes = [libusb_context_p, timeval_p]
+#int libusb_get_next_timeout(libusb_context *ctx, struct timeval *tv);
+libusb_get_next_timeout = libusb.libusb_get_next_timeout
+libusb_get_next_timeout.argtypes = [libusb_context_p, timeval_p]
+
+class libusb_pollfd(Structure):
+    _fields_ = [('fd', c_int),
+                ('events', c_short)]
+libusb_pollfd_p = POINTER(libusb_pollfd)
+libusb_pollfd_p_p = POINTER(libusb_pollfd_p)
+
+libusb_pollfd_added_cb_p = CFUNCTYPE(None, c_int, c_short, py_object)
+libusb_pollfd_removed_cb_p = CFUNCTYPE(None, c_int, py_object)
+
+#const struct libusb_pollfd **libusb_get_pollfds(libusb_context *ctx);
+libusb_get_pollfds = libusb.libusb_get_pollfds
+libusb_get_pollfds.argtypes = [libusb_context_p]
+libusb_get_pollfds.restype = libusb_pollfd_p_p
+#void libusb_set_pollfd_notifiers(libusb_context *ctx,
+#        libusb_pollfd_added_cb added_cb, libusb_pollfd_removed_cb removed_cb,
+#        void *user_data);
+libusb_set_pollfd_notifiers = libusb.libusb_set_pollfd_notifiers
+libusb_set_pollfd_notifiers.argtypes = [libusb_context_p,
+                                        libusb_pollfd_added_cb_p,
+                                        libusb_pollfd_removed_cb_p, py_object]
+libusb_set_pollfd_notifiers.restype = None
+
+# /libusb.h
+