libusb: libusb.h Source File

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 
00029 #ifdef __cplusplus
00030 extern "C" {
00031 #endif
00032 
00041 #define libusb_cpu_to_le16(x) ({ \
00042     union { \
00043         uint8_t  b8[2]; \
00044         uint16_t b16; \
00045     } _tmp; \
00046     uint16_t _tmp2 = (uint16_t)(x); \
00047     _tmp.b8[1] = _tmp2 >> 8; \
00048     _tmp.b8[0] = _tmp2 & 0xff; \
00049     _tmp.b16; \
00050 })
00051 
00060 #define libusb_le16_to_cpu libusb_cpu_to_le16
00061 
00062 /* standard USB stuff */
00063 
00066 enum libusb_class_code {
00071     LIBUSB_CLASS_PER_INTERFACE = 0,
00072 
00074     LIBUSB_CLASS_AUDIO = 1,
00075 
00077     LIBUSB_CLASS_COMM = 2,
00078 
00080     LIBUSB_CLASS_HID = 3,
00081 
00083     LIBUSB_CLASS_PRINTER = 7,
00084 
00086     LIBUSB_CLASS_PTP = 6,
00087 
00089     LIBUSB_CLASS_MASS_STORAGE = 8,
00090 
00092     LIBUSB_CLASS_HUB = 9,
00093 
00095     LIBUSB_CLASS_DATA = 10,
00096 
00098     LIBUSB_CLASS_VENDOR_SPEC = 0xff,
00099 };
00100 
00103 enum libusb_descriptor_type {
00105     LIBUSB_DT_DEVICE = 0x01,
00106 
00108     LIBUSB_DT_CONFIG = 0x02,
00109 
00111     LIBUSB_DT_STRING = 0x03,
00112 
00114     LIBUSB_DT_INTERFACE = 0x04,
00115 
00117     LIBUSB_DT_ENDPOINT = 0x05,
00118 
00120     LIBUSB_DT_HID = 0x21,
00121 
00123     LIBUSB_DT_REPORT = 0x22,
00124 
00126     LIBUSB_DT_PHYSICAL = 0x23,
00127 
00129     LIBUSB_DT_HUB = 0x29,
00130 };
00131 
00132 /* Descriptor sizes per descriptor type */
00133 #define LIBUSB_DT_DEVICE_SIZE           18
00134 #define LIBUSB_DT_CONFIG_SIZE           9
00135 #define LIBUSB_DT_INTERFACE_SIZE        9
00136 #define LIBUSB_DT_ENDPOINT_SIZE     7
00137 #define LIBUSB_DT_ENDPOINT_AUDIO_SIZE   9   /* Audio extension */
00138 #define LIBUSB_DT_HUB_NONVAR_SIZE       7
00139 
00140 #define LIBUSB_ENDPOINT_ADDRESS_MASK    0x0f    /* in bEndpointAddress */
00141 #define LIBUSB_ENDPOINT_DIR_MASK        0x80
00142 
00147 enum libusb_endpoint_direction {
00149     LIBUSB_ENDPOINT_IN = 0x80,
00150 
00152     LIBUSB_ENDPOINT_OUT = 0x00,
00153 };
00154 
00155 #define LIBUSB_TRANSFER_TYPE_MASK           0x03    /* in bmAttributes */
00156 
00161 enum libusb_transfer_type {
00163     LIBUSB_TRANSFER_TYPE_CONTROL = 0,
00164 
00166     LIBUSB_TRANSFER_TYPE_ISOCHRONOUS = 1,
00167 
00169     LIBUSB_TRANSFER_TYPE_BULK = 2,
00170 
00172     LIBUSB_TRANSFER_TYPE_INTERRUPT = 3,
00173 };
00174 
00177 enum libusb_standard_request {
00179     LIBUSB_REQUEST_GET_STATUS = 0x00,
00180 
00182     LIBUSB_REQUEST_CLEAR_FEATURE = 0x01,
00183 
00184     /* 0x02 is reserved */
00185 
00187     LIBUSB_REQUEST_SET_FEATURE = 0x03,
00188 
00189     /* 0x04 is reserved */
00190 
00192     LIBUSB_REQUEST_SET_ADDRESS = 0x05,
00193 
00195     LIBUSB_REQUEST_GET_DESCRIPTOR = 0x06,
00196 
00198     LIBUSB_REQUEST_SET_DESCRIPTOR = 0x07,
00199 
00201     LIBUSB_REQUEST_GET_CONFIGURATION = 0x08,
00202 
00204     LIBUSB_REQUEST_SET_CONFIGURATION = 0x09,
00205 
00207     LIBUSB_REQUEST_GET_INTERFACE = 0x0A,
00208 
00210     LIBUSB_REQUEST_SET_INTERFACE = 0x0B,
00211 
00213     LIBUSB_REQUEST_SYNCH_FRAME = 0x0C,
00214 };
00215 
00220 enum libusb_request_type {
00222     LIBUSB_REQUEST_TYPE_STANDARD = (0x00 << 5),
00223 
00225     LIBUSB_REQUEST_TYPE_CLASS = (0x01 << 5),
00226 
00228     LIBUSB_REQUEST_TYPE_VENDOR = (0x02 << 5),
00229 
00231     LIBUSB_REQUEST_TYPE_RESERVED = (0x03 << 5),
00232 };
00233 
00238 enum libusb_request_recipient {
00240     LIBUSB_RECIPIENT_DEVICE = 0x00,
00241 
00243     LIBUSB_RECIPIENT_INTERFACE = 0x01,
00244 
00246     LIBUSB_RECIPIENT_ENDPOINT = 0x02,
00247 
00249     LIBUSB_RECIPIENT_OTHER = 0x03,
00250 };
00251 
00252 #define LIBUSB_ISO_SYNC_TYPE_MASK       0x0C
00253 
00259 enum libusb_iso_sync_type {
00261     LIBUSB_ISO_SYNC_TYPE_NONE = 0,
00262 
00264     LIBUSB_ISO_SYNC_TYPE_ASYNC = 1,
00265 
00267     LIBUSB_ISO_SYNC_TYPE_ADAPTIVE = 2,
00268 
00270     LIBUSB_ISO_SYNC_TYPE_SYNC = 3,
00271 };
00272 
00273 #define LIBUSB_ISO_USAGE_TYPE_MASK 0x30
00274 
00280 enum libusb_iso_usage_type {
00282     LIBUSB_ISO_USAGE_TYPE_DATA = 0,
00283 
00285     LIBUSB_ISO_USAGE_TYPE_FEEDBACK = 1,
00286 
00288     LIBUSB_ISO_USAGE_TYPE_IMPLICIT = 2,
00289 };
00290 
00296 struct libusb_device_descriptor {
00298     uint8_t  bLength;
00299 
00303     uint8_t  bDescriptorType;
00304 
00307     uint16_t bcdUSB;
00308 
00310     uint8_t  bDeviceClass;
00311 
00314     uint8_t  bDeviceSubClass;
00315 
00318     uint8_t  bDeviceProtocol;
00319 
00321     uint8_t  bMaxPacketSize0;
00322 
00324     uint16_t idVendor;
00325 
00327     uint16_t idProduct;
00328 
00330     uint16_t bcdDevice;
00331 
00333     uint8_t  iManufacturer;
00334 
00336     uint8_t  iProduct;
00337 
00339     uint8_t  iSerialNumber;
00340 
00342     uint8_t  bNumConfigurations;
00343 };
00344 
00350 struct libusb_endpoint_descriptor {
00352     uint8_t  bLength;
00353 
00357     uint8_t  bDescriptorType;
00358 
00363     uint8_t  bEndpointAddress;
00364 
00372     uint8_t  bmAttributes;
00373 
00375     uint16_t wMaxPacketSize;
00376 
00378     uint8_t  bInterval;
00379 
00382     uint8_t  bRefresh;
00383 
00385     uint8_t  bSynchAddress;
00386 
00389     const unsigned char *extra;
00390 
00392     int extra_length;
00393 };
00394 
00400 struct libusb_interface_descriptor {
00402     uint8_t  bLength;
00403 
00407     uint8_t  bDescriptorType;
00408 
00410     uint8_t  bInterfaceNumber;
00411 
00413     uint8_t  bAlternateSetting;
00414 
00417     uint8_t  bNumEndpoints;
00418 
00420     uint8_t  bInterfaceClass;
00421 
00424     uint8_t  bInterfaceSubClass;
00425 
00428     uint8_t  bInterfaceProtocol;
00429 
00431     uint8_t  iInterface;
00432 
00435     const struct libusb_endpoint_descriptor *endpoint;
00436 
00439     const unsigned char *extra;
00440 
00442     int extra_length;
00443 };
00444 
00448 struct libusb_interface {
00451     const struct libusb_interface_descriptor *altsetting;
00452 
00454     int num_altsetting;
00455 };
00456 
00462 struct libusb_config_descriptor {
00464     uint8_t  bLength;
00465 
00469     uint8_t  bDescriptorType;
00470 
00472     uint16_t wTotalLength;
00473 
00475     uint8_t  bNumInterfaces;
00476 
00478     uint8_t  bConfigurationValue;
00479 
00481     uint8_t  iConfiguration;
00482 
00484     uint8_t  bmAttributes;
00485 
00489     uint8_t  MaxPower;
00490 
00493     const struct libusb_interface *interface;
00494 
00497     const unsigned char *extra;
00498 
00500     int extra_length;
00501 };
00502 
00505 struct libusb_control_setup {
00511     uint8_t  bmRequestType;
00512 
00518     uint8_t  bRequest;
00519 
00521     uint16_t wValue;
00522 
00525     uint16_t wIndex;
00526 
00528     uint16_t wLength;
00529 };
00530 
00531 #define LIBUSB_CONTROL_SETUP_SIZE (sizeof(struct libusb_control_setup))
00532 
00533 /* libusb */
00534 
00535 struct libusb_context;
00536 struct libusb_device;
00537 struct libusb_device_handle;
00538 
00556 typedef struct libusb_context libusb_context;
00557 
00573 typedef struct libusb_device libusb_device;
00574 
00575 
00584 typedef struct libusb_device_handle libusb_device_handle;
00585 
00590 enum libusb_error {
00592     LIBUSB_SUCCESS = 0,
00593 
00595     LIBUSB_ERROR_IO = -1,
00596 
00598     LIBUSB_ERROR_INVALID_PARAM = -2,
00599 
00601     LIBUSB_ERROR_ACCESS = -3,
00602 
00604     LIBUSB_ERROR_NO_DEVICE = -4,
00605 
00607     LIBUSB_ERROR_NOT_FOUND = -5,
00608 
00610     LIBUSB_ERROR_BUSY = -6,
00611 
00613     LIBUSB_ERROR_TIMEOUT = -7,
00614 
00616     LIBUSB_ERROR_OVERFLOW = -8,
00617 
00619     LIBUSB_ERROR_PIPE = -9,
00620 
00622     LIBUSB_ERROR_INTERRUPTED = -10,
00623 
00625     LIBUSB_ERROR_NO_MEM = -11,
00626 
00628     LIBUSB_ERROR_NOT_SUPPORTED = -12,
00629 
00631     LIBUSB_ERROR_OTHER = -99,
00632 };
00633 
00636 enum libusb_transfer_status {
00639     LIBUSB_TRANSFER_COMPLETED,
00640 
00642     LIBUSB_TRANSFER_ERROR,
00643 
00645     LIBUSB_TRANSFER_TIMED_OUT,
00646 
00648     LIBUSB_TRANSFER_CANCELLED,
00649 
00652     LIBUSB_TRANSFER_STALL,
00653 
00655     LIBUSB_TRANSFER_NO_DEVICE,
00656 
00658     LIBUSB_TRANSFER_OVERFLOW,
00659 };
00660 
00663 enum libusb_transfer_flags {
00665     LIBUSB_TRANSFER_SHORT_NOT_OK = 1<<0,
00666 
00668     LIBUSB_TRANSFER_FREE_BUFFER = 1<<1,
00669 
00674     LIBUSB_TRANSFER_FREE_TRANSFER = 1<<2,
00675 };
00676 
00679 struct libusb_iso_packet_descriptor {
00681     unsigned int length;
00682 
00684     unsigned int actual_length;
00685 
00687     enum libusb_transfer_status status;
00688 };
00689 
00690 struct libusb_transfer;
00691 
00701 typedef void (*libusb_transfer_cb_fn)(struct libusb_transfer *transfer);
00702 
00709 struct libusb_transfer {
00711     libusb_device_handle *dev_handle;
00712 
00714     uint8_t flags;
00715 
00717     unsigned char endpoint;
00718 
00720     unsigned char type;
00721 
00724     unsigned int timeout;
00725 
00733     enum libusb_transfer_status status;
00734 
00736     int length;
00737 
00741     int actual_length;
00742 
00745     libusb_transfer_cb_fn callback;
00746 
00748     void *user_data;
00749 
00751     unsigned char *buffer;
00752 
00755     int num_iso_packets;
00756 
00758     struct libusb_iso_packet_descriptor iso_packet_desc
00759 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
00760     [] /* valid C99 code */
00761 #else
00762     [0] /* non-standard, but usually working code */
00763 #endif
00764     ;
00765 };
00766 
00767 int libusb_init(libusb_context **ctx);
00768 void libusb_exit(libusb_context *ctx);
00769 void libusb_set_debug(libusb_context *ctx, int level);
00770 
00771 ssize_t libusb_get_device_list(libusb_context *ctx,
00772     libusb_device ***list);
00773 void libusb_free_device_list(libusb_device **list, int unref_devices);
00774 libusb_device *libusb_ref_device(libusb_device *dev);
00775 void libusb_unref_device(libusb_device *dev);
00776 
00777 int libusb_get_configuration(libusb_device_handle *dev, int *config);
00778 int libusb_get_device_descriptor(libusb_device *dev,
00779     struct libusb_device_descriptor *desc);
00780 int libusb_get_active_config_descriptor(libusb_device *dev,
00781     struct libusb_config_descriptor **config);
00782 int libusb_get_config_descriptor(libusb_device *dev, uint8_t config_index,
00783     struct libusb_config_descriptor **config);
00784 int libusb_get_config_descriptor_by_value(libusb_device *dev,
00785     uint8_t bConfigurationValue, struct libusb_config_descriptor **config);
00786 void libusb_free_config_descriptor(struct libusb_config_descriptor *config);
00787 uint8_t libusb_get_bus_number(libusb_device *dev);
00788 uint8_t libusb_get_device_address(libusb_device *dev);
00789 int libusb_get_max_packet_size(libusb_device *dev, unsigned char endpoint);
00790 
00791 int libusb_open(libusb_device *dev, libusb_device_handle **handle);
00792 void libusb_close(libusb_device_handle *dev_handle);
00793 libusb_device *libusb_get_device(libusb_device_handle *dev_handle);
00794 
00795 int libusb_set_configuration(libusb_device_handle *dev, int configuration);
00796 int libusb_claim_interface(libusb_device_handle *dev, int iface);
00797 int libusb_release_interface(libusb_device_handle *dev, int iface);
00798 
00799 libusb_device_handle *libusb_open_device_with_vid_pid(libusb_context *ctx,
00800     uint16_t vendor_id, uint16_t product_id);
00801 
00802 int libusb_set_interface_alt_setting(libusb_device_handle *dev,
00803     int interface_number, int alternate_setting);
00804 int libusb_clear_halt(libusb_device_handle *dev, unsigned char endpoint);
00805 int libusb_reset_device(libusb_device_handle *dev);
00806 
00807 int libusb_kernel_driver_active(libusb_device_handle *dev, int interface);
00808 int libusb_detach_kernel_driver(libusb_device_handle *dev, int interface);
00809 int libusb_attach_kernel_driver(libusb_device_handle *dev, int interface);
00810 
00811 /* async I/O */
00812 
00825 static inline unsigned char *libusb_control_transfer_get_data(
00826     struct libusb_transfer *transfer)
00827 {
00828     return transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE;
00829 }
00830 
00843 static inline struct libusb_control_setup *libusb_control_transfer_get_setup(
00844     struct libusb_transfer *transfer)
00845 {
00846     return (struct libusb_control_setup *) transfer->buffer;
00847 }
00848 
00871 static inline void libusb_fill_control_setup(unsigned char *buffer,
00872     uint8_t bmRequestType, uint8_t bRequest, uint16_t wValue, uint16_t wIndex,
00873     uint16_t wLength)
00874 {
00875     struct libusb_control_setup *setup = (struct libusb_control_setup *) buffer;
00876     setup->bmRequestType = bmRequestType;
00877     setup->bRequest = bRequest;
00878     setup->wValue = libusb_cpu_to_le16(wValue);
00879     setup->wIndex = libusb_cpu_to_le16(wIndex);
00880     setup->wLength = libusb_cpu_to_le16(wLength);
00881 }
00882 
00883 struct libusb_transfer *libusb_alloc_transfer(int iso_packets);
00884 int libusb_submit_transfer(struct libusb_transfer *transfer);
00885 int libusb_cancel_transfer(struct libusb_transfer *transfer);
00886 void libusb_free_transfer(struct libusb_transfer *transfer);
00887 
00915 static inline void libusb_fill_control_transfer(
00916     struct libusb_transfer *transfer, libusb_device_handle *dev_handle,
00917     unsigned char *buffer, libusb_transfer_cb_fn callback, void *user_data,
00918     unsigned int timeout)
00919 {
00920     struct libusb_control_setup *setup = (struct libusb_control_setup *) buffer;
00921     transfer->dev_handle = dev_handle;
00922     transfer->endpoint = 0;
00923     transfer->type = LIBUSB_TRANSFER_TYPE_CONTROL;
00924     transfer->timeout = timeout;
00925     transfer->buffer = buffer;
00926     if (setup)
00927         transfer->length = LIBUSB_CONTROL_SETUP_SIZE
00928             + libusb_le16_to_cpu(setup->wLength);
00929     transfer->user_data = user_data;
00930     transfer->callback = callback;
00931 }
00932 
00946 static inline void libusb_fill_bulk_transfer(struct libusb_transfer *transfer,
00947     libusb_device_handle *dev_handle, unsigned char endpoint,
00948     unsigned char *buffer, int length, libusb_transfer_cb_fn callback,
00949     void *user_data, unsigned int timeout)
00950 {
00951     transfer->dev_handle = dev_handle;
00952     transfer->endpoint = endpoint;
00953     transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
00954     transfer->timeout = timeout;
00955     transfer->buffer = buffer;
00956     transfer->length = length;
00957     transfer->user_data = user_data;
00958     transfer->callback = callback;
00959 }
00960 
00974 static inline void libusb_fill_interrupt_transfer(
00975     struct libusb_transfer *transfer, libusb_device_handle *dev_handle,
00976     unsigned char endpoint, unsigned char *buffer, int length,
00977     libusb_transfer_cb_fn callback, void *user_data, unsigned int timeout)
00978 {
00979     transfer->dev_handle = dev_handle;
00980     transfer->endpoint = endpoint;
00981     transfer->type = LIBUSB_TRANSFER_TYPE_INTERRUPT;
00982     transfer->timeout = timeout;
00983     transfer->buffer = buffer;
00984     transfer->length = length;
00985     transfer->user_data = user_data;
00986     transfer->callback = callback;
00987 }
00988 
01003 static inline void libusb_fill_iso_transfer(struct libusb_transfer *transfer,
01004     libusb_device_handle *dev_handle, unsigned char endpoint,
01005     unsigned char *buffer, int length, int num_iso_packets,
01006     libusb_transfer_cb_fn callback, void *user_data, unsigned int timeout)
01007 {
01008     transfer->dev_handle = dev_handle;
01009     transfer->endpoint = endpoint;
01010     transfer->type = LIBUSB_TRANSFER_TYPE_ISOCHRONOUS;
01011     transfer->timeout = timeout;
01012     transfer->buffer = buffer;
01013     transfer->length = length;
01014     transfer->num_iso_packets = num_iso_packets;
01015     transfer->user_data = user_data;
01016     transfer->callback = callback;
01017 }
01018 
01027 static inline void libusb_set_iso_packet_lengths(
01028     struct libusb_transfer *transfer, unsigned int length)
01029 {
01030     int i;
01031     for (i = 0; i < transfer->num_iso_packets; i++)
01032         transfer->iso_packet_desc[i].length = length;
01033 }
01034 
01051 static inline unsigned char *libusb_get_iso_packet_buffer(
01052     struct libusb_transfer *transfer, unsigned int packet)
01053 {
01054     int i;
01055     size_t offset = 0;
01056 
01057     if (packet >= transfer->num_iso_packets)
01058         return NULL;
01059 
01060     for (i = 0; i < packet; i++)
01061         offset += transfer->iso_packet_desc[i].length;
01062 
01063     return transfer->buffer + offset;
01064 }
01065 
01085 static inline unsigned char *libusb_get_iso_packet_buffer_simple(
01086     struct libusb_transfer *transfer, unsigned int packet)
01087 {
01088     if (packet >= transfer->num_iso_packets)
01089         return NULL;
01090 
01091     return transfer->buffer + (transfer->iso_packet_desc[0].length * packet);
01092 }
01093 
01094 /* sync I/O */
01095 
01096 int libusb_control_transfer(libusb_device_handle *dev_handle,
01097     uint8_t request_type, uint8_t request, uint16_t value, uint16_t index,
01098     unsigned char *data, uint16_t length, unsigned int timeout);
01099 
01100 int libusb_bulk_transfer(libusb_device_handle *dev_handle,
01101     unsigned char endpoint, unsigned char *data, int length,
01102     int *actual_length, unsigned int timeout);
01103 
01104 int libusb_interrupt_transfer(libusb_device_handle *dev_handle,
01105     unsigned char endpoint, unsigned char *data, int length,
01106     int *actual_length, unsigned int timeout);
01107 
01120 static inline int libusb_get_descriptor(libusb_device_handle *dev,
01121     uint8_t desc_type, uint8_t desc_index, unsigned char *data, int length)
01122 {
01123     return libusb_control_transfer(dev, LIBUSB_ENDPOINT_IN,
01124         LIBUSB_REQUEST_GET_DESCRIPTOR, (desc_type << 8) | desc_index, 0, data,
01125         length, 1000);
01126 }
01127 
01142 static inline int libusb_get_string_descriptor(libusb_device_handle *dev,
01143     uint8_t desc_index, uint16_t langid, unsigned char *data, int length)
01144 {
01145     return libusb_control_transfer(dev, LIBUSB_ENDPOINT_IN,
01146         LIBUSB_REQUEST_GET_DESCRIPTOR, (LIBUSB_DT_STRING << 8) | desc_index,
01147         langid, data, length, 1000);
01148 }
01149 
01150 int libusb_get_string_descriptor_ascii(libusb_device_handle *dev,
01151     uint8_t index, unsigned char *data, int length);
01152 
01153 /* polling and timeouts */
01154 
01155 int libusb_try_lock_events(libusb_context *ctx);
01156 void libusb_lock_events(libusb_context *ctx);
01157 void libusb_unlock_events(libusb_context *ctx);
01158 int libusb_event_handling_ok(libusb_context *ctx);
01159 int libusb_event_handler_active(libusb_context *ctx);
01160 void libusb_lock_event_waiters(libusb_context *ctx);
01161 void libusb_unlock_event_waiters(libusb_context *ctx);
01162 int libusb_wait_for_event(libusb_context *ctx, struct timeval *tv);
01163 
01164 int libusb_handle_events_timeout(libusb_context *ctx, struct timeval *tv);
01165 int libusb_handle_events(libusb_context *ctx);
01166 int libusb_handle_events_locked(libusb_context *ctx, struct timeval *tv);
01167 int libusb_get_next_timeout(libusb_context *ctx, struct timeval *tv);
01168 
01172 struct libusb_pollfd {
01174     int fd;
01175 
01180     short events;
01181 };
01182 
01193 typedef void (*libusb_pollfd_added_cb)(int fd, short events, void *user_data);
01194 
01204 typedef void (*libusb_pollfd_removed_cb)(int fd, void *user_data);
01205 
01206 const struct libusb_pollfd **libusb_get_pollfds(libusb_context *ctx);
01207 void libusb_set_pollfd_notifiers(libusb_context *ctx,
01208     libusb_pollfd_added_cb added_cb, libusb_pollfd_removed_cb removed_cb,
01209     void *user_data);
01210 
01211 #ifdef __cplusplus
01212 }
01213 #endif
01214 
01215 #endif