efee1712aa
* fix.. speed_limit error... * draw tpms settings. * fix.. traffic light stopping only.. * fix.. waze cam * fix.. waze... * add setting (Enable comma connect ) * auto detect LFA2 * fix.. cruisespeed1 * vff2 driving model. * fix.. * agnos 12.3 * fix.. * ff * ff * test * ff * fix.. drawTurnInfo.. * Update drive_helpers.py * fix.. support eng voice eng sounds fix settings... english fix.. mph.. fix.. roadlimit speed bug.. * new vff model.. 250608 * fix soundd.. * fix safe exit speed.. * fix.. sounds. * fix.. radar timeStep.. * KerryGold model * Update drive_helpers.py * fix.. model. * fix.. * fix.. * Revert "fix.." This reverts commit b09ec459afb855c533d47fd7e8a1a6b1a09466e7. * Revert "fix.." This reverts commit 290bec6b83a4554ca232d531a911edccf94a2156. * fix esim * add more acc table. 10kph * kg update.. * fix cruisebutton mode3 * test atc..cond. * fix.. canfd * fix.. angle control limit
1644 lines
66 KiB
Python
1644 lines
66 KiB
Python
# 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']
|