sadmen
/
openpilot_comma
mirror of https://github.com/commaai/openpilot.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
openpilot is an open source driver assistance system. openpilot performs the functions of Automated Lane Centering and Adaptive Cruise Control for over 200 supported car makes and models.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6 Commits
38 Branches
82 Tags
6.1 GiB
 
 
 
 
 
 
Tag: Branch: Tree: b8f90a7a15
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'b8f90a7a15'
${ noResults }
openpilot_comma/tinygrad_repo/tinygrad/runtime/autogen/libusb.py

1643 lines
66 KiB
Raw Blame History

# mypy: ignore-errors
# -*- coding: utf-8 -*-
#
# TARGET arch is: []
# WORD_SIZE is: 8
# POINTER_SIZE is: 8
# LONGDOUBLE_SIZE is: 16
#
import ctypes, os
class FunctionFactoryStub:
def __getattr__(self, _):
return ctypes.CFUNCTYPE(lambda y:y)
# libraries['libusb'] explanation
# As you did not list (-l libraryname.so) a library that exports this function
# This is a non-working stub instead.
# You can either re-run clan2py with -l /path/to/library.so
# Or manually fix this by comment the ctypes.CDLL loading
_libraries = {}
_libraries['libusb'] = None if (lib_path:=os.getenv('LIBUSB_PATH', ctypes.util.find_library('usb-1.0'))) is None else ctypes.CDLL(lib_path) # ctypes.CDLL('libusb')
class AsDictMixin:
@classmethod
def as_dict(cls, self):
result = {}
if not isinstance(self, AsDictMixin):
# not a structure, assume it's already a python object
return self
if not hasattr(cls, "_fields_"):
return result
# sys.version_info >= (3, 5)
# for (field, *_) in cls._fields_: # noqa
for field_tuple in cls._fields_: # noqa
field = field_tuple[0]
if field.startswith('PADDING_'):
continue
value = getattr(self, field)
type_ = type(value)
if hasattr(value, "_length_") and hasattr(value, "_type_"):
# array
if not hasattr(type_, "as_dict"):
value = [v for v in value]
else:
type_ = type_._type_
value = [type_.as_dict(v) for v in value]
elif hasattr(value, "contents") and hasattr(value, "_type_"):
# pointer
try:
if not hasattr(type_, "as_dict"):
value = value.contents
else:
type_ = type_._type_
value = type_.as_dict(value.contents)
except ValueError:
# nullptr
value = None
elif isinstance(value, AsDictMixin):
# other structure
value = type_.as_dict(value)
result[field] = value
return result
class Structure(ctypes.Structure, AsDictMixin):
def __init__(self, *args, **kwds):
# We don't want to use positional arguments fill PADDING_* fields
args = dict(zip(self.__class__._field_names_(), args))
args.update(kwds)
super(Structure, self).__init__(**args)
@classmethod
def _field_names_(cls):
if hasattr(cls, '_fields_'):
return (f[0] for f in cls._fields_ if not f[0].startswith('PADDING'))
else:
return ()
@classmethod
def get_type(cls, field):
for f in cls._fields_:
if f[0] == field:
return f[1]
return None
@classmethod
def bind(cls, bound_fields):
fields = {}
for name, type_ in cls._fields_:
if hasattr(type_, "restype"):
if name in bound_fields:
if bound_fields[name] is None:
fields[name] = type_()
else:
# use a closure to capture the callback from the loop scope
fields[name] = (
type_((lambda callback: lambda *args: callback(*args))(
bound_fields[name]))
)
del bound_fields[name]
else:
# default callback implementation (does nothing)
try:
default_ = type_(0).restype().value
except TypeError:
default_ = None
fields[name] = type_((
lambda default_: lambda *args: default_)(default_))
else:
# not a callback function, use default initialization
if name in bound_fields:
fields[name] = bound_fields[name]
del bound_fields[name]
else:
fields[name] = type_()
if len(bound_fields) != 0:
raise ValueError(
"Cannot bind the following unknown callback(s) {}.{}".format(
cls.__name__, bound_fields.keys()
))
return cls(**fields)
class Union(ctypes.Union, AsDictMixin):
pass
def string_cast(char_pointer, encoding='utf-8', errors='strict'):
value = ctypes.cast(char_pointer, ctypes.c_char_p).value
if value is not None and encoding is not None:
value = value.decode(encoding, errors=errors)
return value
def char_pointer_cast(string, encoding='utf-8'):
if encoding is not None:
try:
string = string.encode(encoding)
except AttributeError:
# In Python3, bytes has no encode attribute
pass
string = ctypes.c_char_p(string)
return ctypes.cast(string, ctypes.POINTER(ctypes.c_char))
c_int128 = ctypes.c_ubyte*16
c_uint128 = c_int128
void = None
if ctypes.sizeof(ctypes.c_longdouble) == 16:
c_long_double_t = ctypes.c_longdouble
else:
c_long_double_t = ctypes.c_ubyte*16
LIBUSB_H = True # macro
ZERO_SIZED_ARRAY = True # macro
# def LIBUSB_DEPRECATED_FOR(f): # macro
# return ((deprecated))
# LIBUSB_PACKED = ((packed)) # macro
LIBUSB_CALL = True # macro
LIBUSB_API_VERSION = 0x01000109 # macro
LIBUSBX_API_VERSION = 0x01000109 # macro
LIBUSB_DT_DEVICE_SIZE = 18 # macro
LIBUSB_DT_CONFIG_SIZE = 9 # macro
LIBUSB_DT_INTERFACE_SIZE = 9 # macro
LIBUSB_DT_ENDPOINT_SIZE = 7 # macro
LIBUSB_DT_ENDPOINT_AUDIO_SIZE = 9 # macro
LIBUSB_DT_HUB_NONVAR_SIZE = 7 # macro
LIBUSB_DT_SS_ENDPOINT_COMPANION_SIZE = 6 # macro
LIBUSB_DT_BOS_SIZE = 5 # macro
LIBUSB_DT_DEVICE_CAPABILITY_SIZE = 3 # macro
LIBUSB_BT_USB_2_0_EXTENSION_SIZE = 7 # macro
LIBUSB_BT_SS_USB_DEVICE_CAPABILITY_SIZE = 10 # macro
LIBUSB_BT_CONTAINER_ID_SIZE = 20 # macro
LIBUSB_DT_BOS_MAX_SIZE = (5+7+10+20) # macro
LIBUSB_ENDPOINT_ADDRESS_MASK = 0x0f # macro
LIBUSB_ENDPOINT_DIR_MASK = 0x80 # macro
LIBUSB_TRANSFER_TYPE_MASK = 0x03 # macro
LIBUSB_ISO_SYNC_TYPE_MASK = 0x0c # macro
LIBUSB_ISO_USAGE_TYPE_MASK = 0x30 # macro
LIBUSB_ERROR_COUNT = 14 # macro
LIBUSB_HOTPLUG_NO_FLAGS = 0 # macro
LIBUSB_HOTPLUG_MATCH_ANY = -1 # macro
uint16_t = ctypes.c_uint16
try:
libusb_cpu_to_le16 = _libraries['libusb'].libusb_cpu_to_le16
libusb_cpu_to_le16.restype = uint16_t
libusb_cpu_to_le16.argtypes = [uint16_t]
except AttributeError:
pass
# macro
# values for enumeration 'libusb_class_code'
libusb_class_code__enumvalues = {
0: 'LIBUSB_CLASS_PER_INTERFACE',
1: 'LIBUSB_CLASS_AUDIO',
2: 'LIBUSB_CLASS_COMM',
3: 'LIBUSB_CLASS_HID',
5: 'LIBUSB_CLASS_PHYSICAL',
6: 'LIBUSB_CLASS_IMAGE',
6: 'LIBUSB_CLASS_PTP',
7: 'LIBUSB_CLASS_PRINTER',
8: 'LIBUSB_CLASS_MASS_STORAGE',
9: 'LIBUSB_CLASS_HUB',
10: 'LIBUSB_CLASS_DATA',
11: 'LIBUSB_CLASS_SMART_CARD',
13: 'LIBUSB_CLASS_CONTENT_SECURITY',
14: 'LIBUSB_CLASS_VIDEO',
15: 'LIBUSB_CLASS_PERSONAL_HEALTHCARE',
220: 'LIBUSB_CLASS_DIAGNOSTIC_DEVICE',
224: 'LIBUSB_CLASS_WIRELESS',
239: 'LIBUSB_CLASS_MISCELLANEOUS',
254: 'LIBUSB_CLASS_APPLICATION',
255: 'LIBUSB_CLASS_VENDOR_SPEC',
}
LIBUSB_CLASS_PER_INTERFACE = 0
LIBUSB_CLASS_AUDIO = 1
LIBUSB_CLASS_COMM = 2
LIBUSB_CLASS_HID = 3
LIBUSB_CLASS_PHYSICAL = 5
LIBUSB_CLASS_IMAGE = 6
LIBUSB_CLASS_PTP = 6
LIBUSB_CLASS_PRINTER = 7
LIBUSB_CLASS_MASS_STORAGE = 8
LIBUSB_CLASS_HUB = 9
LIBUSB_CLASS_DATA = 10
LIBUSB_CLASS_SMART_CARD = 11
LIBUSB_CLASS_CONTENT_SECURITY = 13
LIBUSB_CLASS_VIDEO = 14
LIBUSB_CLASS_PERSONAL_HEALTHCARE = 15
LIBUSB_CLASS_DIAGNOSTIC_DEVICE = 220
LIBUSB_CLASS_WIRELESS = 224
LIBUSB_CLASS_MISCELLANEOUS = 239
LIBUSB_CLASS_APPLICATION = 254
LIBUSB_CLASS_VENDOR_SPEC = 255
libusb_class_code = ctypes.c_uint32 # enum
# values for enumeration 'libusb_descriptor_type'
libusb_descriptor_type__enumvalues = {
1: 'LIBUSB_DT_DEVICE',
2: 'LIBUSB_DT_CONFIG',
3: 'LIBUSB_DT_STRING',
4: 'LIBUSB_DT_INTERFACE',
5: 'LIBUSB_DT_ENDPOINT',
15: 'LIBUSB_DT_BOS',
16: 'LIBUSB_DT_DEVICE_CAPABILITY',
33: 'LIBUSB_DT_HID',
34: 'LIBUSB_DT_REPORT',
35: 'LIBUSB_DT_PHYSICAL',
41: 'LIBUSB_DT_HUB',
42: 'LIBUSB_DT_SUPERSPEED_HUB',
48: 'LIBUSB_DT_SS_ENDPOINT_COMPANION',
}
LIBUSB_DT_DEVICE = 1
LIBUSB_DT_CONFIG = 2
LIBUSB_DT_STRING = 3
LIBUSB_DT_INTERFACE = 4
LIBUSB_DT_ENDPOINT = 5
LIBUSB_DT_BOS = 15
LIBUSB_DT_DEVICE_CAPABILITY = 16
LIBUSB_DT_HID = 33
LIBUSB_DT_REPORT = 34
LIBUSB_DT_PHYSICAL = 35
LIBUSB_DT_HUB = 41
LIBUSB_DT_SUPERSPEED_HUB = 42
LIBUSB_DT_SS_ENDPOINT_COMPANION = 48
libusb_descriptor_type = ctypes.c_uint32 # enum
# values for enumeration 'libusb_endpoint_direction'
libusb_endpoint_direction__enumvalues = {
0: 'LIBUSB_ENDPOINT_OUT',
128: 'LIBUSB_ENDPOINT_IN',
}
LIBUSB_ENDPOINT_OUT = 0
LIBUSB_ENDPOINT_IN = 128
libusb_endpoint_direction = ctypes.c_uint32 # enum
# values for enumeration 'libusb_endpoint_transfer_type'
libusb_endpoint_transfer_type__enumvalues = {
0: 'LIBUSB_ENDPOINT_TRANSFER_TYPE_CONTROL',
1: 'LIBUSB_ENDPOINT_TRANSFER_TYPE_ISOCHRONOUS',
2: 'LIBUSB_ENDPOINT_TRANSFER_TYPE_BULK',
3: 'LIBUSB_ENDPOINT_TRANSFER_TYPE_INTERRUPT',
}
LIBUSB_ENDPOINT_TRANSFER_TYPE_CONTROL = 0
LIBUSB_ENDPOINT_TRANSFER_TYPE_ISOCHRONOUS = 1
LIBUSB_ENDPOINT_TRANSFER_TYPE_BULK = 2
LIBUSB_ENDPOINT_TRANSFER_TYPE_INTERRUPT = 3
libusb_endpoint_transfer_type = ctypes.c_uint32 # enum
# values for enumeration 'libusb_standard_request'
libusb_standard_request__enumvalues = {
0: 'LIBUSB_REQUEST_GET_STATUS',
1: 'LIBUSB_REQUEST_CLEAR_FEATURE',
3: 'LIBUSB_REQUEST_SET_FEATURE',
5: 'LIBUSB_REQUEST_SET_ADDRESS',
6: 'LIBUSB_REQUEST_GET_DESCRIPTOR',
7: 'LIBUSB_REQUEST_SET_DESCRIPTOR',
8: 'LIBUSB_REQUEST_GET_CONFIGURATION',
9: 'LIBUSB_REQUEST_SET_CONFIGURATION',
10: 'LIBUSB_REQUEST_GET_INTERFACE',
11: 'LIBUSB_REQUEST_SET_INTERFACE',
12: 'LIBUSB_REQUEST_SYNCH_FRAME',
48: 'LIBUSB_REQUEST_SET_SEL',
49: 'LIBUSB_SET_ISOCH_DELAY',
}
LIBUSB_REQUEST_GET_STATUS = 0
LIBUSB_REQUEST_CLEAR_FEATURE = 1
LIBUSB_REQUEST_SET_FEATURE = 3
LIBUSB_REQUEST_SET_ADDRESS = 5
LIBUSB_REQUEST_GET_DESCRIPTOR = 6
LIBUSB_REQUEST_SET_DESCRIPTOR = 7
LIBUSB_REQUEST_GET_CONFIGURATION = 8
LIBUSB_REQUEST_SET_CONFIGURATION = 9
LIBUSB_REQUEST_GET_INTERFACE = 10
LIBUSB_REQUEST_SET_INTERFACE = 11
LIBUSB_REQUEST_SYNCH_FRAME = 12
LIBUSB_REQUEST_SET_SEL = 48
LIBUSB_SET_ISOCH_DELAY = 49
libusb_standard_request = ctypes.c_uint32 # enum
# values for enumeration 'libusb_request_type'
libusb_request_type__enumvalues = {
0: 'LIBUSB_REQUEST_TYPE_STANDARD',
32: 'LIBUSB_REQUEST_TYPE_CLASS',
64: 'LIBUSB_REQUEST_TYPE_VENDOR',
96: 'LIBUSB_REQUEST_TYPE_RESERVED',
}
LIBUSB_REQUEST_TYPE_STANDARD = 0
LIBUSB_REQUEST_TYPE_CLASS = 32
LIBUSB_REQUEST_TYPE_VENDOR = 64
LIBUSB_REQUEST_TYPE_RESERVED = 96
libusb_request_type = ctypes.c_uint32 # enum
# values for enumeration 'libusb_request_recipient'
libusb_request_recipient__enumvalues = {
0: 'LIBUSB_RECIPIENT_DEVICE',
1: 'LIBUSB_RECIPIENT_INTERFACE',
2: 'LIBUSB_RECIPIENT_ENDPOINT',
3: 'LIBUSB_RECIPIENT_OTHER',
}
LIBUSB_RECIPIENT_DEVICE = 0
LIBUSB_RECIPIENT_INTERFACE = 1
LIBUSB_RECIPIENT_ENDPOINT = 2
LIBUSB_RECIPIENT_OTHER = 3
libusb_request_recipient = ctypes.c_uint32 # enum
# values for enumeration 'libusb_iso_sync_type'
libusb_iso_sync_type__enumvalues = {
0: 'LIBUSB_ISO_SYNC_TYPE_NONE',
1: 'LIBUSB_ISO_SYNC_TYPE_ASYNC',
2: 'LIBUSB_ISO_SYNC_TYPE_ADAPTIVE',
3: 'LIBUSB_ISO_SYNC_TYPE_SYNC',
}
LIBUSB_ISO_SYNC_TYPE_NONE = 0
LIBUSB_ISO_SYNC_TYPE_ASYNC = 1
LIBUSB_ISO_SYNC_TYPE_ADAPTIVE = 2
LIBUSB_ISO_SYNC_TYPE_SYNC = 3
libusb_iso_sync_type = ctypes.c_uint32 # enum
# values for enumeration 'libusb_iso_usage_type'
libusb_iso_usage_type__enumvalues = {
0: 'LIBUSB_ISO_USAGE_TYPE_DATA',
1: 'LIBUSB_ISO_USAGE_TYPE_FEEDBACK',
2: 'LIBUSB_ISO_USAGE_TYPE_IMPLICIT',
}
LIBUSB_ISO_USAGE_TYPE_DATA = 0
LIBUSB_ISO_USAGE_TYPE_FEEDBACK = 1
LIBUSB_ISO_USAGE_TYPE_IMPLICIT = 2
libusb_iso_usage_type = ctypes.c_uint32 # enum
# values for enumeration 'libusb_supported_speed'
libusb_supported_speed__enumvalues = {
1: 'LIBUSB_LOW_SPEED_OPERATION',
2: 'LIBUSB_FULL_SPEED_OPERATION',
4: 'LIBUSB_HIGH_SPEED_OPERATION',
8: 'LIBUSB_SUPER_SPEED_OPERATION',
}
LIBUSB_LOW_SPEED_OPERATION = 1
LIBUSB_FULL_SPEED_OPERATION = 2
LIBUSB_HIGH_SPEED_OPERATION = 4
LIBUSB_SUPER_SPEED_OPERATION = 8
libusb_supported_speed = ctypes.c_uint32 # enum
# values for enumeration 'libusb_usb_2_0_extension_attributes'
libusb_usb_2_0_extension_attributes__enumvalues = {
2: 'LIBUSB_BM_LPM_SUPPORT',
}
LIBUSB_BM_LPM_SUPPORT = 2
libusb_usb_2_0_extension_attributes = ctypes.c_uint32 # enum
# values for enumeration 'libusb_ss_usb_device_capability_attributes'
libusb_ss_usb_device_capability_attributes__enumvalues = {
2: 'LIBUSB_BM_LTM_SUPPORT',
}
LIBUSB_BM_LTM_SUPPORT = 2
libusb_ss_usb_device_capability_attributes = ctypes.c_uint32 # enum
# values for enumeration 'libusb_bos_type'
libusb_bos_type__enumvalues = {
1: 'LIBUSB_BT_WIRELESS_USB_DEVICE_CAPABILITY',
2: 'LIBUSB_BT_USB_2_0_EXTENSION',
3: 'LIBUSB_BT_SS_USB_DEVICE_CAPABILITY',
4: 'LIBUSB_BT_CONTAINER_ID',
}
LIBUSB_BT_WIRELESS_USB_DEVICE_CAPABILITY = 1
LIBUSB_BT_USB_2_0_EXTENSION = 2
LIBUSB_BT_SS_USB_DEVICE_CAPABILITY = 3
LIBUSB_BT_CONTAINER_ID = 4
libusb_bos_type = ctypes.c_uint32 # enum
class struct_libusb_device_descriptor(Structure):
pass
struct_libusb_device_descriptor._pack_ = 1 # source:False
struct_libusb_device_descriptor._fields_ = [
('bLength', ctypes.c_ubyte),
('bDescriptorType', ctypes.c_ubyte),
('bcdUSB', ctypes.c_uint16),
('bDeviceClass', ctypes.c_ubyte),
('bDeviceSubClass', ctypes.c_ubyte),
('bDeviceProtocol', ctypes.c_ubyte),
('bMaxPacketSize0', ctypes.c_ubyte),
('idVendor', ctypes.c_uint16),
('idProduct', ctypes.c_uint16),
('bcdDevice', ctypes.c_uint16),
('iManufacturer', ctypes.c_ubyte),
('iProduct', ctypes.c_ubyte),
('iSerialNumber', ctypes.c_ubyte),
('bNumConfigurations', ctypes.c_ubyte),
]
class struct_libusb_endpoint_descriptor(Structure):
pass
struct_libusb_endpoint_descriptor._pack_ = 1 # source:False
struct_libusb_endpoint_descriptor._fields_ = [
('bLength', ctypes.c_ubyte),
('bDescriptorType', ctypes.c_ubyte),
('bEndpointAddress', ctypes.c_ubyte),
('bmAttributes', ctypes.c_ubyte),
('wMaxPacketSize', ctypes.c_uint16),
('bInterval', ctypes.c_ubyte),
('bRefresh', ctypes.c_ubyte),
('bSynchAddress', ctypes.c_ubyte),
('PADDING_0', ctypes.c_ubyte * 7),
('extra', ctypes.POINTER(ctypes.c_ubyte)),
('extra_length', ctypes.c_int32),
('PADDING_1', ctypes.c_ubyte * 4),
]
class struct_libusb_interface_descriptor(Structure):
pass
struct_libusb_interface_descriptor._pack_ = 1 # source:False
struct_libusb_interface_descriptor._fields_ = [
('bLength', ctypes.c_ubyte),
('bDescriptorType', ctypes.c_ubyte),
('bInterfaceNumber', ctypes.c_ubyte),
('bAlternateSetting', ctypes.c_ubyte),
('bNumEndpoints', ctypes.c_ubyte),
('bInterfaceClass', ctypes.c_ubyte),
('bInterfaceSubClass', ctypes.c_ubyte),
('bInterfaceProtocol', ctypes.c_ubyte),
('iInterface', ctypes.c_ubyte),
('PADDING_0', ctypes.c_ubyte * 7),
('endpoint', ctypes.POINTER(struct_libusb_endpoint_descriptor)),
('extra', ctypes.POINTER(ctypes.c_ubyte)),
('extra_length', ctypes.c_int32),
('PADDING_1', ctypes.c_ubyte * 4),
]
class struct_libusb_interface(Structure):
pass
struct_libusb_interface._pack_ = 1 # source:False
struct_libusb_interface._fields_ = [
('altsetting', ctypes.POINTER(struct_libusb_interface_descriptor)),
('num_altsetting', ctypes.c_int32),
('PADDING_0', ctypes.c_ubyte * 4),
]
class struct_libusb_config_descriptor(Structure):
pass
struct_libusb_config_descriptor._pack_ = 1 # source:False
struct_libusb_config_descriptor._fields_ = [
('bLength', ctypes.c_ubyte),
('bDescriptorType', ctypes.c_ubyte),
('wTotalLength', ctypes.c_uint16),
('bNumInterfaces', ctypes.c_ubyte),
('bConfigurationValue', ctypes.c_ubyte),
('iConfiguration', ctypes.c_ubyte),
('bmAttributes', ctypes.c_ubyte),
('MaxPower', ctypes.c_ubyte),
('PADDING_0', ctypes.c_ubyte * 7),
('interface', ctypes.POINTER(struct_libusb_interface)),
('extra', ctypes.POINTER(ctypes.c_ubyte)),
('extra_length', ctypes.c_int32),
('PADDING_1', ctypes.c_ubyte * 4),
]
class struct_libusb_ss_endpoint_companion_descriptor(Structure):
pass
struct_libusb_ss_endpoint_companion_descriptor._pack_ = 1 # source:False
struct_libusb_ss_endpoint_companion_descriptor._fields_ = [
('bLength', ctypes.c_ubyte),
('bDescriptorType', ctypes.c_ubyte),
('bMaxBurst', ctypes.c_ubyte),
('bmAttributes', ctypes.c_ubyte),
('wBytesPerInterval', ctypes.c_uint16),
]
class struct_libusb_bos_dev_capability_descriptor(Structure):
pass
struct_libusb_bos_dev_capability_descriptor._pack_ = 1 # source:False
struct_libusb_bos_dev_capability_descriptor._fields_ = [
('bLength', ctypes.c_ubyte),
('bDescriptorType', ctypes.c_ubyte),
('bDevCapabilityType', ctypes.c_ubyte),
('dev_capability_data', ctypes.c_ubyte * 0),
]
class struct_libusb_bos_descriptor(Structure):
pass
struct_libusb_bos_descriptor._pack_ = 1 # source:False
struct_libusb_bos_descriptor._fields_ = [
('bLength', ctypes.c_ubyte),
('bDescriptorType', ctypes.c_ubyte),
('wTotalLength', ctypes.c_uint16),
('bNumDeviceCaps', ctypes.c_ubyte),
('PADDING_0', ctypes.c_ubyte * 3),
('dev_capability', ctypes.POINTER(struct_libusb_bos_dev_capability_descriptor) * 0),
]
class struct_libusb_usb_2_0_extension_descriptor(Structure):
pass
struct_libusb_usb_2_0_extension_descriptor._pack_ = 1 # source:False
struct_libusb_usb_2_0_extension_descriptor._fields_ = [
('bLength', ctypes.c_ubyte),
('bDescriptorType', ctypes.c_ubyte),
('bDevCapabilityType', ctypes.c_ubyte),
('PADDING_0', ctypes.c_ubyte),
('bmAttributes', ctypes.c_uint32),
]
class struct_libusb_ss_usb_device_capability_descriptor(Structure):
pass
struct_libusb_ss_usb_device_capability_descriptor._pack_ = 1 # source:False
struct_libusb_ss_usb_device_capability_descriptor._fields_ = [
('bLength', ctypes.c_ubyte),
('bDescriptorType', ctypes.c_ubyte),
('bDevCapabilityType', ctypes.c_ubyte),
('bmAttributes', ctypes.c_ubyte),
('wSpeedSupported', ctypes.c_uint16),
('bFunctionalitySupport', ctypes.c_ubyte),
('bU1DevExitLat', ctypes.c_ubyte),
('bU2DevExitLat', ctypes.c_uint16),
]
class struct_libusb_container_id_descriptor(Structure):
pass
struct_libusb_container_id_descriptor._pack_ = 1 # source:False
struct_libusb_container_id_descriptor._fields_ = [
('bLength', ctypes.c_ubyte),
('bDescriptorType', ctypes.c_ubyte),
('bDevCapabilityType', ctypes.c_ubyte),
('bReserved', ctypes.c_ubyte),
('ContainerID', ctypes.c_ubyte * 16),
]
class struct_libusb_control_setup(Structure):
pass
struct_libusb_control_setup._pack_ = 1 # source:True
struct_libusb_control_setup._fields_ = [
('bmRequestType', ctypes.c_ubyte),
('bRequest', ctypes.c_ubyte),
('wValue', ctypes.c_uint16),
('wIndex', ctypes.c_uint16),
('wLength', ctypes.c_uint16),
]
# LIBUSB_CONTROL_SETUP_SIZE = (ctypes.sizeof(struct_libusb_control_setup)) # macro
class struct_libusb_context(Structure):
pass
class struct_libusb_device(Structure):
pass
class struct_libusb_device_handle(Structure):
pass
class struct_libusb_version(Structure):
pass
struct_libusb_version._pack_ = 1 # source:False
struct_libusb_version._fields_ = [
('major', ctypes.c_uint16),
('minor', ctypes.c_uint16),
('micro', ctypes.c_uint16),
('nano', ctypes.c_uint16),
('rc', ctypes.POINTER(ctypes.c_char)),
('describe', ctypes.POINTER(ctypes.c_char)),
]
libusb_context = struct_libusb_context
libusb_device = struct_libusb_device
libusb_device_handle = struct_libusb_device_handle
# values for enumeration 'libusb_speed'
libusb_speed__enumvalues = {
0: 'LIBUSB_SPEED_UNKNOWN',
1: 'LIBUSB_SPEED_LOW',
2: 'LIBUSB_SPEED_FULL',
3: 'LIBUSB_SPEED_HIGH',
4: 'LIBUSB_SPEED_SUPER',
5: 'LIBUSB_SPEED_SUPER_PLUS',
}
LIBUSB_SPEED_UNKNOWN = 0
LIBUSB_SPEED_LOW = 1
LIBUSB_SPEED_FULL = 2
LIBUSB_SPEED_HIGH = 3
LIBUSB_SPEED_SUPER = 4
LIBUSB_SPEED_SUPER_PLUS = 5
libusb_speed = ctypes.c_uint32 # enum
# values for enumeration 'libusb_error'
libusb_error__enumvalues = {
0: 'LIBUSB_SUCCESS',
-1: 'LIBUSB_ERROR_IO',
-2: 'LIBUSB_ERROR_INVALID_PARAM',
-3: 'LIBUSB_ERROR_ACCESS',
-4: 'LIBUSB_ERROR_NO_DEVICE',
-5: 'LIBUSB_ERROR_NOT_FOUND',
-6: 'LIBUSB_ERROR_BUSY',
-7: 'LIBUSB_ERROR_TIMEOUT',
-8: 'LIBUSB_ERROR_OVERFLOW',
-9: 'LIBUSB_ERROR_PIPE',
-10: 'LIBUSB_ERROR_INTERRUPTED',
-11: 'LIBUSB_ERROR_NO_MEM',
-12: 'LIBUSB_ERROR_NOT_SUPPORTED',
-99: 'LIBUSB_ERROR_OTHER',
}
LIBUSB_SUCCESS = 0
LIBUSB_ERROR_IO = -1
LIBUSB_ERROR_INVALID_PARAM = -2
LIBUSB_ERROR_ACCESS = -3
LIBUSB_ERROR_NO_DEVICE = -4
LIBUSB_ERROR_NOT_FOUND = -5
LIBUSB_ERROR_BUSY = -6
LIBUSB_ERROR_TIMEOUT = -7
LIBUSB_ERROR_OVERFLOW = -8
LIBUSB_ERROR_PIPE = -9
LIBUSB_ERROR_INTERRUPTED = -10
LIBUSB_ERROR_NO_MEM = -11
LIBUSB_ERROR_NOT_SUPPORTED = -12
LIBUSB_ERROR_OTHER = -99
libusb_error = ctypes.c_int32 # enum
# values for enumeration 'libusb_transfer_type'
libusb_transfer_type__enumvalues = {
0: 'LIBUSB_TRANSFER_TYPE_CONTROL',
1: 'LIBUSB_TRANSFER_TYPE_ISOCHRONOUS',
2: 'LIBUSB_TRANSFER_TYPE_BULK',
3: 'LIBUSB_TRANSFER_TYPE_INTERRUPT',
4: 'LIBUSB_TRANSFER_TYPE_BULK_STREAM',
}
LIBUSB_TRANSFER_TYPE_CONTROL = 0
LIBUSB_TRANSFER_TYPE_ISOCHRONOUS = 1
LIBUSB_TRANSFER_TYPE_BULK = 2
LIBUSB_TRANSFER_TYPE_INTERRUPT = 3
LIBUSB_TRANSFER_TYPE_BULK_STREAM = 4
libusb_transfer_type = ctypes.c_uint32 # enum
# values for enumeration 'libusb_transfer_status'
libusb_transfer_status__enumvalues = {
0: 'LIBUSB_TRANSFER_COMPLETED',
1: 'LIBUSB_TRANSFER_ERROR',
2: 'LIBUSB_TRANSFER_TIMED_OUT',
3: 'LIBUSB_TRANSFER_CANCELLED',
4: 'LIBUSB_TRANSFER_STALL',
5: 'LIBUSB_TRANSFER_NO_DEVICE',
6: 'LIBUSB_TRANSFER_OVERFLOW',
}
LIBUSB_TRANSFER_COMPLETED = 0
LIBUSB_TRANSFER_ERROR = 1
LIBUSB_TRANSFER_TIMED_OUT = 2
LIBUSB_TRANSFER_CANCELLED = 3
LIBUSB_TRANSFER_STALL = 4
LIBUSB_TRANSFER_NO_DEVICE = 5
LIBUSB_TRANSFER_OVERFLOW = 6
libusb_transfer_status = ctypes.c_uint32 # enum
# values for enumeration 'libusb_transfer_flags'
libusb_transfer_flags__enumvalues = {
1: 'LIBUSB_TRANSFER_SHORT_NOT_OK',
2: 'LIBUSB_TRANSFER_FREE_BUFFER',
4: 'LIBUSB_TRANSFER_FREE_TRANSFER',
8: 'LIBUSB_TRANSFER_ADD_ZERO_PACKET',
}
LIBUSB_TRANSFER_SHORT_NOT_OK = 1
LIBUSB_TRANSFER_FREE_BUFFER = 2
LIBUSB_TRANSFER_FREE_TRANSFER = 4
LIBUSB_TRANSFER_ADD_ZERO_PACKET = 8
libusb_transfer_flags = ctypes.c_uint32 # enum
class struct_libusb_iso_packet_descriptor(Structure):
pass
struct_libusb_iso_packet_descriptor._pack_ = 1 # source:False
struct_libusb_iso_packet_descriptor._fields_ = [
('length', ctypes.c_uint32),
('actual_length', ctypes.c_uint32),
('status', libusb_transfer_status),
]
class struct_libusb_transfer(Structure):
pass
libusb_transfer_cb_fn = ctypes.CFUNCTYPE(None, ctypes.POINTER(struct_libusb_transfer))
# values for enumeration 'libusb_capability'
libusb_capability__enumvalues = {
0: 'LIBUSB_CAP_HAS_CAPABILITY',
1: 'LIBUSB_CAP_HAS_HOTPLUG',
256: 'LIBUSB_CAP_HAS_HID_ACCESS',
257: 'LIBUSB_CAP_SUPPORTS_DETACH_KERNEL_DRIVER',
}
LIBUSB_CAP_HAS_CAPABILITY = 0
LIBUSB_CAP_HAS_HOTPLUG = 1
LIBUSB_CAP_HAS_HID_ACCESS = 256
LIBUSB_CAP_SUPPORTS_DETACH_KERNEL_DRIVER = 257
libusb_capability = ctypes.c_uint32 # enum
# values for enumeration 'libusb_log_level'
libusb_log_level__enumvalues = {
0: 'LIBUSB_LOG_LEVEL_NONE',
1: 'LIBUSB_LOG_LEVEL_ERROR',
2: 'LIBUSB_LOG_LEVEL_WARNING',
3: 'LIBUSB_LOG_LEVEL_INFO',
4: 'LIBUSB_LOG_LEVEL_DEBUG',
}
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
libusb_log_level = ctypes.c_uint32 # enum
# values for enumeration 'libusb_log_cb_mode'
libusb_log_cb_mode__enumvalues = {
1: 'LIBUSB_LOG_CB_GLOBAL',
2: 'LIBUSB_LOG_CB_CONTEXT',
}
LIBUSB_LOG_CB_GLOBAL = 1
LIBUSB_LOG_CB_CONTEXT = 2
libusb_log_cb_mode = ctypes.c_uint32 # enum
libusb_log_cb = ctypes.CFUNCTYPE(None, ctypes.POINTER(struct_libusb_context), libusb_log_level, ctypes.POINTER(ctypes.c_char))
try:
libusb_init = _libraries['libusb'].libusb_init
libusb_init.restype = ctypes.c_int32
libusb_init.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_libusb_context))]
except AttributeError:
pass
try:
libusb_exit = _libraries['libusb'].libusb_exit
libusb_exit.restype = None
libusb_exit.argtypes = [ctypes.POINTER(struct_libusb_context)]
except AttributeError:
pass
try:
libusb_set_debug = _libraries['libusb'].libusb_set_debug
libusb_set_debug.restype = None
libusb_set_debug.argtypes = [ctypes.POINTER(struct_libusb_context), ctypes.c_int32]
except AttributeError:
pass
try:
libusb_set_log_cb = _libraries['libusb'].libusb_set_log_cb
libusb_set_log_cb.restype = None
libusb_set_log_cb.argtypes = [ctypes.POINTER(struct_libusb_context), libusb_log_cb, ctypes.c_int32]
except AttributeError:
pass
try:
libusb_get_version = _libraries['libusb'].libusb_get_version
libusb_get_version.restype = ctypes.POINTER(struct_libusb_version)
libusb_get_version.argtypes = []
except AttributeError:
pass
uint32_t = ctypes.c_uint32
try:
libusb_has_capability = _libraries['libusb'].libusb_has_capability
libusb_has_capability.restype = ctypes.c_int32
libusb_has_capability.argtypes = [uint32_t]
except AttributeError:
pass
try:
libusb_error_name = _libraries['libusb'].libusb_error_name
libusb_error_name.restype = ctypes.POINTER(ctypes.c_char)
libusb_error_name.argtypes = [ctypes.c_int32]
except AttributeError:
pass
try:
libusb_setlocale = _libraries['libusb'].libusb_setlocale
libusb_setlocale.restype = ctypes.c_int32
libusb_setlocale.argtypes = [ctypes.POINTER(ctypes.c_char)]
except AttributeError:
pass
try:
libusb_strerror = _libraries['libusb'].libusb_strerror
libusb_strerror.restype = ctypes.POINTER(ctypes.c_char)
libusb_strerror.argtypes = [ctypes.c_int32]
except AttributeError:
pass
ssize_t = ctypes.c_int64
try:
libusb_get_device_list = _libraries['libusb'].libusb_get_device_list
libusb_get_device_list.restype = ssize_t
libusb_get_device_list.argtypes = [ctypes.POINTER(struct_libusb_context), ctypes.POINTER(ctypes.POINTER(ctypes.POINTER(struct_libusb_device)))]
except AttributeError:
pass
try:
libusb_free_device_list = _libraries['libusb'].libusb_free_device_list
libusb_free_device_list.restype = None
libusb_free_device_list.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_libusb_device)), ctypes.c_int32]
except AttributeError:
pass
try:
libusb_ref_device = _libraries['libusb'].libusb_ref_device
libusb_ref_device.restype = ctypes.POINTER(struct_libusb_device)
libusb_ref_device.argtypes = [ctypes.POINTER(struct_libusb_device)]
except AttributeError:
pass
try:
libusb_unref_device = _libraries['libusb'].libusb_unref_device
libusb_unref_device.restype = None
libusb_unref_device.argtypes = [ctypes.POINTER(struct_libusb_device)]
except AttributeError:
pass
try:
libusb_get_configuration = _libraries['libusb'].libusb_get_configuration
libusb_get_configuration.restype = ctypes.c_int32
libusb_get_configuration.argtypes = [ctypes.POINTER(struct_libusb_device_handle), ctypes.POINTER(ctypes.c_int32)]
except AttributeError:
pass
try:
libusb_get_device_descriptor = _libraries['libusb'].libusb_get_device_descriptor
libusb_get_device_descriptor.restype = ctypes.c_int32
libusb_get_device_descriptor.argtypes = [ctypes.POINTER(struct_libusb_device), ctypes.POINTER(struct_libusb_device_descriptor)]
except AttributeError:
pass
try:
libusb_get_active_config_descriptor = _libraries['libusb'].libusb_get_active_config_descriptor
libusb_get_active_config_descriptor.restype = ctypes.c_int32
libusb_get_active_config_descriptor.argtypes = [ctypes.POINTER(struct_libusb_device), ctypes.POINTER(ctypes.POINTER(struct_libusb_config_descriptor))]
except AttributeError:
pass
uint8_t = ctypes.c_uint8
try:
libusb_get_config_descriptor = _libraries['libusb'].libusb_get_config_descriptor
libusb_get_config_descriptor.restype = ctypes.c_int32
libusb_get_config_descriptor.argtypes = [ctypes.POINTER(struct_libusb_device), uint8_t, ctypes.POINTER(ctypes.POINTER(struct_libusb_config_descriptor))]
except AttributeError:
pass
try:
libusb_get_config_descriptor_by_value = _libraries['libusb'].libusb_get_config_descriptor_by_value
libusb_get_config_descriptor_by_value.restype = ctypes.c_int32
libusb_get_config_descriptor_by_value.argtypes = [ctypes.POINTER(struct_libusb_device), uint8_t, ctypes.POINTER(ctypes.POINTER(struct_libusb_config_descriptor))]
except AttributeError:
pass
try:
libusb_free_config_descriptor = _libraries['libusb'].libusb_free_config_descriptor
libusb_free_config_descriptor.restype = None
libusb_free_config_descriptor.argtypes = [ctypes.POINTER(struct_libusb_config_descriptor)]
except AttributeError:
pass
try:
libusb_get_ss_endpoint_companion_descriptor = _libraries['libusb'].libusb_get_ss_endpoint_companion_descriptor
libusb_get_ss_endpoint_companion_descriptor.restype = ctypes.c_int32
libusb_get_ss_endpoint_companion_descriptor.argtypes = [ctypes.POINTER(struct_libusb_context), ctypes.POINTER(struct_libusb_endpoint_descriptor), ctypes.POINTER(ctypes.POINTER(struct_libusb_ss_endpoint_companion_descriptor))]
except AttributeError:
pass
try:
libusb_free_ss_endpoint_companion_descriptor = _libraries['libusb'].libusb_free_ss_endpoint_companion_descriptor
libusb_free_ss_endpoint_companion_descriptor.restype = None
libusb_free_ss_endpoint_companion_descriptor.argtypes = [ctypes.POINTER(struct_libusb_ss_endpoint_companion_descriptor)]
except AttributeError:
pass
try:
libusb_get_bos_descriptor = _libraries['libusb'].libusb_get_bos_descriptor
libusb_get_bos_descriptor.restype = ctypes.c_int32
libusb_get_bos_descriptor.argtypes = [ctypes.POINTER(struct_libusb_device_handle), ctypes.POINTER(ctypes.POINTER(struct_libusb_bos_descriptor))]
except AttributeError:
pass
try:
libusb_free_bos_descriptor = _libraries['libusb'].libusb_free_bos_descriptor
libusb_free_bos_descriptor.restype = None
libusb_free_bos_descriptor.argtypes = [ctypes.POINTER(struct_libusb_bos_descriptor)]
except AttributeError:
pass
try:
libusb_get_usb_2_0_extension_descriptor = _libraries['libusb'].libusb_get_usb_2_0_extension_descriptor
libusb_get_usb_2_0_extension_descriptor.restype = ctypes.c_int32
libusb_get_usb_2_0_extension_descriptor.argtypes = [ctypes.POINTER(struct_libusb_context), ctypes.POINTER(struct_libusb_bos_dev_capability_descriptor), ctypes.POINTER(ctypes.POINTER(struct_libusb_usb_2_0_extension_descriptor))]
except AttributeError:
pass
try:
libusb_free_usb_2_0_extension_descriptor = _libraries['libusb'].libusb_free_usb_2_0_extension_descriptor
libusb_free_usb_2_0_extension_descriptor.restype = None
libusb_free_usb_2_0_extension_descriptor.argtypes = [ctypes.POINTER(struct_libusb_usb_2_0_extension_descriptor)]
except AttributeError:
pass
try:
libusb_get_ss_usb_device_capability_descriptor = _libraries['libusb'].libusb_get_ss_usb_device_capability_descriptor
libusb_get_ss_usb_device_capability_descriptor.restype = ctypes.c_int32
libusb_get_ss_usb_device_capability_descriptor.argtypes = [ctypes.POINTER(struct_libusb_context), ctypes.POINTER(struct_libusb_bos_dev_capability_descriptor), ctypes.POINTER(ctypes.POINTER(struct_libusb_ss_usb_device_capability_descriptor))]
except AttributeError:
pass
try:
libusb_free_ss_usb_device_capability_descriptor = _libraries['libusb'].libusb_free_ss_usb_device_capability_descriptor
libusb_free_ss_usb_device_capability_descriptor.restype = None
libusb_free_ss_usb_device_capability_descriptor.argtypes = [ctypes.POINTER(struct_libusb_ss_usb_device_capability_descriptor)]
except AttributeError:
pass
try:
libusb_get_container_id_descriptor = _libraries['libusb'].libusb_get_container_id_descriptor
libusb_get_container_id_descriptor.restype = ctypes.c_int32
libusb_get_container_id_descriptor.argtypes = [ctypes.POINTER(struct_libusb_context), ctypes.POINTER(struct_libusb_bos_dev_capability_descriptor), ctypes.POINTER(ctypes.POINTER(struct_libusb_container_id_descriptor))]
except AttributeError:
pass
try:
libusb_free_container_id_descriptor = _libraries['libusb'].libusb_free_container_id_descriptor
libusb_free_container_id_descriptor.restype = None
libusb_free_container_id_descriptor.argtypes = [ctypes.POINTER(struct_libusb_container_id_descriptor)]
except AttributeError:
pass
try:
libusb_get_bus_number = _libraries['libusb'].libusb_get_bus_number
libusb_get_bus_number.restype = uint8_t
libusb_get_bus_number.argtypes = [ctypes.POINTER(struct_libusb_device)]
except AttributeError:
pass
try:
libusb_get_port_number = _libraries['libusb'].libusb_get_port_number
libusb_get_port_number.restype = uint8_t
libusb_get_port_number.argtypes = [ctypes.POINTER(struct_libusb_device)]
except AttributeError:
pass
try:
libusb_get_port_numbers = _libraries['libusb'].libusb_get_port_numbers
libusb_get_port_numbers.restype = ctypes.c_int32
libusb_get_port_numbers.argtypes = [ctypes.POINTER(struct_libusb_device), ctypes.POINTER(ctypes.c_ubyte), ctypes.c_int32]
except AttributeError:
pass
try:
libusb_get_port_path = _libraries['libusb'].libusb_get_port_path
libusb_get_port_path.restype = ctypes.c_int32
libusb_get_port_path.argtypes = [ctypes.POINTER(struct_libusb_context), ctypes.POINTER(struct_libusb_device), ctypes.POINTER(ctypes.c_ubyte), uint8_t]
except AttributeError:
pass
try:
libusb_get_parent = _libraries['libusb'].libusb_get_parent
libusb_get_parent.restype = ctypes.POINTER(struct_libusb_device)
libusb_get_parent.argtypes = [ctypes.POINTER(struct_libusb_device)]
except AttributeError:
pass
try:
libusb_get_device_address = _libraries['libusb'].libusb_get_device_address
libusb_get_device_address.restype = uint8_t
libusb_get_device_address.argtypes = [ctypes.POINTER(struct_libusb_device)]
except AttributeError:
pass
try:
libusb_get_device_speed = _libraries['libusb'].libusb_get_device_speed
libusb_get_device_speed.restype = ctypes.c_int32
libusb_get_device_speed.argtypes = [ctypes.POINTER(struct_libusb_device)]
except AttributeError:
pass
try:
libusb_get_max_packet_size = _libraries['libusb'].libusb_get_max_packet_size
libusb_get_max_packet_size.restype = ctypes.c_int32
libusb_get_max_packet_size.argtypes = [ctypes.POINTER(struct_libusb_device), ctypes.c_ubyte]
except AttributeError:
pass
try:
libusb_get_max_iso_packet_size = _libraries['libusb'].libusb_get_max_iso_packet_size
libusb_get_max_iso_packet_size.restype = ctypes.c_int32
libusb_get_max_iso_packet_size.argtypes = [ctypes.POINTER(struct_libusb_device), ctypes.c_ubyte]
except AttributeError:
pass
intptr_t = ctypes.c_int64
try:
libusb_wrap_sys_device = _libraries['libusb'].libusb_wrap_sys_device
libusb_wrap_sys_device.restype = ctypes.c_int32
libusb_wrap_sys_device.argtypes = [ctypes.POINTER(struct_libusb_context), intptr_t, ctypes.POINTER(ctypes.POINTER(struct_libusb_device_handle))]
except AttributeError:
pass
try:
libusb_open = _libraries['libusb'].libusb_open
libusb_open.restype = ctypes.c_int32
libusb_open.argtypes = [ctypes.POINTER(struct_libusb_device), ctypes.POINTER(ctypes.POINTER(struct_libusb_device_handle))]
except AttributeError:
pass
try:
libusb_close = _libraries['libusb'].libusb_close
libusb_close.restype = None
libusb_close.argtypes = [ctypes.POINTER(struct_libusb_device_handle)]
except AttributeError:
pass
try:
libusb_get_device = _libraries['libusb'].libusb_get_device
libusb_get_device.restype = ctypes.POINTER(struct_libusb_device)
libusb_get_device.argtypes = [ctypes.POINTER(struct_libusb_device_handle)]
except AttributeError:
pass
try:
libusb_set_configuration = _libraries['libusb'].libusb_set_configuration
libusb_set_configuration.restype = ctypes.c_int32
libusb_set_configuration.argtypes = [ctypes.POINTER(struct_libusb_device_handle), ctypes.c_int32]
except AttributeError:
pass
try:
libusb_claim_interface = _libraries['libusb'].libusb_claim_interface
libusb_claim_interface.restype = ctypes.c_int32
libusb_claim_interface.argtypes = [ctypes.POINTER(struct_libusb_device_handle), ctypes.c_int32]
except AttributeError:
pass
try:
libusb_release_interface = _libraries['libusb'].libusb_release_interface
libusb_release_interface.restype = ctypes.c_int32
libusb_release_interface.argtypes = [ctypes.POINTER(struct_libusb_device_handle), ctypes.c_int32]
except AttributeError:
pass
try:
libusb_open_device_with_vid_pid = _libraries['libusb'].libusb_open_device_with_vid_pid
libusb_open_device_with_vid_pid.restype = ctypes.POINTER(struct_libusb_device_handle)
libusb_open_device_with_vid_pid.argtypes = [ctypes.POINTER(struct_libusb_context), uint16_t, uint16_t]
except AttributeError:
pass
try:
libusb_set_interface_alt_setting = _libraries['libusb'].libusb_set_interface_alt_setting
libusb_set_interface_alt_setting.restype = ctypes.c_int32
libusb_set_interface_alt_setting.argtypes = [ctypes.POINTER(struct_libusb_device_handle), ctypes.c_int32, ctypes.c_int32]
except AttributeError:
pass
try:
libusb_clear_halt = _libraries['libusb'].libusb_clear_halt
libusb_clear_halt.restype = ctypes.c_int32
libusb_clear_halt.argtypes = [ctypes.POINTER(struct_libusb_device_handle), ctypes.c_ubyte]
except AttributeError:
pass
try:
libusb_reset_device = _libraries['libusb'].libusb_reset_device
libusb_reset_device.restype = ctypes.c_int32
libusb_reset_device.argtypes = [ctypes.POINTER(struct_libusb_device_handle)]
except AttributeError:
pass
try:
libusb_alloc_streams = _libraries['libusb'].libusb_alloc_streams
libusb_alloc_streams.restype = ctypes.c_int32
libusb_alloc_streams.argtypes = [ctypes.POINTER(struct_libusb_device_handle), uint32_t, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_int32]
except AttributeError:
pass
try:
libusb_free_streams = _libraries['libusb'].libusb_free_streams
libusb_free_streams.restype = ctypes.c_int32
libusb_free_streams.argtypes = [ctypes.POINTER(struct_libusb_device_handle), ctypes.POINTER(ctypes.c_ubyte), ctypes.c_int32]
except AttributeError:
pass
size_t = ctypes.c_uint64
try:
libusb_dev_mem_alloc = _libraries['libusb'].libusb_dev_mem_alloc
libusb_dev_mem_alloc.restype = ctypes.POINTER(ctypes.c_ubyte)
libusb_dev_mem_alloc.argtypes = [ctypes.POINTER(struct_libusb_device_handle), size_t]
except AttributeError:
pass
try:
libusb_dev_mem_free = _libraries['libusb'].libusb_dev_mem_free
libusb_dev_mem_free.restype = ctypes.c_int32
libusb_dev_mem_free.argtypes = [ctypes.POINTER(struct_libusb_device_handle), ctypes.POINTER(ctypes.c_ubyte), size_t]
except AttributeError:
pass
try:
libusb_kernel_driver_active = _libraries['libusb'].libusb_kernel_driver_active
libusb_kernel_driver_active.restype = ctypes.c_int32
libusb_kernel_driver_active.argtypes = [ctypes.POINTER(struct_libusb_device_handle), ctypes.c_int32]
except AttributeError:
pass
try:
libusb_detach_kernel_driver = _libraries['libusb'].libusb_detach_kernel_driver
libusb_detach_kernel_driver.restype = ctypes.c_int32
libusb_detach_kernel_driver.argtypes = [ctypes.POINTER(struct_libusb_device_handle), ctypes.c_int32]
except AttributeError:
pass
try:
libusb_attach_kernel_driver = _libraries['libusb'].libusb_attach_kernel_driver
libusb_attach_kernel_driver.restype = ctypes.c_int32
libusb_attach_kernel_driver.argtypes = [ctypes.POINTER(struct_libusb_device_handle), ctypes.c_int32]
except AttributeError:
pass
try:
libusb_set_auto_detach_kernel_driver = _libraries['libusb'].libusb_set_auto_detach_kernel_driver
libusb_set_auto_detach_kernel_driver.restype = ctypes.c_int32
libusb_set_auto_detach_kernel_driver.argtypes = [ctypes.POINTER(struct_libusb_device_handle), ctypes.c_int32]
except AttributeError:
pass
try:
libusb_control_transfer_get_data = _libraries['libusb'].libusb_control_transfer_get_data
libusb_control_transfer_get_data.restype = ctypes.POINTER(ctypes.c_ubyte)
libusb_control_transfer_get_data.argtypes = [ctypes.POINTER(struct_libusb_transfer)]
except AttributeError:
pass
try:
libusb_control_transfer_get_setup = _libraries['libusb'].libusb_control_transfer_get_setup
libusb_control_transfer_get_setup.restype = ctypes.POINTER(struct_libusb_control_setup)
libusb_control_transfer_get_setup.argtypes = [ctypes.POINTER(struct_libusb_transfer)]
except AttributeError:
pass
try:
libusb_fill_control_setup = _libraries['libusb'].libusb_fill_control_setup
libusb_fill_control_setup.restype = None
libusb_fill_control_setup.argtypes = [ctypes.POINTER(ctypes.c_ubyte), uint8_t, uint8_t, uint16_t, uint16_t, uint16_t]
except AttributeError:
pass
try:
libusb_alloc_transfer = _libraries['libusb'].libusb_alloc_transfer
libusb_alloc_transfer.restype = ctypes.POINTER(struct_libusb_transfer)
libusb_alloc_transfer.argtypes = [ctypes.c_int32]
except AttributeError:
pass
try:
libusb_submit_transfer = _libraries['libusb'].libusb_submit_transfer
libusb_submit_transfer.restype = ctypes.c_int32
libusb_submit_transfer.argtypes = [ctypes.POINTER(struct_libusb_transfer)]
except AttributeError:
pass
try:
libusb_cancel_transfer = _libraries['libusb'].libusb_cancel_transfer
libusb_cancel_transfer.restype = ctypes.c_int32
libusb_cancel_transfer.argtypes = [ctypes.POINTER(struct_libusb_transfer)]
except AttributeError:
pass
try:
libusb_free_transfer = _libraries['libusb'].libusb_free_transfer
libusb_free_transfer.restype = None
libusb_free_transfer.argtypes = [ctypes.POINTER(struct_libusb_transfer)]
except AttributeError:
pass
try:
libusb_transfer_set_stream_id = _libraries['libusb'].libusb_transfer_set_stream_id
libusb_transfer_set_stream_id.restype = None
libusb_transfer_set_stream_id.argtypes = [ctypes.POINTER(struct_libusb_transfer), uint32_t]
except AttributeError:
pass
try:
libusb_transfer_get_stream_id = _libraries['libusb'].libusb_transfer_get_stream_id
libusb_transfer_get_stream_id.restype = uint32_t
libusb_transfer_get_stream_id.argtypes = [ctypes.POINTER(struct_libusb_transfer)]
except AttributeError:
pass
try:
libusb_fill_control_transfer = _libraries['libusb'].libusb_fill_control_transfer
libusb_fill_control_transfer.restype = None
libusb_fill_control_transfer.argtypes = [ctypes.POINTER(struct_libusb_transfer), ctypes.POINTER(struct_libusb_device_handle), ctypes.POINTER(ctypes.c_ubyte), libusb_transfer_cb_fn, ctypes.POINTER(None), ctypes.c_uint32]
except AttributeError:
pass
try:
libusb_fill_bulk_transfer = _libraries['libusb'].libusb_fill_bulk_transfer
libusb_fill_bulk_transfer.restype = None
libusb_fill_bulk_transfer.argtypes = [ctypes.POINTER(struct_libusb_transfer), ctypes.POINTER(struct_libusb_device_handle), ctypes.c_ubyte, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_int32, libusb_transfer_cb_fn, ctypes.POINTER(None), ctypes.c_uint32]
except AttributeError:
pass
try:
libusb_fill_bulk_stream_transfer = _libraries['libusb'].libusb_fill_bulk_stream_transfer
libusb_fill_bulk_stream_transfer.restype = None
libusb_fill_bulk_stream_transfer.argtypes = [ctypes.POINTER(struct_libusb_transfer), ctypes.POINTER(struct_libusb_device_handle), ctypes.c_ubyte, uint32_t, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_int32, libusb_transfer_cb_fn, ctypes.POINTER(None), ctypes.c_uint32]
except AttributeError:
pass
try:
libusb_fill_interrupt_transfer = _libraries['libusb'].libusb_fill_interrupt_transfer
libusb_fill_interrupt_transfer.restype = None
libusb_fill_interrupt_transfer.argtypes = [ctypes.POINTER(struct_libusb_transfer), ctypes.POINTER(struct_libusb_device_handle), ctypes.c_ubyte, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_int32, libusb_transfer_cb_fn, ctypes.POINTER(None), ctypes.c_uint32]
except AttributeError:
pass
try:
libusb_fill_iso_transfer = _libraries['libusb'].libusb_fill_iso_transfer
libusb_fill_iso_transfer.restype = None
libusb_fill_iso_transfer.argtypes = [ctypes.POINTER(struct_libusb_transfer), ctypes.POINTER(struct_libusb_device_handle), ctypes.c_ubyte, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_int32, ctypes.c_int32, libusb_transfer_cb_fn, ctypes.POINTER(None), ctypes.c_uint32]
except AttributeError:
pass
try:
libusb_set_iso_packet_lengths = _libraries['libusb'].libusb_set_iso_packet_lengths
libusb_set_iso_packet_lengths.restype = None
libusb_set_iso_packet_lengths.argtypes = [ctypes.POINTER(struct_libusb_transfer), ctypes.c_uint32]
except AttributeError:
pass
try:
libusb_get_iso_packet_buffer = _libraries['libusb'].libusb_get_iso_packet_buffer
libusb_get_iso_packet_buffer.restype = ctypes.POINTER(ctypes.c_ubyte)
libusb_get_iso_packet_buffer.argtypes = [ctypes.POINTER(struct_libusb_transfer), ctypes.c_uint32]
except AttributeError:
pass
try:
libusb_get_iso_packet_buffer_simple = _libraries['libusb'].libusb_get_iso_packet_buffer_simple
libusb_get_iso_packet_buffer_simple.restype = ctypes.POINTER(ctypes.c_ubyte)
libusb_get_iso_packet_buffer_simple.argtypes = [ctypes.POINTER(struct_libusb_transfer), ctypes.c_uint32]
except AttributeError:
pass
try:
libusb_control_transfer = _libraries['libusb'].libusb_control_transfer
libusb_control_transfer.restype = ctypes.c_int32
libusb_control_transfer.argtypes = [ctypes.POINTER(struct_libusb_device_handle), uint8_t, uint8_t, uint16_t, uint16_t, ctypes.POINTER(ctypes.c_ubyte), uint16_t, ctypes.c_uint32]
except AttributeError:
pass
try:
libusb_bulk_transfer = _libraries['libusb'].libusb_bulk_transfer
libusb_bulk_transfer.restype = ctypes.c_int32
libusb_bulk_transfer.argtypes = [ctypes.POINTER(struct_libusb_device_handle), ctypes.c_ubyte, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_int32, ctypes.POINTER(ctypes.c_int32), ctypes.c_uint32]
except AttributeError:
pass
try:
libusb_interrupt_transfer = _libraries['libusb'].libusb_interrupt_transfer
libusb_interrupt_transfer.restype = ctypes.c_int32
libusb_interrupt_transfer.argtypes = [ctypes.POINTER(struct_libusb_device_handle), ctypes.c_ubyte, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_int32, ctypes.POINTER(ctypes.c_int32), ctypes.c_uint32]
except AttributeError:
pass
try:
libusb_get_descriptor = _libraries['libusb'].libusb_get_descriptor
libusb_get_descriptor.restype = ctypes.c_int32
libusb_get_descriptor.argtypes = [ctypes.POINTER(struct_libusb_device_handle), uint8_t, uint8_t, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_int32]
except AttributeError:
pass
try:
libusb_get_string_descriptor = _libraries['libusb'].libusb_get_string_descriptor
libusb_get_string_descriptor.restype = ctypes.c_int32
libusb_get_string_descriptor.argtypes = [ctypes.POINTER(struct_libusb_device_handle), uint8_t, uint16_t, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_int32]
except AttributeError:
pass
try:
libusb_get_string_descriptor_ascii = _libraries['libusb'].libusb_get_string_descriptor_ascii
libusb_get_string_descriptor_ascii.restype = ctypes.c_int32
libusb_get_string_descriptor_ascii.argtypes = [ctypes.POINTER(struct_libusb_device_handle), uint8_t, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_int32]
except AttributeError:
pass
try:
libusb_try_lock_events = _libraries['libusb'].libusb_try_lock_events
libusb_try_lock_events.restype = ctypes.c_int32
libusb_try_lock_events.argtypes = [ctypes.POINTER(struct_libusb_context)]
except AttributeError:
pass
try:
libusb_lock_events = _libraries['libusb'].libusb_lock_events
libusb_lock_events.restype = None
libusb_lock_events.argtypes = [ctypes.POINTER(struct_libusb_context)]
except AttributeError:
pass
try:
libusb_unlock_events = _libraries['libusb'].libusb_unlock_events
libusb_unlock_events.restype = None
libusb_unlock_events.argtypes = [ctypes.POINTER(struct_libusb_context)]
except AttributeError:
pass
try:
libusb_event_handling_ok = _libraries['libusb'].libusb_event_handling_ok
libusb_event_handling_ok.restype = ctypes.c_int32
libusb_event_handling_ok.argtypes = [ctypes.POINTER(struct_libusb_context)]
except AttributeError:
pass
try:
libusb_event_handler_active = _libraries['libusb'].libusb_event_handler_active
libusb_event_handler_active.restype = ctypes.c_int32
libusb_event_handler_active.argtypes = [ctypes.POINTER(struct_libusb_context)]
except AttributeError:
pass
try:
libusb_interrupt_event_handler = _libraries['libusb'].libusb_interrupt_event_handler
libusb_interrupt_event_handler.restype = None
libusb_interrupt_event_handler.argtypes = [ctypes.POINTER(struct_libusb_context)]
except AttributeError:
pass
try:
libusb_lock_event_waiters = _libraries['libusb'].libusb_lock_event_waiters
libusb_lock_event_waiters.restype = None
libusb_lock_event_waiters.argtypes = [ctypes.POINTER(struct_libusb_context)]
except AttributeError:
pass
try:
libusb_unlock_event_waiters = _libraries['libusb'].libusb_unlock_event_waiters
libusb_unlock_event_waiters.restype = None
libusb_unlock_event_waiters.argtypes = [ctypes.POINTER(struct_libusb_context)]
except AttributeError:
pass
class struct_timeval(Structure):
pass
struct_timeval._pack_ = 1 # source:False
struct_timeval._fields_ = [
('tv_sec', ctypes.c_int64),
('tv_usec', ctypes.c_int64),
]
try:
libusb_wait_for_event = _libraries['libusb'].libusb_wait_for_event
libusb_wait_for_event.restype = ctypes.c_int32
libusb_wait_for_event.argtypes = [ctypes.POINTER(struct_libusb_context), ctypes.POINTER(struct_timeval)]
except AttributeError:
pass
try:
libusb_handle_events_timeout = _libraries['libusb'].libusb_handle_events_timeout
libusb_handle_events_timeout.restype = ctypes.c_int32
libusb_handle_events_timeout.argtypes = [ctypes.POINTER(struct_libusb_context), ctypes.POINTER(struct_timeval)]
except AttributeError:
pass
try:
libusb_handle_events_timeout_completed = _libraries['libusb'].libusb_handle_events_timeout_completed
libusb_handle_events_timeout_completed.restype = ctypes.c_int32
libusb_handle_events_timeout_completed.argtypes = [ctypes.POINTER(struct_libusb_context), ctypes.POINTER(struct_timeval), ctypes.POINTER(ctypes.c_int32)]
except AttributeError:
pass
try:
libusb_handle_events = _libraries['libusb'].libusb_handle_events
libusb_handle_events.restype = ctypes.c_int32
libusb_handle_events.argtypes = [ctypes.POINTER(struct_libusb_context)]
except AttributeError:
pass
try:
libusb_handle_events_completed = _libraries['libusb'].libusb_handle_events_completed
libusb_handle_events_completed.restype = ctypes.c_int32
libusb_handle_events_completed.argtypes = [ctypes.POINTER(struct_libusb_context), ctypes.POINTER(ctypes.c_int32)]
except AttributeError:
pass
try:
libusb_handle_events_locked = _libraries['libusb'].libusb_handle_events_locked
libusb_handle_events_locked.restype = ctypes.c_int32
libusb_handle_events_locked.argtypes = [ctypes.POINTER(struct_libusb_context), ctypes.POINTER(struct_timeval)]
except AttributeError:
pass
try:
libusb_pollfds_handle_timeouts = _libraries['libusb'].libusb_pollfds_handle_timeouts
libusb_pollfds_handle_timeouts.restype = ctypes.c_int32
libusb_pollfds_handle_timeouts.argtypes = [ctypes.POINTER(struct_libusb_context)]
except AttributeError:
pass
try:
libusb_get_next_timeout = _libraries['libusb'].libusb_get_next_timeout
libusb_get_next_timeout.restype = ctypes.c_int32
libusb_get_next_timeout.argtypes = [ctypes.POINTER(struct_libusb_context), ctypes.POINTER(struct_timeval)]
except AttributeError:
pass
class struct_libusb_pollfd(Structure):
pass
struct_libusb_pollfd._pack_ = 1 # source:False
struct_libusb_pollfd._fields_ = [
('fd', ctypes.c_int32),
('events', ctypes.c_int16),
('PADDING_0', ctypes.c_ubyte * 2),
]
libusb_pollfd_added_cb = ctypes.CFUNCTYPE(None, ctypes.c_int32, ctypes.c_int16, ctypes.POINTER(None))
libusb_pollfd_removed_cb = ctypes.CFUNCTYPE(None, ctypes.c_int32, ctypes.POINTER(None))
try:
libusb_get_pollfds = _libraries['libusb'].libusb_get_pollfds
libusb_get_pollfds.restype = ctypes.POINTER(ctypes.POINTER(struct_libusb_pollfd))
libusb_get_pollfds.argtypes = [ctypes.POINTER(struct_libusb_context)]
except AttributeError:
pass
try:
libusb_free_pollfds = _libraries['libusb'].libusb_free_pollfds
libusb_free_pollfds.restype = None
libusb_free_pollfds.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_libusb_pollfd))]
except AttributeError:
pass
try:
libusb_set_pollfd_notifiers = _libraries['libusb'].libusb_set_pollfd_notifiers
libusb_set_pollfd_notifiers.restype = None
libusb_set_pollfd_notifiers.argtypes = [ctypes.POINTER(struct_libusb_context), libusb_pollfd_added_cb, libusb_pollfd_removed_cb, ctypes.POINTER(None)]
except AttributeError:
pass
libusb_hotplug_callback_handle = ctypes.c_int32
# values for enumeration 'c__EA_libusb_hotplug_event'
c__EA_libusb_hotplug_event__enumvalues = {
1: 'LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED',
2: 'LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT',
}
LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED = 1
LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT = 2
c__EA_libusb_hotplug_event = ctypes.c_uint32 # enum
libusb_hotplug_event = c__EA_libusb_hotplug_event
libusb_hotplug_event__enumvalues = c__EA_libusb_hotplug_event__enumvalues
# values for enumeration 'c__EA_libusb_hotplug_flag'
c__EA_libusb_hotplug_flag__enumvalues = {
1: 'LIBUSB_HOTPLUG_ENUMERATE',
}
LIBUSB_HOTPLUG_ENUMERATE = 1
c__EA_libusb_hotplug_flag = ctypes.c_uint32 # enum
libusb_hotplug_flag = c__EA_libusb_hotplug_flag
libusb_hotplug_flag__enumvalues = c__EA_libusb_hotplug_flag__enumvalues
libusb_hotplug_callback_fn = ctypes.CFUNCTYPE(ctypes.c_int32, ctypes.POINTER(struct_libusb_context), ctypes.POINTER(struct_libusb_device), c__EA_libusb_hotplug_event, ctypes.POINTER(None))
try:
libusb_hotplug_register_callback = _libraries['libusb'].libusb_hotplug_register_callback
libusb_hotplug_register_callback.restype = ctypes.c_int32
libusb_hotplug_register_callback.argtypes = [ctypes.POINTER(struct_libusb_context), ctypes.c_int32, ctypes.c_int32, ctypes.c_int32, ctypes.c_int32, ctypes.c_int32, libusb_hotplug_callback_fn, ctypes.POINTER(None), ctypes.POINTER(ctypes.c_int32)]
except AttributeError:
pass
try:
libusb_hotplug_deregister_callback = _libraries['libusb'].libusb_hotplug_deregister_callback
libusb_hotplug_deregister_callback.restype = None
libusb_hotplug_deregister_callback.argtypes = [ctypes.POINTER(struct_libusb_context), libusb_hotplug_callback_handle]
except AttributeError:
pass
try:
libusb_hotplug_get_user_data = _libraries['libusb'].libusb_hotplug_get_user_data
libusb_hotplug_get_user_data.restype = ctypes.POINTER(None)
libusb_hotplug_get_user_data.argtypes = [ctypes.POINTER(struct_libusb_context), libusb_hotplug_callback_handle]
except AttributeError:
pass
# values for enumeration 'libusb_option'
libusb_option__enumvalues = {
0: 'LIBUSB_OPTION_LOG_LEVEL',
1: 'LIBUSB_OPTION_USE_USBDK',
2: 'LIBUSB_OPTION_NO_DEVICE_DISCOVERY',
3: 'LIBUSB_OPTION_MAX',
}
LIBUSB_OPTION_LOG_LEVEL = 0
LIBUSB_OPTION_USE_USBDK = 1
LIBUSB_OPTION_NO_DEVICE_DISCOVERY = 2
LIBUSB_OPTION_MAX = 3
libusb_option = ctypes.c_uint32 # enum
LIBUSB_OPTION_WEAK_AUTHORITY = LIBUSB_OPTION_NO_DEVICE_DISCOVERY # macro
try:
libusb_set_option = _libraries['libusb'].libusb_set_option
libusb_set_option.restype = ctypes.c_int32
libusb_set_option.argtypes = [ctypes.POINTER(struct_libusb_context), libusb_option]
except AttributeError:
pass
struct_libusb_transfer._pack_ = 1 # source:False
struct_libusb_transfer._fields_ = [
('dev_handle', ctypes.POINTER(struct_libusb_device_handle)),
('flags', ctypes.c_ubyte),
('endpoint', ctypes.c_ubyte),
('type', ctypes.c_ubyte),
('PADDING_0', ctypes.c_ubyte),
('timeout', ctypes.c_uint32),
('status', libusb_transfer_status),
('length', ctypes.c_int32),
('actual_length', ctypes.c_int32),
('PADDING_1', ctypes.c_ubyte * 4),
('callback', ctypes.CFUNCTYPE(None, ctypes.POINTER(struct_libusb_transfer))),
('user_data', ctypes.POINTER(None)),
('buffer', ctypes.POINTER(ctypes.c_ubyte)),
('num_iso_packets', ctypes.c_int32),
('iso_packet_desc', struct_libusb_iso_packet_descriptor * 0),
('PADDING_2', ctypes.c_ubyte * 4),
]
__all__ = \
['LIBUSBX_API_VERSION', 'LIBUSB_API_VERSION',
'LIBUSB_BM_LPM_SUPPORT', 'LIBUSB_BM_LTM_SUPPORT',
'LIBUSB_BT_CONTAINER_ID', 'LIBUSB_BT_CONTAINER_ID_SIZE',
'LIBUSB_BT_SS_USB_DEVICE_CAPABILITY',
'LIBUSB_BT_SS_USB_DEVICE_CAPABILITY_SIZE',
'LIBUSB_BT_USB_2_0_EXTENSION', 'LIBUSB_BT_USB_2_0_EXTENSION_SIZE',
'LIBUSB_BT_WIRELESS_USB_DEVICE_CAPABILITY', 'LIBUSB_CALL',
'LIBUSB_CAP_HAS_CAPABILITY', 'LIBUSB_CAP_HAS_HID_ACCESS',
'LIBUSB_CAP_HAS_HOTPLUG',
'LIBUSB_CAP_SUPPORTS_DETACH_KERNEL_DRIVER',
'LIBUSB_CLASS_APPLICATION', 'LIBUSB_CLASS_AUDIO',
'LIBUSB_CLASS_COMM', 'LIBUSB_CLASS_CONTENT_SECURITY',
'LIBUSB_CLASS_DATA', 'LIBUSB_CLASS_DIAGNOSTIC_DEVICE',
'LIBUSB_CLASS_HID', 'LIBUSB_CLASS_HUB', 'LIBUSB_CLASS_IMAGE',
'LIBUSB_CLASS_MASS_STORAGE', 'LIBUSB_CLASS_MISCELLANEOUS',
'LIBUSB_CLASS_PERSONAL_HEALTHCARE', 'LIBUSB_CLASS_PER_INTERFACE',
'LIBUSB_CLASS_PHYSICAL', 'LIBUSB_CLASS_PRINTER',
'LIBUSB_CLASS_PTP', 'LIBUSB_CLASS_SMART_CARD',
'LIBUSB_CLASS_VENDOR_SPEC', 'LIBUSB_CLASS_VIDEO',
'LIBUSB_CLASS_WIRELESS', 'LIBUSB_DT_BOS',
'LIBUSB_DT_BOS_MAX_SIZE', 'LIBUSB_DT_BOS_SIZE',
'LIBUSB_DT_CONFIG', 'LIBUSB_DT_CONFIG_SIZE', 'LIBUSB_DT_DEVICE',
'LIBUSB_DT_DEVICE_CAPABILITY', 'LIBUSB_DT_DEVICE_CAPABILITY_SIZE',
'LIBUSB_DT_DEVICE_SIZE', 'LIBUSB_DT_ENDPOINT',
'LIBUSB_DT_ENDPOINT_AUDIO_SIZE', 'LIBUSB_DT_ENDPOINT_SIZE',
'LIBUSB_DT_HID', 'LIBUSB_DT_HUB', 'LIBUSB_DT_HUB_NONVAR_SIZE',
'LIBUSB_DT_INTERFACE', 'LIBUSB_DT_INTERFACE_SIZE',
'LIBUSB_DT_PHYSICAL', 'LIBUSB_DT_REPORT',
'LIBUSB_DT_SS_ENDPOINT_COMPANION',
'LIBUSB_DT_SS_ENDPOINT_COMPANION_SIZE', 'LIBUSB_DT_STRING',
'LIBUSB_DT_SUPERSPEED_HUB', 'LIBUSB_ENDPOINT_ADDRESS_MASK',
'LIBUSB_ENDPOINT_DIR_MASK', 'LIBUSB_ENDPOINT_IN',
'LIBUSB_ENDPOINT_OUT', 'LIBUSB_ENDPOINT_TRANSFER_TYPE_BULK',
'LIBUSB_ENDPOINT_TRANSFER_TYPE_CONTROL',
'LIBUSB_ENDPOINT_TRANSFER_TYPE_INTERRUPT',
'LIBUSB_ENDPOINT_TRANSFER_TYPE_ISOCHRONOUS',
'LIBUSB_ERROR_ACCESS', 'LIBUSB_ERROR_BUSY', 'LIBUSB_ERROR_COUNT',
'LIBUSB_ERROR_INTERRUPTED', 'LIBUSB_ERROR_INVALID_PARAM',
'LIBUSB_ERROR_IO', 'LIBUSB_ERROR_NOT_FOUND',
'LIBUSB_ERROR_NOT_SUPPORTED', 'LIBUSB_ERROR_NO_DEVICE',
'LIBUSB_ERROR_NO_MEM', 'LIBUSB_ERROR_OTHER',
'LIBUSB_ERROR_OVERFLOW', 'LIBUSB_ERROR_PIPE',
'LIBUSB_ERROR_TIMEOUT', 'LIBUSB_FULL_SPEED_OPERATION', 'LIBUSB_H',
'LIBUSB_HIGH_SPEED_OPERATION', 'LIBUSB_HOTPLUG_ENUMERATE',
'LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED',
'LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT', 'LIBUSB_HOTPLUG_MATCH_ANY',
'LIBUSB_HOTPLUG_NO_FLAGS', 'LIBUSB_ISO_SYNC_TYPE_ADAPTIVE',
'LIBUSB_ISO_SYNC_TYPE_ASYNC', 'LIBUSB_ISO_SYNC_TYPE_MASK',
'LIBUSB_ISO_SYNC_TYPE_NONE', 'LIBUSB_ISO_SYNC_TYPE_SYNC',
'LIBUSB_ISO_USAGE_TYPE_DATA', 'LIBUSB_ISO_USAGE_TYPE_FEEDBACK',
'LIBUSB_ISO_USAGE_TYPE_IMPLICIT', 'LIBUSB_ISO_USAGE_TYPE_MASK',
'LIBUSB_LOG_CB_CONTEXT', 'LIBUSB_LOG_CB_GLOBAL',
'LIBUSB_LOG_LEVEL_DEBUG', 'LIBUSB_LOG_LEVEL_ERROR',
'LIBUSB_LOG_LEVEL_INFO', 'LIBUSB_LOG_LEVEL_NONE',
'LIBUSB_LOG_LEVEL_WARNING', 'LIBUSB_LOW_SPEED_OPERATION',
'LIBUSB_OPTION_LOG_LEVEL', 'LIBUSB_OPTION_MAX',
'LIBUSB_OPTION_NO_DEVICE_DISCOVERY', 'LIBUSB_OPTION_USE_USBDK',
'LIBUSB_OPTION_WEAK_AUTHORITY', 'LIBUSB_RECIPIENT_DEVICE',
'LIBUSB_RECIPIENT_ENDPOINT', 'LIBUSB_RECIPIENT_INTERFACE',
'LIBUSB_RECIPIENT_OTHER', 'LIBUSB_REQUEST_CLEAR_FEATURE',
'LIBUSB_REQUEST_GET_CONFIGURATION',
'LIBUSB_REQUEST_GET_DESCRIPTOR', 'LIBUSB_REQUEST_GET_INTERFACE',
'LIBUSB_REQUEST_GET_STATUS', 'LIBUSB_REQUEST_SET_ADDRESS',
'LIBUSB_REQUEST_SET_CONFIGURATION',
'LIBUSB_REQUEST_SET_DESCRIPTOR', 'LIBUSB_REQUEST_SET_FEATURE',
'LIBUSB_REQUEST_SET_INTERFACE', 'LIBUSB_REQUEST_SET_SEL',
'LIBUSB_REQUEST_SYNCH_FRAME', 'LIBUSB_REQUEST_TYPE_CLASS',
'LIBUSB_REQUEST_TYPE_RESERVED', 'LIBUSB_REQUEST_TYPE_STANDARD',
'LIBUSB_REQUEST_TYPE_VENDOR', 'LIBUSB_SET_ISOCH_DELAY',
'LIBUSB_SPEED_FULL', 'LIBUSB_SPEED_HIGH', 'LIBUSB_SPEED_LOW',
'LIBUSB_SPEED_SUPER', 'LIBUSB_SPEED_SUPER_PLUS',
'LIBUSB_SPEED_UNKNOWN', 'LIBUSB_SUCCESS',
'LIBUSB_SUPER_SPEED_OPERATION', 'LIBUSB_TRANSFER_ADD_ZERO_PACKET',
'LIBUSB_TRANSFER_CANCELLED', 'LIBUSB_TRANSFER_COMPLETED',
'LIBUSB_TRANSFER_ERROR', 'LIBUSB_TRANSFER_FREE_BUFFER',
'LIBUSB_TRANSFER_FREE_TRANSFER', 'LIBUSB_TRANSFER_NO_DEVICE',
'LIBUSB_TRANSFER_OVERFLOW', 'LIBUSB_TRANSFER_SHORT_NOT_OK',
'LIBUSB_TRANSFER_STALL', 'LIBUSB_TRANSFER_TIMED_OUT',
'LIBUSB_TRANSFER_TYPE_BULK', 'LIBUSB_TRANSFER_TYPE_BULK_STREAM',
'LIBUSB_TRANSFER_TYPE_CONTROL', 'LIBUSB_TRANSFER_TYPE_INTERRUPT',
'LIBUSB_TRANSFER_TYPE_ISOCHRONOUS', 'LIBUSB_TRANSFER_TYPE_MASK',
'ZERO_SIZED_ARRAY', 'c__EA_libusb_hotplug_event',
'c__EA_libusb_hotplug_flag', 'intptr_t', 'libusb_alloc_streams',
'libusb_alloc_transfer', 'libusb_attach_kernel_driver',
'libusb_bos_type', 'libusb_bulk_transfer',
'libusb_cancel_transfer', 'libusb_capability',
'libusb_claim_interface', 'libusb_class_code',
'libusb_clear_halt', 'libusb_close', 'libusb_context',
'libusb_control_transfer', 'libusb_control_transfer_get_data',
'libusb_control_transfer_get_setup', 'libusb_cpu_to_le16',
'libusb_descriptor_type', 'libusb_detach_kernel_driver',
'libusb_dev_mem_alloc', 'libusb_dev_mem_free', 'libusb_device',
'libusb_device_handle', 'libusb_endpoint_direction',
'libusb_endpoint_transfer_type', 'libusb_error',
'libusb_error_name', 'libusb_event_handler_active',
'libusb_event_handling_ok', 'libusb_exit',
'libusb_fill_bulk_stream_transfer', 'libusb_fill_bulk_transfer',
'libusb_fill_control_setup', 'libusb_fill_control_transfer',
'libusb_fill_interrupt_transfer', 'libusb_fill_iso_transfer',
'libusb_free_bos_descriptor', 'libusb_free_config_descriptor',
'libusb_free_container_id_descriptor', 'libusb_free_device_list',
'libusb_free_pollfds',
'libusb_free_ss_endpoint_companion_descriptor',
'libusb_free_ss_usb_device_capability_descriptor',
'libusb_free_streams', 'libusb_free_transfer',
'libusb_free_usb_2_0_extension_descriptor',
'libusb_get_active_config_descriptor',
'libusb_get_bos_descriptor', 'libusb_get_bus_number',
'libusb_get_config_descriptor',
'libusb_get_config_descriptor_by_value',
'libusb_get_configuration', 'libusb_get_container_id_descriptor',
'libusb_get_descriptor', 'libusb_get_device',
'libusb_get_device_address', 'libusb_get_device_descriptor',
'libusb_get_device_list', 'libusb_get_device_speed',
'libusb_get_iso_packet_buffer',
'libusb_get_iso_packet_buffer_simple',
'libusb_get_max_iso_packet_size', 'libusb_get_max_packet_size',
'libusb_get_next_timeout', 'libusb_get_parent',
'libusb_get_pollfds', 'libusb_get_port_number',
'libusb_get_port_numbers', 'libusb_get_port_path',
'libusb_get_ss_endpoint_companion_descriptor',
'libusb_get_ss_usb_device_capability_descriptor',
'libusb_get_string_descriptor',
'libusb_get_string_descriptor_ascii',
'libusb_get_usb_2_0_extension_descriptor', 'libusb_get_version',
'libusb_handle_events', 'libusb_handle_events_completed',
'libusb_handle_events_locked', 'libusb_handle_events_timeout',
'libusb_handle_events_timeout_completed', 'libusb_has_capability',
'libusb_hotplug_callback_fn', 'libusb_hotplug_callback_handle',
'libusb_hotplug_deregister_callback', 'libusb_hotplug_event',
'libusb_hotplug_event__enumvalues', 'libusb_hotplug_flag',
'libusb_hotplug_flag__enumvalues', 'libusb_hotplug_get_user_data',
'libusb_hotplug_register_callback', 'libusb_init',
'libusb_interrupt_event_handler', 'libusb_interrupt_transfer',
'libusb_iso_sync_type', 'libusb_iso_usage_type',
'libusb_kernel_driver_active', 'libusb_le16_to_cpu',
'libusb_lock_event_waiters', 'libusb_lock_events',
'libusb_log_cb', 'libusb_log_cb_mode', 'libusb_log_level',
'libusb_open', 'libusb_open_device_with_vid_pid', 'libusb_option',
'libusb_pollfd_added_cb', 'libusb_pollfd_removed_cb',
'libusb_pollfds_handle_timeouts', 'libusb_ref_device',
'libusb_release_interface', 'libusb_request_recipient',
'libusb_request_type', 'libusb_reset_device',
'libusb_set_auto_detach_kernel_driver',
'libusb_set_configuration', 'libusb_set_debug',
'libusb_set_interface_alt_setting',
'libusb_set_iso_packet_lengths', 'libusb_set_log_cb',
'libusb_set_option', 'libusb_set_pollfd_notifiers',
'libusb_setlocale', 'libusb_speed',
'libusb_ss_usb_device_capability_attributes',
'libusb_standard_request', 'libusb_strerror',
'libusb_submit_transfer', 'libusb_supported_speed',
'libusb_transfer_cb_fn', 'libusb_transfer_flags',
'libusb_transfer_get_stream_id', 'libusb_transfer_set_stream_id',
'libusb_transfer_status', 'libusb_transfer_type',
'libusb_try_lock_events', 'libusb_unlock_event_waiters',
'libusb_unlock_events', 'libusb_unref_device',
'libusb_usb_2_0_extension_attributes', 'libusb_wait_for_event',
'libusb_wrap_sys_device', 'size_t', 'ssize_t',
'struct_libusb_bos_descriptor',
'struct_libusb_bos_dev_capability_descriptor',
'struct_libusb_config_descriptor',
'struct_libusb_container_id_descriptor', 'struct_libusb_context',
'struct_libusb_control_setup', 'struct_libusb_device',
'struct_libusb_device_descriptor', 'struct_libusb_device_handle',
'struct_libusb_endpoint_descriptor', 'struct_libusb_interface',
'struct_libusb_interface_descriptor',
'struct_libusb_iso_packet_descriptor', 'struct_libusb_pollfd',
'struct_libusb_ss_endpoint_companion_descriptor',
'struct_libusb_ss_usb_device_capability_descriptor',
'struct_libusb_transfer',
'struct_libusb_usb_2_0_extension_descriptor',
'struct_libusb_version', 'struct_timeval', 'uint16_t', 'uint32_t',
'uint8_t']