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 #include <limits.h>
00029 
00030 #ifdef __cplusplus
00031 extern "C" {
00032 #endif
00033 
00042 #define libusb_cpu_to_le16(x) ({ \
00043     union { \
00044         uint8_t  b8[2]; \
00045         uint16_t b16; \
00046     } _tmp; \
00047     uint16_t _tmp2 = (uint16_t)(x); \
00048     _tmp.b8[1] = _tmp2 >> 8; \
00049     _tmp.b8[0] = _tmp2 & 0xff; \
00050     _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_VENDOR_SPEC = 0xff,
00100 };
00101 
00104 enum libusb_descriptor_type {
00106     LIBUSB_DT_DEVICE = 0x01,
00107 
00109     LIBUSB_DT_CONFIG = 0x02,
00110 
00112     LIBUSB_DT_STRING = 0x03,
00113 
00115     LIBUSB_DT_INTERFACE = 0x04,
00116 
00118     LIBUSB_DT_ENDPOINT = 0x05,
00119 
00121     LIBUSB_DT_HID = 0x21,
00122 
00124     LIBUSB_DT_REPORT = 0x22,
00125 
00127     LIBUSB_DT_PHYSICAL = 0x23,
00128 
00130     LIBUSB_DT_HUB = 0x29,
00131 };
00132 
00133 /* Descriptor sizes per descriptor type */
00134 #define LIBUSB_DT_DEVICE_SIZE           18
00135 #define LIBUSB_DT_CONFIG_SIZE           9
00136 #define LIBUSB_DT_INTERFACE_SIZE        9
00137 #define LIBUSB_DT_ENDPOINT_SIZE     7
00138 #define LIBUSB_DT_ENDPOINT_AUDIO_SIZE   9   /* Audio extension */
00139 #define LIBUSB_DT_HUB_NONVAR_SIZE       7
00140 
00141 #define LIBUSB_ENDPOINT_ADDRESS_MASK    0x0f    /* in bEndpointAddress */
00142 #define LIBUSB_ENDPOINT_DIR_MASK        0x80
00143 
00148 enum libusb_endpoint_direction {
00150     LIBUSB_ENDPOINT_IN = 0x80,
00151 
00153     LIBUSB_ENDPOINT_OUT = 0x00,
00154 };
00155 
00156 #define LIBUSB_TRANSFER_TYPE_MASK           0x03    /* in bmAttributes */
00157 
00162 enum libusb_transfer_type {
00164     LIBUSB_TRANSFER_TYPE_CONTROL = 0,
00165 
00167     LIBUSB_TRANSFER_TYPE_ISOCHRONOUS = 1,
00168 
00170     LIBUSB_TRANSFER_TYPE_BULK = 2,
00171 
00173     LIBUSB_TRANSFER_TYPE_INTERRUPT = 3,
00174 };
00175 
00178 enum libusb_standard_request {
00180     LIBUSB_REQUEST_GET_STATUS = 0x00,
00181 
00183     LIBUSB_REQUEST_CLEAR_FEATURE = 0x01,
00184 
00185     /* 0x02 is reserved */
00186 
00188     LIBUSB_REQUEST_SET_FEATURE = 0x03,
00189 
00190     /* 0x04 is reserved */
00191 
00193     LIBUSB_REQUEST_SET_ADDRESS = 0x05,
00194 
00196     LIBUSB_REQUEST_GET_DESCRIPTOR = 0x06,
00197 
00199     LIBUSB_REQUEST_SET_DESCRIPTOR = 0x07,
00200 
00202     LIBUSB_REQUEST_GET_CONFIGURATION = 0x08,
00203 
00205     LIBUSB_REQUEST_SET_CONFIGURATION = 0x09,
00206 
00208     LIBUSB_REQUEST_GET_INTERFACE = 0x0A,
00209 
00211     LIBUSB_REQUEST_SET_INTERFACE = 0x0B,
00212 
00214     LIBUSB_REQUEST_SYNCH_FRAME = 0x0C,
00215 };
00216 
00221 enum libusb_request_type {
00223     LIBUSB_REQUEST_TYPE_STANDARD = (0x00 << 5),
00224 
00226     LIBUSB_REQUEST_TYPE_CLASS = (0x01 << 5),
00227 
00229     LIBUSB_REQUEST_TYPE_VENDOR = (0x02 << 5),
00230 
00232     LIBUSB_REQUEST_TYPE_RESERVED = (0x03 << 5),
00233 };
00234 
00239 enum libusb_request_recipient {
00241     LIBUSB_RECIPIENT_DEVICE = 0x00,
00242 
00244     LIBUSB_RECIPIENT_INTERFACE = 0x01,
00245 
00247     LIBUSB_RECIPIENT_ENDPOINT = 0x02,
00248 
00250     LIBUSB_RECIPIENT_OTHER = 0x03,
00251 };
00252 
00253 #define LIBUSB_ISO_SYNC_TYPE_MASK       0x0C
00254 
00260 enum libusb_iso_sync_type {
00262     LIBUSB_ISO_SYNC_TYPE_NONE = 0,
00263 
00265     LIBUSB_ISO_SYNC_TYPE_ASYNC = 1,
00266 
00268     LIBUSB_ISO_SYNC_TYPE_ADAPTIVE = 2,
00269 
00271     LIBUSB_ISO_SYNC_TYPE_SYNC = 3,
00272 };
00273 
00274 #define LIBUSB_ISO_USAGE_TYPE_MASK 0x30
00275 
00281 enum libusb_iso_usage_type {
00283     LIBUSB_ISO_USAGE_TYPE_DATA = 0,
00284 
00286     LIBUSB_ISO_USAGE_TYPE_FEEDBACK = 1,
00287 
00289     LIBUSB_ISO_USAGE_TYPE_IMPLICIT = 2,
00290 };
00291 
00297 struct libusb_device_descriptor {
00299     uint8_t  bLength;
00300 
00304     uint8_t  bDescriptorType;
00305 
00308     uint16_t bcdUSB;
00309 
00311     uint8_t  bDeviceClass;
00312 
00315     uint8_t  bDeviceSubClass;
00316 
00319     uint8_t  bDeviceProtocol;
00320 
00322     uint8_t  bMaxPacketSize0;
00323 
00325     uint16_t idVendor;
00326 
00328     uint16_t idProduct;
00329 
00331     uint16_t bcdDevice;
00332 
00334     uint8_t  iManufacturer;
00335 
00337     uint8_t  iProduct;
00338 
00340     uint8_t  iSerialNumber;
00341 
00343     uint8_t  bNumConfigurations;
00344 };
00345 
00351 struct libusb_endpoint_descriptor {
00353     uint8_t  bLength;
00354 
00358     uint8_t  bDescriptorType;
00359 
00364     uint8_t  bEndpointAddress;
00365 
00373     uint8_t  bmAttributes;
00374 
00376     uint16_t wMaxPacketSize;
00377 
00379     uint8_t  bInterval;
00380 
00383     uint8_t  bRefresh;
00384 
00386     uint8_t  bSynchAddress;
00387 
00390     const unsigned char *extra;
00391 
00393     int extra_length;
00394 };
00395 
00401 struct libusb_interface_descriptor {
00403     uint8_t  bLength;
00404 
00408     uint8_t  bDescriptorType;
00409 
00411     uint8_t  bInterfaceNumber;
00412 
00414     uint8_t  bAlternateSetting;
00415 
00418     uint8_t  bNumEndpoints;
00419 
00421     uint8_t  bInterfaceClass;
00422 
00425     uint8_t  bInterfaceSubClass;
00426 
00429     uint8_t  bInterfaceProtocol;
00430 
00432     uint8_t  iInterface;
00433 
00436     const struct libusb_endpoint_descriptor *endpoint;
00437 
00440     const unsigned char *extra;
00441 
00443     int extra_length;
00444 };
00445 
00449 struct libusb_interface {
00452     const struct libusb_interface_descriptor *altsetting;
00453 
00455     int num_altsetting;
00456 };
00457 
00463 struct libusb_config_descriptor {
00465     uint8_t  bLength;
00466 
00470     uint8_t  bDescriptorType;
00471 
00473     uint16_t wTotalLength;
00474 
00476     uint8_t  bNumInterfaces;
00477 
00479     uint8_t  bConfigurationValue;
00480 
00482     uint8_t  iConfiguration;
00483 
00485     uint8_t  bmAttributes;
00486 
00490     uint8_t  MaxPower;
00491 
00494     const struct libusb_interface *interface;
00495 
00498     const unsigned char *extra;
00499 
00501     int extra_length;
00502 };
00503 
00506 struct libusb_control_setup {
00512     uint8_t  bmRequestType;
00513 
00519     uint8_t  bRequest;
00520 
00522     uint16_t wValue;
00523 
00526     uint16_t wIndex;
00527 
00529     uint16_t wLength;
00530 };
00531 
00532 #define LIBUSB_CONTROL_SETUP_SIZE (sizeof(struct libusb_control_setup))
00533 
00534 /* libusb */
00535 
00536 struct libusb_context;
00537 struct libusb_device;
00538 struct libusb_device_handle;
00539 
00557 typedef struct libusb_context libusb_context;
00558 
00574 typedef struct libusb_device libusb_device;
00575 
00576 
00585 typedef struct libusb_device_handle libusb_device_handle;
00586 
00591 enum libusb_error {
00593     LIBUSB_SUCCESS = 0,
00594 
00596     LIBUSB_ERROR_IO = -1,
00597 
00599     LIBUSB_ERROR_INVALID_PARAM = -2,
00600 
00602     LIBUSB_ERROR_ACCESS = -3,
00603 
00605     LIBUSB_ERROR_NO_DEVICE = -4,
00606 
00608     LIBUSB_ERROR_NOT_FOUND = -5,
00609 
00611     LIBUSB_ERROR_BUSY = -6,
00612 
00614     LIBUSB_ERROR_TIMEOUT = -7,
00615 
00617     LIBUSB_ERROR_OVERFLOW = -8,
00618 
00620     LIBUSB_ERROR_PIPE = -9,
00621 
00623     LIBUSB_ERROR_INTERRUPTED = -10,
00624 
00626     LIBUSB_ERROR_NO_MEM = -11,
00627 
00629     LIBUSB_ERROR_NOT_SUPPORTED = -12,
00630 
00632     LIBUSB_ERROR_OTHER = -99,
00633 };
00634 
00637 enum libusb_transfer_status {
00640     LIBUSB_TRANSFER_COMPLETED,
00641 
00643     LIBUSB_TRANSFER_ERROR,
00644 
00646     LIBUSB_TRANSFER_TIMED_OUT,
00647 
00649     LIBUSB_TRANSFER_CANCELLED,
00650 
00653     LIBUSB_TRANSFER_STALL,
00654 
00656     LIBUSB_TRANSFER_NO_DEVICE,
00657 
00659     LIBUSB_TRANSFER_OVERFLOW,
00660 };
00661 
00664 enum libusb_transfer_flags {
00666     LIBUSB_TRANSFER_SHORT_NOT_OK = 1<<0,
00667 
00669     LIBUSB_TRANSFER_FREE_BUFFER = 1<<1,
00670 
00675     LIBUSB_TRANSFER_FREE_TRANSFER = 1<<2,
00676 };
00677 
00680 struct libusb_iso_packet_descriptor {
00682     unsigned int length;
00683 
00685     unsigned int actual_length;
00686 
00688     enum libusb_transfer_status status;
00689 };
00690 
00691 struct libusb_transfer;
00692 
00702 typedef void (*libusb_transfer_cb_fn)(struct libusb_transfer *transfer);
00703 
00710 struct libusb_transfer {
00712     libusb_device_handle *dev_handle;
00713 
00715     uint8_t flags;
00716 
00718     unsigned char endpoint;
00719 
00721     unsigned char type;
00722 
00725     unsigned int timeout;
00726 
00734     enum libusb_transfer_status status;
00735 
00737     int length;
00738 
00742     int actual_length;
00743 
00746     libusb_transfer_cb_fn callback;
00747 
00749     void *user_data;
00750 
00752     unsigned char *buffer;
00753 
00756     int num_iso_packets;
00757 
00759     struct libusb_iso_packet_descriptor iso_packet_desc
00760 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
00761     [] /* valid C99 code */
00762 #else
00763     [0] /* non-standard, but usually working code */
00764 #endif
00765     ;
00766 };
00767 
00768 int libusb_init(libusb_context **ctx);
00769 void libusb_exit(libusb_context *ctx);
00770 void libusb_set_debug(libusb_context *ctx, int level);
00771 
00772 ssize_t libusb_get_device_list(libusb_context *ctx,
00773     libusb_device ***list);
00774 void libusb_free_device_list(libusb_device **list, int unref_devices);
00775 libusb_device *libusb_ref_device(libusb_device *dev);
00776 void libusb_unref_device(libusb_device *dev);
00777 
00778 int libusb_get_configuration(libusb_device_handle *dev, int *config);
00779 int libusb_get_device_descriptor(libusb_device *dev,
00780     struct libusb_device_descriptor *desc);
00781 int libusb_get_active_config_descriptor(libusb_device *dev,
00782     struct libusb_config_descriptor **config);
00783 int libusb_get_config_descriptor(libusb_device *dev, uint8_t config_index,
00784     struct libusb_config_descriptor **config);
00785 int libusb_get_config_descriptor_by_value(libusb_device *dev,
00786     uint8_t bConfigurationValue, struct libusb_config_descriptor **config);
00787 void libusb_free_config_descriptor(struct libusb_config_descriptor *config);
00788 uint8_t libusb_get_bus_number(libusb_device *dev);
00789 uint8_t libusb_get_device_address(libusb_device *dev);
00790 int libusb_get_max_packet_size(libusb_device *dev, unsigned char endpoint);
00791 
00792 int libusb_open(libusb_device *dev, libusb_device_handle **handle);
00793 void libusb_close(libusb_device_handle *dev_handle);
00794 libusb_device *libusb_get_device(libusb_device_handle *dev_handle);
00795 
00796 int libusb_set_configuration(libusb_device_handle *dev, int configuration);
00797 int libusb_claim_interface(libusb_device_handle *dev, int iface);
00798 int libusb_release_interface(libusb_device_handle *dev, int iface);
00799 
00800 libusb_device_handle *libusb_open_device_with_vid_pid(libusb_context *ctx,
00801     uint16_t vendor_id, uint16_t product_id);
00802 
00803 int libusb_set_interface_alt_setting(libusb_device_handle *dev,
00804     int interface_number, int alternate_setting);
00805 int libusb_clear_halt(libusb_device_handle *dev, unsigned char endpoint);
00806 int libusb_reset_device(libusb_device_handle *dev);
00807 
00808 int libusb_kernel_driver_active(libusb_device_handle *dev, int interface);
00809 int libusb_detach_kernel_driver(libusb_device_handle *dev, int interface);
00810 int libusb_attach_kernel_driver(libusb_device_handle *dev, int interface);
00811 
00812 /* async I/O */
00813 
00826 static inline unsigned char *libusb_control_transfer_get_data(
00827     struct libusb_transfer *transfer)
00828 {
00829     return transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE;
00830 }
00831 
00844 static inline struct libusb_control_setup *libusb_control_transfer_get_setup(
00845     struct libusb_transfer *transfer)
00846 {
00847     return (struct libusb_control_setup *) transfer->buffer;
00848 }
00849 
00872 static inline void libusb_fill_control_setup(unsigned char *buffer,
00873     uint8_t bmRequestType, uint8_t bRequest, uint16_t wValue, uint16_t wIndex,
00874     uint16_t wLength)
00875 {
00876     struct libusb_control_setup *setup = (struct libusb_control_setup *) buffer;
00877     setup->bmRequestType = bmRequestType;
00878     setup->bRequest = bRequest;
00879     setup->wValue = libusb_cpu_to_le16(wValue);
00880     setup->wIndex = libusb_cpu_to_le16(wIndex);
00881     setup->wLength = libusb_cpu_to_le16(wLength);
00882 }
00883 
00884 struct libusb_transfer *libusb_alloc_transfer(int iso_packets);
00885 int libusb_submit_transfer(struct libusb_transfer *transfer);
00886 int libusb_cancel_transfer(struct libusb_transfer *transfer);
00887 void libusb_free_transfer(struct libusb_transfer *transfer);
00888 
00916 static inline void libusb_fill_control_transfer(
00917     struct libusb_transfer *transfer, libusb_device_handle *dev_handle,
00918     unsigned char *buffer, libusb_transfer_cb_fn callback, void *user_data,
00919     unsigned int timeout)
00920 {
00921     struct libusb_control_setup *setup = (struct libusb_control_setup *) buffer;
00922     transfer->dev_handle = dev_handle;
00923     transfer->endpoint = 0;
00924     transfer->type = LIBUSB_TRANSFER_TYPE_CONTROL;
00925     transfer->timeout = timeout;
00926     transfer->buffer = buffer;
00927     if (setup)
00928         transfer->length = LIBUSB_CONTROL_SETUP_SIZE
00929             + libusb_le16_to_cpu(setup->wLength);
00930     transfer->user_data = user_data;
00931     transfer->callback = callback;
00932 }
00933 
00947 static inline void libusb_fill_bulk_transfer(struct libusb_transfer *transfer,
00948     libusb_device_handle *dev_handle, unsigned char endpoint,
00949     unsigned char *buffer, int length, libusb_transfer_cb_fn callback,
00950     void *user_data, unsigned int timeout)
00951 {
00952     transfer->dev_handle = dev_handle;
00953     transfer->endpoint = endpoint;
00954     transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
00955     transfer->timeout = timeout;
00956     transfer->buffer = buffer;
00957     transfer->length = length;
00958     transfer->user_data = user_data;
00959     transfer->callback = callback;
00960 }
00961 
00975 static inline void libusb_fill_interrupt_transfer(
00976     struct libusb_transfer *transfer, libusb_device_handle *dev_handle,
00977     unsigned char endpoint, unsigned char *buffer, int length,
00978     libusb_transfer_cb_fn callback, void *user_data, unsigned int timeout)
00979 {
00980     transfer->dev_handle = dev_handle;
00981     transfer->endpoint = endpoint;
00982     transfer->type = LIBUSB_TRANSFER_TYPE_INTERRUPT;
00983     transfer->timeout = timeout;
00984     transfer->buffer = buffer;
00985     transfer->length = length;
00986     transfer->user_data = user_data;
00987     transfer->callback = callback;
00988 }
00989 
01004 static inline void libusb_fill_iso_transfer(struct libusb_transfer *transfer,
01005     libusb_device_handle *dev_handle, unsigned char endpoint,
01006     unsigned char *buffer, int length, int num_iso_packets,
01007     libusb_transfer_cb_fn callback, void *user_data, unsigned int timeout)
01008 {
01009     transfer->dev_handle = dev_handle;
01010     transfer->endpoint = endpoint;
01011     transfer->type = LIBUSB_TRANSFER_TYPE_ISOCHRONOUS;
01012     transfer->timeout = timeout;
01013     transfer->buffer = buffer;
01014     transfer->length = length;
01015     transfer->num_iso_packets = num_iso_packets;
01016     transfer->user_data = user_data;
01017     transfer->callback = callback;
01018 }
01019 
01028 static inline void libusb_set_iso_packet_lengths(
01029     struct libusb_transfer *transfer, unsigned int length)
01030 {
01031     int i;
01032     for (i = 0; i < transfer->num_iso_packets; i++)
01033         transfer->iso_packet_desc[i].length = length;
01034 }
01035 
01052 static inline unsigned char *libusb_get_iso_packet_buffer(
01053     struct libusb_transfer *transfer, unsigned int packet)
01054 {
01055     int i;
01056     size_t offset = 0;
01057     int _packet;
01058 
01059     /* oops..slight bug in the API. packet is an unsigned int, but we use
01060      * signed integers almost everywhere else. range-check and convert to
01061      * signed to avoid compiler warnings. FIXME for libusb-2. */
01062     if (packet > INT_MAX)
01063         return NULL;
01064     _packet = packet;
01065 
01066     if (_packet >= transfer->num_iso_packets)
01067         return NULL;
01068 
01069     for (i = 0; i < _packet; i++)
01070         offset += transfer->iso_packet_desc[i].length;
01071 
01072     return transfer->buffer + offset;
01073 }
01074 
01094 static inline unsigned char *libusb_get_iso_packet_buffer_simple(
01095     struct libusb_transfer *transfer, unsigned int packet)
01096 {
01097     int _packet;
01098 
01099     /* oops..slight bug in the API. packet is an unsigned int, but we use
01100      * signed integers almost everywhere else. range-check and convert to
01101      * signed to avoid compiler warnings. FIXME for libusb-2. */
01102     if (packet > INT_MAX)
01103         return NULL;
01104     _packet = packet;
01105 
01106     if (_packet >= transfer->num_iso_packets)
01107         return NULL;
01108 
01109     return transfer->buffer + (transfer->iso_packet_desc[0].length * _packet);
01110 }
01111 
01112 /* sync I/O */
01113 
01114 int libusb_control_transfer(libusb_device_handle *dev_handle,
01115     uint8_t request_type, uint8_t request, uint16_t value, uint16_t index,
01116     unsigned char *data, uint16_t length, unsigned int timeout);
01117 
01118 int libusb_bulk_transfer(libusb_device_handle *dev_handle,
01119     unsigned char endpoint, unsigned char *data, int length,
01120     int *actual_length, unsigned int timeout);
01121 
01122 int libusb_interrupt_transfer(libusb_device_handle *dev_handle,
01123     unsigned char endpoint, unsigned char *data, int length,
01124     int *actual_length, unsigned int timeout);
01125 
01138 static inline int libusb_get_descriptor(libusb_device_handle *dev,
01139     uint8_t desc_type, uint8_t desc_index, unsigned char *data, int length)
01140 {
01141     return libusb_control_transfer(dev, LIBUSB_ENDPOINT_IN,
01142         LIBUSB_REQUEST_GET_DESCRIPTOR, (desc_type << 8) | desc_index, 0, data,
01143         length, 1000);
01144 }
01145 
01160 static inline int libusb_get_string_descriptor(libusb_device_handle *dev,
01161     uint8_t desc_index, uint16_t langid, unsigned char *data, int length)
01162 {
01163     return libusb_control_transfer(dev, LIBUSB_ENDPOINT_IN,
01164         LIBUSB_REQUEST_GET_DESCRIPTOR, (LIBUSB_DT_STRING << 8) | desc_index,
01165         langid, data, length, 1000);
01166 }
01167 
01168 int libusb_get_string_descriptor_ascii(libusb_device_handle *dev,
01169     uint8_t index, unsigned char *data, int length);
01170 
01171 /* polling and timeouts */
01172 
01173 int libusb_try_lock_events(libusb_context *ctx);
01174 void libusb_lock_events(libusb_context *ctx);
01175 void libusb_unlock_events(libusb_context *ctx);
01176 int libusb_event_handling_ok(libusb_context *ctx);
01177 int libusb_event_handler_active(libusb_context *ctx);
01178 void libusb_lock_event_waiters(libusb_context *ctx);
01179 void libusb_unlock_event_waiters(libusb_context *ctx);
01180 int libusb_wait_for_event(libusb_context *ctx, struct timeval *tv);
01181 
01182 int libusb_handle_events_timeout(libusb_context *ctx, struct timeval *tv);
01183 int libusb_handle_events(libusb_context *ctx);
01184 int libusb_handle_events_locked(libusb_context *ctx, struct timeval *tv);
01185 int libusb_get_next_timeout(libusb_context *ctx, struct timeval *tv);
01186 
01190 struct libusb_pollfd {
01192     int fd;
01193 
01198     short events;
01199 };
01200 
01211 typedef void (*libusb_pollfd_added_cb)(int fd, short events, void *user_data);
01212 
01222 typedef void (*libusb_pollfd_removed_cb)(int fd, void *user_data);
01223 
01224 const struct libusb_pollfd **libusb_get_pollfds(libusb_context *ctx);
01225 void libusb_set_pollfd_notifiers(libusb_context *ctx,
01226     libusb_pollfd_added_cb added_cb, libusb_pollfd_removed_cb removed_cb,
01227     void *user_data);
01228 
01229 #ifdef __cplusplus
01230 }
01231 #endif
01232 
01233 #endif