libusb
|
00001 /* 00002 * Public libusb header file 00003 * Copyright (C) 2007-2008 Daniel Drake <dsd@gentoo.org> 00004 * Copyright (c) 2001 Johannes Erdfelt <johannes@erdfelt.com> 00005 * 00006 * This library is free software; you can redistribute it and/or 00007 * modify it under the terms of the GNU Lesser General Public 00008 * License as published by the Free Software Foundation; either 00009 * version 2.1 of the License, or (at your option) any later version. 00010 * 00011 * This library is distributed in the hope that it will be useful, 00012 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00013 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00014 * Lesser General Public License for more details. 00015 * 00016 * You should have received a copy of the GNU Lesser General Public 00017 * License along with this library; if not, write to the Free Software 00018 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 00019 */ 00020 00021 #ifndef __LIBUSB_H__ 00022 #define __LIBUSB_H__ 00023 00024 #include <stdint.h> 00025 #include <sys/time.h> 00026 #include <sys/types.h> 00027 #include <time.h> 00028 #include <limits.h> 00029 00030 #ifdef __cplusplus 00031 extern "C" { 00032 #endif 00033 00042 static inline uint16_t libusb_cpu_to_le16(const uint16_t x) 00043 { 00044 union { 00045 uint8_t b8[2]; 00046 uint16_t b16; 00047 } _tmp; 00048 _tmp.b8[1] = x >> 8; 00049 _tmp.b8[0] = x & 0xff; 00050 return _tmp.b16; 00051 } 00052 00061 #define libusb_le16_to_cpu libusb_cpu_to_le16 00062 00063 /* standard USB stuff */ 00064 00067 enum libusb_class_code { 00072 LIBUSB_CLASS_PER_INTERFACE = 0, 00073 00075 LIBUSB_CLASS_AUDIO = 1, 00076 00078 LIBUSB_CLASS_COMM = 2, 00079 00081 LIBUSB_CLASS_HID = 3, 00082 00084 LIBUSB_CLASS_PRINTER = 7, 00085 00087 LIBUSB_CLASS_PTP = 6, 00088 00090 LIBUSB_CLASS_MASS_STORAGE = 8, 00091 00093 LIBUSB_CLASS_HUB = 9, 00094 00096 LIBUSB_CLASS_DATA = 10, 00097 00099 LIBUSB_CLASS_WIRELESS = 0xe0, 00100 00102 LIBUSB_CLASS_APPLICATION = 0xfe, 00103 00105 LIBUSB_CLASS_VENDOR_SPEC = 0xff 00106 }; 00107 00110 enum libusb_descriptor_type { 00112 LIBUSB_DT_DEVICE = 0x01, 00113 00115 LIBUSB_DT_CONFIG = 0x02, 00116 00118 LIBUSB_DT_STRING = 0x03, 00119 00121 LIBUSB_DT_INTERFACE = 0x04, 00122 00124 LIBUSB_DT_ENDPOINT = 0x05, 00125 00127 LIBUSB_DT_HID = 0x21, 00128 00130 LIBUSB_DT_REPORT = 0x22, 00131 00133 LIBUSB_DT_PHYSICAL = 0x23, 00134 00136 LIBUSB_DT_HUB = 0x29 00137 }; 00138 00139 /* Descriptor sizes per descriptor type */ 00140 #define LIBUSB_DT_DEVICE_SIZE 18 00141 #define LIBUSB_DT_CONFIG_SIZE 9 00142 #define LIBUSB_DT_INTERFACE_SIZE 9 00143 #define LIBUSB_DT_ENDPOINT_SIZE 7 00144 #define LIBUSB_DT_ENDPOINT_AUDIO_SIZE 9 /* Audio extension */ 00145 #define LIBUSB_DT_HUB_NONVAR_SIZE 7 00146 00147 #define LIBUSB_ENDPOINT_ADDRESS_MASK 0x0f /* in bEndpointAddress */ 00148 #define LIBUSB_ENDPOINT_DIR_MASK 0x80 00149 00154 enum libusb_endpoint_direction { 00156 LIBUSB_ENDPOINT_IN = 0x80, 00157 00159 LIBUSB_ENDPOINT_OUT = 0x00 00160 }; 00161 00162 #define LIBUSB_TRANSFER_TYPE_MASK 0x03 /* in bmAttributes */ 00163 00168 enum libusb_transfer_type { 00170 LIBUSB_TRANSFER_TYPE_CONTROL = 0, 00171 00173 LIBUSB_TRANSFER_TYPE_ISOCHRONOUS = 1, 00174 00176 LIBUSB_TRANSFER_TYPE_BULK = 2, 00177 00179 LIBUSB_TRANSFER_TYPE_INTERRUPT = 3 00180 }; 00181 00184 enum libusb_standard_request { 00186 LIBUSB_REQUEST_GET_STATUS = 0x00, 00187 00189 LIBUSB_REQUEST_CLEAR_FEATURE = 0x01, 00190 00191 /* 0x02 is reserved */ 00192 00194 LIBUSB_REQUEST_SET_FEATURE = 0x03, 00195 00196 /* 0x04 is reserved */ 00197 00199 LIBUSB_REQUEST_SET_ADDRESS = 0x05, 00200 00202 LIBUSB_REQUEST_GET_DESCRIPTOR = 0x06, 00203 00205 LIBUSB_REQUEST_SET_DESCRIPTOR = 0x07, 00206 00208 LIBUSB_REQUEST_GET_CONFIGURATION = 0x08, 00209 00211 LIBUSB_REQUEST_SET_CONFIGURATION = 0x09, 00212 00214 LIBUSB_REQUEST_GET_INTERFACE = 0x0A, 00215 00217 LIBUSB_REQUEST_SET_INTERFACE = 0x0B, 00218 00220 LIBUSB_REQUEST_SYNCH_FRAME = 0x0C 00221 }; 00222 00227 enum libusb_request_type { 00229 LIBUSB_REQUEST_TYPE_STANDARD = (0x00 << 5), 00230 00232 LIBUSB_REQUEST_TYPE_CLASS = (0x01 << 5), 00233 00235 LIBUSB_REQUEST_TYPE_VENDOR = (0x02 << 5), 00236 00238 LIBUSB_REQUEST_TYPE_RESERVED = (0x03 << 5) 00239 }; 00240 00245 enum libusb_request_recipient { 00247 LIBUSB_RECIPIENT_DEVICE = 0x00, 00248 00250 LIBUSB_RECIPIENT_INTERFACE = 0x01, 00251 00253 LIBUSB_RECIPIENT_ENDPOINT = 0x02, 00254 00256 LIBUSB_RECIPIENT_OTHER = 0x03 00257 }; 00258 00259 #define LIBUSB_ISO_SYNC_TYPE_MASK 0x0C 00260 00266 enum libusb_iso_sync_type { 00268 LIBUSB_ISO_SYNC_TYPE_NONE = 0, 00269 00271 LIBUSB_ISO_SYNC_TYPE_ASYNC = 1, 00272 00274 LIBUSB_ISO_SYNC_TYPE_ADAPTIVE = 2, 00275 00277 LIBUSB_ISO_SYNC_TYPE_SYNC = 3 00278 }; 00279 00280 #define LIBUSB_ISO_USAGE_TYPE_MASK 0x30 00281 00287 enum libusb_iso_usage_type { 00289 LIBUSB_ISO_USAGE_TYPE_DATA = 0, 00290 00292 LIBUSB_ISO_USAGE_TYPE_FEEDBACK = 1, 00293 00295 LIBUSB_ISO_USAGE_TYPE_IMPLICIT = 2 00296 }; 00297 00303 struct libusb_device_descriptor { 00305 uint8_t bLength; 00306 00310 uint8_t bDescriptorType; 00311 00314 uint16_t bcdUSB; 00315 00317 uint8_t bDeviceClass; 00318 00321 uint8_t bDeviceSubClass; 00322 00325 uint8_t bDeviceProtocol; 00326 00328 uint8_t bMaxPacketSize0; 00329 00331 uint16_t idVendor; 00332 00334 uint16_t idProduct; 00335 00337 uint16_t bcdDevice; 00338 00340 uint8_t iManufacturer; 00341 00343 uint8_t iProduct; 00344 00346 uint8_t iSerialNumber; 00347 00349 uint8_t bNumConfigurations; 00350 }; 00351 00357 struct libusb_endpoint_descriptor { 00359 uint8_t bLength; 00360 00364 uint8_t bDescriptorType; 00365 00370 uint8_t bEndpointAddress; 00371 00379 uint8_t bmAttributes; 00380 00382 uint16_t wMaxPacketSize; 00383 00385 uint8_t bInterval; 00386 00389 uint8_t bRefresh; 00390 00392 uint8_t bSynchAddress; 00393 00396 const unsigned char *extra; 00397 00399 int extra_length; 00400 }; 00401 00407 struct libusb_interface_descriptor { 00409 uint8_t bLength; 00410 00414 uint8_t bDescriptorType; 00415 00417 uint8_t bInterfaceNumber; 00418 00420 uint8_t bAlternateSetting; 00421 00424 uint8_t bNumEndpoints; 00425 00427 uint8_t bInterfaceClass; 00428 00431 uint8_t bInterfaceSubClass; 00432 00435 uint8_t bInterfaceProtocol; 00436 00438 uint8_t iInterface; 00439 00442 const struct libusb_endpoint_descriptor *endpoint; 00443 00446 const unsigned char *extra; 00447 00449 int extra_length; 00450 }; 00451 00455 struct libusb_interface { 00458 const struct libusb_interface_descriptor *altsetting; 00459 00461 int num_altsetting; 00462 }; 00463 00469 struct libusb_config_descriptor { 00471 uint8_t bLength; 00472 00476 uint8_t bDescriptorType; 00477 00479 uint16_t wTotalLength; 00480 00482 uint8_t bNumInterfaces; 00483 00485 uint8_t bConfigurationValue; 00486 00488 uint8_t iConfiguration; 00489 00491 uint8_t bmAttributes; 00492 00496 uint8_t MaxPower; 00497 00500 const struct libusb_interface *interface; 00501 00504 const unsigned char *extra; 00505 00507 int extra_length; 00508 }; 00509 00512 struct libusb_control_setup { 00518 uint8_t bmRequestType; 00519 00525 uint8_t bRequest; 00526 00528 uint16_t wValue; 00529 00532 uint16_t wIndex; 00533 00535 uint16_t wLength; 00536 }; 00537 00538 #define LIBUSB_CONTROL_SETUP_SIZE (sizeof(struct libusb_control_setup)) 00539 00540 /* libusb */ 00541 00542 struct libusb_context; 00543 struct libusb_device; 00544 struct libusb_device_handle; 00545 00563 typedef struct libusb_context libusb_context; 00564 00580 typedef struct libusb_device libusb_device; 00581 00582 00591 typedef struct libusb_device_handle libusb_device_handle; 00592 00597 enum libusb_error { 00599 LIBUSB_SUCCESS = 0, 00600 00602 LIBUSB_ERROR_IO = -1, 00603 00605 LIBUSB_ERROR_INVALID_PARAM = -2, 00606 00608 LIBUSB_ERROR_ACCESS = -3, 00609 00611 LIBUSB_ERROR_NO_DEVICE = -4, 00612 00614 LIBUSB_ERROR_NOT_FOUND = -5, 00615 00617 LIBUSB_ERROR_BUSY = -6, 00618 00620 LIBUSB_ERROR_TIMEOUT = -7, 00621 00623 LIBUSB_ERROR_OVERFLOW = -8, 00624 00626 LIBUSB_ERROR_PIPE = -9, 00627 00629 LIBUSB_ERROR_INTERRUPTED = -10, 00630 00632 LIBUSB_ERROR_NO_MEM = -11, 00633 00635 LIBUSB_ERROR_NOT_SUPPORTED = -12, 00636 00638 LIBUSB_ERROR_OTHER = -99 00639 }; 00640 00643 enum libusb_transfer_status { 00646 LIBUSB_TRANSFER_COMPLETED, 00647 00649 LIBUSB_TRANSFER_ERROR, 00650 00652 LIBUSB_TRANSFER_TIMED_OUT, 00653 00655 LIBUSB_TRANSFER_CANCELLED, 00656 00659 LIBUSB_TRANSFER_STALL, 00660 00662 LIBUSB_TRANSFER_NO_DEVICE, 00663 00665 LIBUSB_TRANSFER_OVERFLOW 00666 }; 00667 00670 enum libusb_transfer_flags { 00672 LIBUSB_TRANSFER_SHORT_NOT_OK = 1<<0, 00673 00675 LIBUSB_TRANSFER_FREE_BUFFER = 1<<1, 00676 00681 LIBUSB_TRANSFER_FREE_TRANSFER = 1<<2 00682 }; 00683 00686 struct libusb_iso_packet_descriptor { 00688 unsigned int length; 00689 00691 unsigned int actual_length; 00692 00694 enum libusb_transfer_status status; 00695 }; 00696 00697 struct libusb_transfer; 00698 00708 typedef void (*libusb_transfer_cb_fn)(struct libusb_transfer *transfer); 00709 00716 struct libusb_transfer { 00718 libusb_device_handle *dev_handle; 00719 00721 uint8_t flags; 00722 00724 unsigned char endpoint; 00725 00727 unsigned char type; 00728 00731 unsigned int timeout; 00732 00740 enum libusb_transfer_status status; 00741 00743 int length; 00744 00748 int actual_length; 00749 00752 libusb_transfer_cb_fn callback; 00753 00755 void *user_data; 00756 00758 unsigned char *buffer; 00759 00762 int num_iso_packets; 00763 00765 struct libusb_iso_packet_descriptor iso_packet_desc 00766 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) 00767 [] /* valid C99 code */ 00768 #else 00769 [0] /* non-standard, but usually working code */ 00770 #endif 00771 ; 00772 }; 00773 00774 int libusb_init(libusb_context **ctx); 00775 void libusb_exit(libusb_context *ctx); 00776 void libusb_set_debug(libusb_context *ctx, int level); 00777 00778 ssize_t libusb_get_device_list(libusb_context *ctx, 00779 libusb_device ***list); 00780 void libusb_free_device_list(libusb_device **list, int unref_devices); 00781 libusb_device *libusb_ref_device(libusb_device *dev); 00782 void libusb_unref_device(libusb_device *dev); 00783 00784 int libusb_get_configuration(libusb_device_handle *dev, int *config); 00785 int libusb_get_device_descriptor(libusb_device *dev, 00786 struct libusb_device_descriptor *desc); 00787 int libusb_get_active_config_descriptor(libusb_device *dev, 00788 struct libusb_config_descriptor **config); 00789 int libusb_get_config_descriptor(libusb_device *dev, uint8_t config_index, 00790 struct libusb_config_descriptor **config); 00791 int libusb_get_config_descriptor_by_value(libusb_device *dev, 00792 uint8_t bConfigurationValue, struct libusb_config_descriptor **config); 00793 void libusb_free_config_descriptor(struct libusb_config_descriptor *config); 00794 uint8_t libusb_get_bus_number(libusb_device *dev); 00795 uint8_t libusb_get_device_address(libusb_device *dev); 00796 int libusb_get_max_packet_size(libusb_device *dev, unsigned char endpoint); 00797 int libusb_get_max_iso_packet_size(libusb_device *dev, unsigned char endpoint); 00798 00799 int libusb_open(libusb_device *dev, libusb_device_handle **handle); 00800 void libusb_close(libusb_device_handle *dev_handle); 00801 libusb_device *libusb_get_device(libusb_device_handle *dev_handle); 00802 00803 int libusb_set_configuration(libusb_device_handle *dev, int configuration); 00804 int libusb_claim_interface(libusb_device_handle *dev, int iface); 00805 int libusb_release_interface(libusb_device_handle *dev, int iface); 00806 00807 libusb_device_handle *libusb_open_device_with_vid_pid(libusb_context *ctx, 00808 uint16_t vendor_id, uint16_t product_id); 00809 00810 int libusb_set_interface_alt_setting(libusb_device_handle *dev, 00811 int interface_number, int alternate_setting); 00812 int libusb_clear_halt(libusb_device_handle *dev, unsigned char endpoint); 00813 int libusb_reset_device(libusb_device_handle *dev); 00814 00815 int libusb_kernel_driver_active(libusb_device_handle *dev, int interface); 00816 int libusb_detach_kernel_driver(libusb_device_handle *dev, int interface); 00817 int libusb_attach_kernel_driver(libusb_device_handle *dev, int interface); 00818 00819 /* async I/O */ 00820 00833 static inline unsigned char *libusb_control_transfer_get_data( 00834 struct libusb_transfer *transfer) 00835 { 00836 return transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE; 00837 } 00838 00851 static inline struct libusb_control_setup *libusb_control_transfer_get_setup( 00852 struct libusb_transfer *transfer) 00853 { 00854 return (struct libusb_control_setup *) transfer->buffer; 00855 } 00856 00879 static inline void libusb_fill_control_setup(unsigned char *buffer, 00880 uint8_t bmRequestType, uint8_t bRequest, uint16_t wValue, uint16_t wIndex, 00881 uint16_t wLength) 00882 { 00883 struct libusb_control_setup *setup = (struct libusb_control_setup *) buffer; 00884 setup->bmRequestType = bmRequestType; 00885 setup->bRequest = bRequest; 00886 setup->wValue = libusb_cpu_to_le16(wValue); 00887 setup->wIndex = libusb_cpu_to_le16(wIndex); 00888 setup->wLength = libusb_cpu_to_le16(wLength); 00889 } 00890 00891 struct libusb_transfer *libusb_alloc_transfer(int iso_packets); 00892 int libusb_submit_transfer(struct libusb_transfer *transfer); 00893 int libusb_cancel_transfer(struct libusb_transfer *transfer); 00894 void libusb_free_transfer(struct libusb_transfer *transfer); 00895 00923 static inline void libusb_fill_control_transfer( 00924 struct libusb_transfer *transfer, libusb_device_handle *dev_handle, 00925 unsigned char *buffer, libusb_transfer_cb_fn callback, void *user_data, 00926 unsigned int timeout) 00927 { 00928 struct libusb_control_setup *setup = (struct libusb_control_setup *) buffer; 00929 transfer->dev_handle = dev_handle; 00930 transfer->endpoint = 0; 00931 transfer->type = LIBUSB_TRANSFER_TYPE_CONTROL; 00932 transfer->timeout = timeout; 00933 transfer->buffer = buffer; 00934 if (setup) 00935 transfer->length = LIBUSB_CONTROL_SETUP_SIZE 00936 + libusb_le16_to_cpu(setup->wLength); 00937 transfer->user_data = user_data; 00938 transfer->callback = callback; 00939 } 00940 00954 static inline void libusb_fill_bulk_transfer(struct libusb_transfer *transfer, 00955 libusb_device_handle *dev_handle, unsigned char endpoint, 00956 unsigned char *buffer, int length, libusb_transfer_cb_fn callback, 00957 void *user_data, unsigned int timeout) 00958 { 00959 transfer->dev_handle = dev_handle; 00960 transfer->endpoint = endpoint; 00961 transfer->type = LIBUSB_TRANSFER_TYPE_BULK; 00962 transfer->timeout = timeout; 00963 transfer->buffer = buffer; 00964 transfer->length = length; 00965 transfer->user_data = user_data; 00966 transfer->callback = callback; 00967 } 00968 00982 static inline void libusb_fill_interrupt_transfer( 00983 struct libusb_transfer *transfer, libusb_device_handle *dev_handle, 00984 unsigned char endpoint, unsigned char *buffer, int length, 00985 libusb_transfer_cb_fn callback, void *user_data, unsigned int timeout) 00986 { 00987 transfer->dev_handle = dev_handle; 00988 transfer->endpoint = endpoint; 00989 transfer->type = LIBUSB_TRANSFER_TYPE_INTERRUPT; 00990 transfer->timeout = timeout; 00991 transfer->buffer = buffer; 00992 transfer->length = length; 00993 transfer->user_data = user_data; 00994 transfer->callback = callback; 00995 } 00996 01011 static inline void libusb_fill_iso_transfer(struct libusb_transfer *transfer, 01012 libusb_device_handle *dev_handle, unsigned char endpoint, 01013 unsigned char *buffer, int length, int num_iso_packets, 01014 libusb_transfer_cb_fn callback, void *user_data, unsigned int timeout) 01015 { 01016 transfer->dev_handle = dev_handle; 01017 transfer->endpoint = endpoint; 01018 transfer->type = LIBUSB_TRANSFER_TYPE_ISOCHRONOUS; 01019 transfer->timeout = timeout; 01020 transfer->buffer = buffer; 01021 transfer->length = length; 01022 transfer->num_iso_packets = num_iso_packets; 01023 transfer->user_data = user_data; 01024 transfer->callback = callback; 01025 } 01026 01035 static inline void libusb_set_iso_packet_lengths( 01036 struct libusb_transfer *transfer, unsigned int length) 01037 { 01038 int i; 01039 for (i = 0; i < transfer->num_iso_packets; i++) 01040 transfer->iso_packet_desc[i].length = length; 01041 } 01042 01059 static inline unsigned char *libusb_get_iso_packet_buffer( 01060 struct libusb_transfer *transfer, unsigned int packet) 01061 { 01062 int i; 01063 size_t offset = 0; 01064 int _packet; 01065 01066 /* oops..slight bug in the API. packet is an unsigned int, but we use 01067 * signed integers almost everywhere else. range-check and convert to 01068 * signed to avoid compiler warnings. FIXME for libusb-2. */ 01069 if (packet > INT_MAX) 01070 return NULL; 01071 _packet = packet; 01072 01073 if (_packet >= transfer->num_iso_packets) 01074 return NULL; 01075 01076 for (i = 0; i < _packet; i++) 01077 offset += transfer->iso_packet_desc[i].length; 01078 01079 return transfer->buffer + offset; 01080 } 01081 01101 static inline unsigned char *libusb_get_iso_packet_buffer_simple( 01102 struct libusb_transfer *transfer, unsigned int packet) 01103 { 01104 int _packet; 01105 01106 /* oops..slight bug in the API. packet is an unsigned int, but we use 01107 * signed integers almost everywhere else. range-check and convert to 01108 * signed to avoid compiler warnings. FIXME for libusb-2. */ 01109 if (packet > INT_MAX) 01110 return NULL; 01111 _packet = packet; 01112 01113 if (_packet >= transfer->num_iso_packets) 01114 return NULL; 01115 01116 return transfer->buffer + (transfer->iso_packet_desc[0].length * _packet); 01117 } 01118 01119 /* sync I/O */ 01120 01121 int libusb_control_transfer(libusb_device_handle *dev_handle, 01122 uint8_t request_type, uint8_t request, uint16_t value, uint16_t index, 01123 unsigned char *data, uint16_t length, unsigned int timeout); 01124 01125 int libusb_bulk_transfer(libusb_device_handle *dev_handle, 01126 unsigned char endpoint, unsigned char *data, int length, 01127 int *actual_length, unsigned int timeout); 01128 01129 int libusb_interrupt_transfer(libusb_device_handle *dev_handle, 01130 unsigned char endpoint, unsigned char *data, int length, 01131 int *actual_length, unsigned int timeout); 01132 01145 static inline int libusb_get_descriptor(libusb_device_handle *dev, 01146 uint8_t desc_type, uint8_t desc_index, unsigned char *data, int length) 01147 { 01148 return libusb_control_transfer(dev, LIBUSB_ENDPOINT_IN, 01149 LIBUSB_REQUEST_GET_DESCRIPTOR, (desc_type << 8) | desc_index, 0, data, 01150 length, 1000); 01151 } 01152 01167 static inline int libusb_get_string_descriptor(libusb_device_handle *dev, 01168 uint8_t desc_index, uint16_t langid, unsigned char *data, int length) 01169 { 01170 return libusb_control_transfer(dev, LIBUSB_ENDPOINT_IN, 01171 LIBUSB_REQUEST_GET_DESCRIPTOR, (LIBUSB_DT_STRING << 8) | desc_index, 01172 langid, data, length, 1000); 01173 } 01174 01175 int libusb_get_string_descriptor_ascii(libusb_device_handle *dev, 01176 uint8_t index, unsigned char *data, int length); 01177 01178 /* polling and timeouts */ 01179 01180 int libusb_try_lock_events(libusb_context *ctx); 01181 void libusb_lock_events(libusb_context *ctx); 01182 void libusb_unlock_events(libusb_context *ctx); 01183 int libusb_event_handling_ok(libusb_context *ctx); 01184 int libusb_event_handler_active(libusb_context *ctx); 01185 void libusb_lock_event_waiters(libusb_context *ctx); 01186 void libusb_unlock_event_waiters(libusb_context *ctx); 01187 int libusb_wait_for_event(libusb_context *ctx, struct timeval *tv); 01188 01189 int libusb_handle_events_timeout(libusb_context *ctx, struct timeval *tv); 01190 int libusb_handle_events(libusb_context *ctx); 01191 int libusb_handle_events_locked(libusb_context *ctx, struct timeval *tv); 01192 int libusb_pollfds_handle_timeouts(libusb_context *ctx); 01193 int libusb_get_next_timeout(libusb_context *ctx, struct timeval *tv); 01194 01198 struct libusb_pollfd { 01200 int fd; 01201 01206 short events; 01207 }; 01208 01219 typedef void (*libusb_pollfd_added_cb)(int fd, short events, void *user_data); 01220 01230 typedef void (*libusb_pollfd_removed_cb)(int fd, void *user_data); 01231 01232 const struct libusb_pollfd **libusb_get_pollfds(libusb_context *ctx); 01233 void libusb_set_pollfd_notifiers(libusb_context *ctx, 01234 libusb_pollfd_added_cb added_cb, libusb_pollfd_removed_cb removed_cb, 01235 void *user_data); 01236 01237 #ifdef __cplusplus 01238 } 01239 #endif 01240 01241 #endif