# Copyright (C) 2010-2016 Vincent Pelletier # # 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 # pylint: disable=invalid-name, too-few-public-methods, too-many-arguments # pylint: disable=missing-docstring """ Python ctypes bindings for libusb-1.0. You should not need to import this if you use usb1 module. Declares all constants, data structures and exported symbols. Locates and loads libusb1 dynamic library. """ from ctypes import Structure, LittleEndianStructure, \ CFUNCTYPE, POINTER, addressof, sizeof, cast, \ c_short, c_int, c_uint, c_size_t, c_long, \ c_uint8, c_uint16, c_uint32, \ c_void_p, c_char_p, py_object, string_at, pointer try: from ctypes import c_ssize_t except ImportError: from ctypes import c_longlong # c_ssize_t is new in Python 2.7 if sizeof(c_int) == sizeof(c_size_t): c_ssize_t = c_int elif sizeof(c_long) == sizeof(c_size_t): c_ssize_t = c_long elif sizeof(c_longlong) == sizeof(c_size_t): c_ssize_t = c_longlong else: raise ValueError('Unsupported arch: sizeof(c_size_t) = %r' % ( sizeof(c_size_t), )) import ctypes.util import platform import os.path import sys class Enum(object): def __init__(self, member_dict, scope_dict=None): if scope_dict is None: # Affect caller's locals, not this module's. # pylint: disable=protected-access scope_dict = sys._getframe(1).f_locals # pylint: enable=protected-access forward_dict = {} reverse_dict = {} next_value = 0 for name, value in member_dict.items(): 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 scope_dict[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) _desc_type_dict = { 'b': c_uint8, 'bcd': c_uint16, 'bm': c_uint8, 'dw': c_uint32, 'i': c_uint8, 'id': c_uint16, 'w': c_uint16, } def newStruct(field_name_list): """ Create a ctype structure class based on USB standard field naming (type-prefixed). """ field_list = [] append = field_list.append for field in field_name_list: type_prefix = '' for char in field: if not char.islower(): break type_prefix += char append((field, _desc_type_dict[type_prefix])) result = type('some_descriptor', (LittleEndianStructure, ), {}) # Not using type()'s 3rd param to initialise class, as per ctypes # documentation: # _pack_ must already be defined when _fields_ is assigned, otherwise it # will have no effect. # pylint: disable=protected-access result._pack_ = 1 result._fields_ = field_list # pylint: enable=protected-access return result def newDescriptor(field_name_list): """ Create a USB descriptor ctype structure, ie starting with bLength and bDescriptorType fields. See newStruct(). """ return newStruct(['bLength', 'bDescriptorType'] + list(field_name_list)) class USBError(Exception): value = None def __init__(self, value=None): Exception.__init__(self) if value is not None: self.value = value def __str__(self): return '%s [%s]' % (libusb_error.get(self.value, 'Unknown error'), self.value) if sys.version_info[0] == 3: _string_item_to_int = lambda x: x _empty_char_p = bytes() else: _string_item_to_int = ord _empty_char_p = '' c_uchar = c_uint8 c_int_p = POINTER(c_int) 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': dll_loader = ctypes.WinDLL suffix = '.dll' else: dll_loader = ctypes.CDLL suffix = system == 'Darwin' and '.dylib' or '.so' loader_kw = {} if sys.version_info[:2] >= (2, 6): loader_kw['use_errno'] = True loader_kw['use_last_error'] = True try: return dll_loader('libusb-1.0' + suffix, **loader_kw) except OSError: libusb_path = None base_name = 'usb-1.0' if 'FreeBSD' in system: # libusb.so.2 on FreeBSD: load('libusb.so') would work fine, but... # libusb.so.2debian on Debian GNU/kFreeBSD: here it wouldn't work. # So use find_library instead. base_name = 'usb' elif system == 'Darwin': for libusb_path in ( # macport standard path '/opt/local/lib/libusb-1.0.dylib', # fink standard path '/sw/lib/libusb-1.0.dylib', ): if os.path.exists(libusb_path): break else: libusb_path = None if libusb_path is None: libusb_path = ctypes.util.find_library(base_name) if libusb_path is None: raise 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, # Physical 'LIBUSB_CLASS_PHYSICAL': 5, # Printer class '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, # Smart Card 'LIBUSB_CLASS_SMART_CARD': 0x0b, # Content Security 'LIBUSB_CLASS_CONTENT_SECURITY': 0x0d, # Video 'LIBUSB_CLASS_VIDEO': 0x0e, # Personal Healthcare 'LIBUSB_CLASS_PERSONAL_HEALTHCARE': 0x0f, # Diagnostic Device 'LIBUSB_CLASS_DIAGNOSTIC_DEVICE': 0xdc, # Wireless class 'LIBUSB_CLASS_WIRELESS': 0xe0, # Application class 'LIBUSB_CLASS_APPLICATION': 0xfe, # Class is vendor-specific 'LIBUSB_CLASS_VENDOR_SPEC': 0xff }) # pylint: disable=undefined-variable LIBUSB_CLASS_IMAGE = LIBUSB_CLASS_PTP # pylint: enable=undefined-variable # 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 LIBUSB_ENDPOINT_ADDRESS_MASK = 0x0f # in bEndpointAddress LIBUSB_ENDPOINT_DIR_MASK = 0x80 # BBB USB_ENDPOINT_ADDRESS_MASK = LIBUSB_ENDPOINT_ADDRESS_MASK USB_ENDPOINT_DIR_MASK = LIBUSB_ENDPOINT_DIR_MASK # 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_REQUEST_TYPE_STANDARD': (0x00 << 5), # Class 'LIBUSB_REQUEST_TYPE_CLASS': (0x01 << 5), # Vendor 'LIBUSB_REQUEST_TYPE_VENDOR': (0x02 << 5), # Reserved 'LIBUSB_REQUEST_TYPE_RESERVED': (0x03 << 5), }) # BBB # pylint: disable=bad-whitespace,undefined-variable LIBUSB_TYPE_STANDARD = LIBUSB_REQUEST_TYPE_STANDARD LIBUSB_TYPE_CLASS = LIBUSB_REQUEST_TYPE_CLASS LIBUSB_TYPE_VENDOR = LIBUSB_REQUEST_TYPE_VENDOR LIBUSB_TYPE_RESERVED = LIBUSB_REQUEST_TYPE_RESERVED # pylint: enable=bad-whitespace,undefined-variable # 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_ = [ ('bmRequestType', 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) class libusb_version(Structure): _fields_ = [ ('major', c_uint16), ('minor', c_uint16), ('micro', c_uint16), ('nano', c_uint16), ('rc', c_char_p), ('describe', c_char_p), ] libusb_speed = Enum({ # The OS doesn't report or know the device speed. 'LIBUSB_SPEED_UNKNOWN': 0, # The device is operating at low speed (1.5MBit/s). 'LIBUSB_SPEED_LOW': 1, # The device is operating at full speed (12MBit/s). 'LIBUSB_SPEED_FULL': 2, # The device is operating at high speed (480MBit/s). 'LIBUSB_SPEED_HIGH': 3, # The device is operating at super speed (5000MBit/s). 'LIBUSB_SPEED_SUPER': 4, }) libusb_supported_speed = Enum({ # Low speed operation supported (1.5MBit/s). 'LIBUSB_LOW_SPEED_OPERATION': 1, # Full speed operation supported (12MBit/s). 'LIBUSB_FULL_SPEED_OPERATION': 2, # High speed operation supported (480MBit/s). 'LIBUSB_HIGH_SPEED_OPERATION': 4, # Superspeed operation supported (5000MBit/s). 'LIBUSB_5GBPS_OPERATION': 8, }) # 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, # Terminate transfers that are a multiple of the endpoint's # wMaxPacketSize with an extra zero length packet. 'LIBUSB_TRANSFER_ADD_ZERO_PACKET': 1 << 3, }) # 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', c_void_p), ('buffer', c_void_p), ('num_iso_packets', c_int), ('iso_packet_desc', libusb_iso_packet_descriptor) ] if 'FreeBSD' in platform.system() and getattr( libusb, 'libusb_get_string_descriptor', None ) is None: # Old FreeBSD version has a slight ABI incompatibility. # Work around it unless libusb_get_string_descriptor is available, as it # is only available on fixed versions. assert _libusb_transfer_fields[2][0] == 'endpoint' _libusb_transfer_fields[2] = ('endpoint', c_uint32) assert _libusb_transfer_fields[11][0] == 'num_iso_packets' _libusb_transfer_fields.insert(11, ('os_priv', c_void_p)) # pylint: disable=protected-access libusb_transfer._fields_ = _libusb_transfer_fields # pylint: enable=protected-access libusb_capability = Enum({ # The libusb_has_capability() API is available. 'LIBUSB_CAP_HAS_CAPABILITY': 0x0000, # Hotplug support is available. 'LIBUSB_CAP_HAS_HOTPLUG': 0x0001, # The library can access HID devices without requiring user intervention. 'LIBUSB_CAP_HAS_HID_ACCESS': 0x0100, # The library supports detaching of the default USB driver. 'LIBUSB_CAP_SUPPORTS_DETACH_KERNEL_DRIVER': 0x0101, }) libusb_log_level = Enum({ 'LIBUSB_LOG_LEVEL_NONE': 0, 'LIBUSB_LOG_LEVEL_ERROR': 1, 'LIBUSB_LOG_LEVEL_WARNING': 2, 'LIBUSB_LOG_LEVEL_INFO': 3, 'LIBUSB_LOG_LEVEL_DEBUG': 4, }) #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 #const struct libusb_version * libusb_get_version(void); try: libusb_get_version = libusb.libusb_get_version except AttributeError: _dummy_version = libusb_version(0, 0, 0, 0, _empty_char_p, _empty_char_p) _dummy_version_p = pointer(_dummy_version) def libusb_get_version(): return _dummy_version_p else: libusb_get_version.argtypes = [] libusb_get_version.restype = POINTER(libusb_version) #int libusb_has_capability(uint32_t capability); try: libusb_has_capability = libusb.libusb_has_capability except AttributeError: def libusb_has_capability(_): return 0 else: libusb_has_capability.argtypes = [c_uint32] libusb_has_capability.restype = c_int try: # Note: Should be equivalent to libusb_error.get (except libusb_error.get # one raises on unknown values). #char *libusb_error_name(int errcode); libusb_error_name = libusb.libusb_error_name except AttributeError: # pylint: disable=unused-argument def libusb_error_name(errcode): return None # pylint: enable=unused-argument else: libusb_error_name.argtypes = [c_int] libusb_error_name.restype = c_char_p # Note on libusb_strerror, libusb_setlocale and future functions in the # same spirit: # I do not think end-user-facing messages belong to a technical library. # Such features bring a new, non essential set of problems, and is a luxury # I do not want to spend time supporting considering limited resources and # more important stuff to work on. # For backward compatibility, expose libusb_strerror placeholder. # pylint: disable=unused-argument def libusb_strerror(errcode): return None # pylint: enable=unused-argument #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_ssize_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 try: #uint8_t libusb_get_port_number(libusb_device *dev); libusb_get_port_number = libusb.libusb_get_port_number except AttributeError: pass else: libusb_get_port_number.argtypes = [libusb_device_p] libusb_get_port_number.restype = c_uint8 try: #int libusb_get_port_numbers(libusb_device *dev, # uint8_t* port_numbers, int port_numbers_len); libusb_get_port_numbers = libusb.libusb_get_port_numbers except AttributeError: pass else: libusb_get_port_numbers.argtypes = [ libusb_device_p, POINTER(c_uint8), c_int] libusb_get_port_numbers.restype = c_int # Missing: libusb_get_port_path (deprecated since 1.0.16) try: #libusb_device * LIBUSB_CALL libusb_get_parent(libusb_device *dev); libusb_get_parent = libusb.libusb_get_parent except AttributeError: pass else: libusb_get_parent.argtypes = [libusb_device_p] libusb_get_parent.restype = libusb_device_p #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 try: #int libusb_get_device_speed(libusb_device *dev); libusb_get_device_speed = libusb.libusb_get_device_speed except AttributeError: # Place holder def libusb_get_device_speed(_): # pylint: disable=undefined-variable return LIBUSB_SPEED_UNKNOWN # pylint: enable=undefined-variable else: libusb_get_device_speed.argtypes = [libusb_device_p] #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); try: libusb_get_max_iso_packet_size = libusb.libusb_get_max_iso_packet_size except AttributeError: # FreeBSD's reimplementation of the API [used to ]lack[s] this function. # It has been added in r234193, but is lacking in default 9.x install as # of this change. Provide a fallback to error-out only if actually used. # pylint: disable=unused-argument def libusb_get_max_iso_packet_size(_, __): raise NotImplementedError # pylint: enable=unused-argument else: 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] try: #int libusb_set_auto_detach_kernel_driver( # libusb_device_handle *dev, int enable); libusb_set_auto_detach_kernel_driver = \ libusb.libusb_set_auto_detach_kernel_driver except AttributeError: pass else: libusb_set_auto_detach_kernel_driver.argtypes = [ libusb_device_handle_p, c_int] libusb_set_auto_detach_kernel_driver.restype = 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 # pylint: disable=redefined-builtin 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 # pylint: disable=undefined-variable transfer.type = LIBUSB_TRANSFER_TYPE_CONTROL # pylint: enable=undefined-variable transfer.timeout = timeout transfer.buffer = cast(buffer, c_void_p) if buffer is not None: setup = cast(buffer, libusb_control_setup_p).contents # pylint: disable=undefined-variable transfer.length = LIBUSB_CONTROL_SETUP_SIZE + \ libusb_le16_to_cpu(setup.wLength) # pylint: enable=undefined-variable transfer.user_data = user_data transfer.callback = callback # pylint: enable=redefined-builtin # pylint: disable=redefined-builtin 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 # pylint: disable=undefined-variable transfer.type = LIBUSB_TRANSFER_TYPE_BULK # pylint: enable=undefined-variable transfer.timeout = timeout transfer.buffer = cast(buffer, c_void_p) transfer.length = length transfer.user_data = user_data transfer.callback = callback # pylint: enable=redefined-builtin # pylint: disable=redefined-builtin 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 # pylint: disable=undefined-variable transfer.type = LIBUSB_TRANSFER_TYPE_INTERRUPT # pylint: enable=undefined-variable transfer.timeout = timeout transfer.buffer = cast(buffer, c_void_p) transfer.length = length transfer.user_data = user_data transfer.callback = callback # pylint: enable=redefined-builtin # pylint: disable=redefined-builtin 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 # pylint: disable=undefined-variable transfer.type = LIBUSB_TRANSFER_TYPE_ISOCHRONOUS # pylint: enable=undefined-variable 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 # pylint: enable=redefined-builtin 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(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 = _string_item_to_int(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] # pylint: disable=undefined-variable 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) # pylint: enable=undefined-variable # pylint: disable=undefined-variable 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) # pylint: enable=undefined-variable #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_timeout_completed(libusb_context *ctx, # struct timeval *tv, int *completed); try: libusb_handle_events_timeout_completed = libusb.\ libusb_handle_events_timeout_completed except AttributeError: # No safe replacement possible. pass else: libusb_handle_events_timeout_completed.argtypes = [ libusb_context_p, timeval_p, c_int_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_completed(libusb_context *ctx, int *completed); try: libusb_handle_events_completed = libusb.libusb_handle_events_completed except AttributeError: # No safe replacement possible. pass else: libusb_handle_events_completed.argtypes = [libusb_context_p, c_int_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 #typedef int libusb_hotplug_callback_handle; libusb_hotplug_callback_handle = c_int libusb_hotplug_flag = Enum({ 'LIBUSB_HOTPLUG_ENUMERATE': 1, }) libusb_hotplug_event = Enum({ 'LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED': 0x01, 'LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT': 0x02, }) LIBUSB_HOTPLUG_MATCH_ANY = -1 #typedef int (*libusb_hotplug_callback_fn)(libusb_context *ctx, # libusb_device *device, libusb_hotplug_event event, void *user_data); libusb_hotplug_callback_fn_p = CFUNCTYPE( c_int, libusb_context_p, libusb_device_p, c_int, c_void_p) #int libusb_hotplug_register_callback(libusb_context *ctx, # libusb_hotplug_event events, libusb_hotplug_flag flags, # int vendor_id, int product_id, int dev_class, # libusb_hotplug_callback_fn cb_fn, void *user_data, # libusb_hotplug_callback_handle *handle); try: libusb_hotplug_register_callback = libusb.libusb_hotplug_register_callback except AttributeError: pass else: libusb_hotplug_register_callback.argtypes = [ libusb_context_p, c_int, c_int, c_int, c_int, c_int, libusb_hotplug_callback_fn_p, c_void_p, POINTER(libusb_hotplug_callback_handle), ] libusb_hotplug_register_callback.restype = c_int #void libusb_hotplug_deregister_callback(libusb_context *ctx, # libusb_hotplug_callback_handle handle); try: libusb_hotplug_deregister_callback = \ libusb.libusb_hotplug_deregister_callback except AttributeError: pass else: libusb_hotplug_deregister_callback.argtypes = [ libusb_context_p, libusb_hotplug_callback_handle, ] libusb_hotplug_deregister_callback.restype = None # /libusb.h