diff options
author | thompsa <thompsa@FreeBSD.org> | 2009-07-10 14:15:53 +0000 |
---|---|---|
committer | thompsa <thompsa@FreeBSD.org> | 2009-07-10 14:15:53 +0000 |
commit | 916ae8e45c6bd152c979c581a46108fdfb7a9111 (patch) | |
tree | 57a73b4c88e143f696376dd2fa566249ccfe438c /lib/libusb | |
parent | bc06993eb4fc58e6b7b99c857dcdc29054d79d0c (diff) | |
download | FreeBSD-src-916ae8e45c6bd152c979c581a46108fdfb7a9111.zip FreeBSD-src-916ae8e45c6bd152c979c581a46108fdfb7a9111.tar.gz |
Sync the libusb 1.0 exported api to the latest GSoC code.
- Fix possible uninitialised variables and null derefs
- Support big transfers
- Various bug fixes and style changes
Submitted by: Sylvestre Gallon
Sponsored by: Google Summer of Code 2009
Approved by: re (kib)
Diffstat (limited to 'lib/libusb')
-rw-r--r-- | lib/libusb/libusb.h | 58 | ||||
-rw-r--r-- | lib/libusb/libusb10.c | 462 | ||||
-rw-r--r-- | lib/libusb/libusb10.h | 213 | ||||
-rw-r--r-- | lib/libusb/libusb10_desc.c | 25 | ||||
-rw-r--r-- | lib/libusb/libusb10_io.c | 258 |
5 files changed, 510 insertions, 506 deletions
diff --git a/lib/libusb/libusb.h b/lib/libusb/libusb.h index a07c355..58a8918 100644 --- a/lib/libusb/libusb.h +++ b/lib/libusb/libusb.h @@ -27,14 +27,16 @@ #ifndef __LIBUSB_H__ #define __LIBUSB_H__ +#include <sys/time.h> +#include <sys/types.h> +#include <sys/endian.h> +#include <sys/queue.h> + #include <stdint.h> #include <time.h> #include <string.h> #include <pthread.h> -#include <sys/time.h> -#include <sys/types.h> -#include <sys/endian.h> #ifdef __cplusplus extern "C" { @@ -44,10 +46,6 @@ extern "C" { #endif -struct list_head { - struct list_head *prev, *next; -}; - /* libusb enums */ enum libusb_class_code { @@ -183,6 +181,33 @@ enum libusb_debug_level { LIBUSB_DEBUG_TRANSFER=2, }; +/* internal structures */ + +typedef struct libusb_pollfd { + int fd; + short events; +} libusb_pollfd; + +struct usb_pollfd { + TAILQ_ENTRY(usb_pollfd) list; + struct libusb_pollfd pollfd; +}; + +struct usb_transfer { + TAILQ_ENTRY(usb_transfer) list; + int num_iso_packets; + struct timeval timeout; + int transferred; + uint8_t flags; +}; + +struct usb_ep_tr { + TAILQ_ENTRY(usb_ep_tr) list; + uint8_t addr; + uint8_t idx; + uint8_t flags; + void *os_priv; +}; /* libusb structures */ typedef void (*libusb_pollfd_added_cb) (int fd, short events, void *user_data); @@ -194,16 +219,16 @@ typedef struct libusb_context { int ctrl_pipe[2]; - struct list_head usb_devs; + TAILQ_HEAD(usb_devs_list, libusb_device) usb_devs; pthread_mutex_t usb_devs_lock; - struct list_head open_devs; + TAILQ_HEAD(open_devs_list, libusb_device_handle) open_devs; pthread_mutex_t open_devs_lock; - struct list_head flying_transfers; + TAILQ_HEAD(flying_transfers_list, usb_transfer) flying_transfers; pthread_mutex_t flying_transfers_lock; - struct list_head pollfds; + TAILQ_HEAD(pollfds_list, usb_pollfd) pollfds; pthread_mutex_t pollfds_lock; unsigned int pollfd_modify; @@ -230,7 +255,7 @@ typedef struct libusb_device { uint8_t device_address; uint8_t num_configurations; - struct list_head list; + TAILQ_ENTRY(libusb_device) list; unsigned long session_data; void *os_priv; } libusb_device; @@ -239,9 +264,10 @@ typedef struct libusb_device_handle { pthread_mutex_t lock; unsigned long claimed_interfaces; - struct list_head list; + TAILQ_ENTRY(libusb_device_handle) list; struct libusb_device *dev; void *os_priv; + TAILQ_HEAD(ep_list, usb_ep_tr) ep_list; } libusb_device_handle; typedef struct libusb_device_descriptor { @@ -343,11 +369,6 @@ typedef struct libusb_transfer { struct libusb_iso_packet_descriptor iso_packet_desc[0]; } libusb_transfer __aligned(sizeof(void *)); -typedef struct libusb_pollfd { - int fd; - short events; -} libusb_pollfd; - /* Library initialisation */ void libusb_set_debug(libusb_context * ctx, int level); @@ -360,6 +381,7 @@ ssize_t libusb_get_device_list(libusb_context * ctx, libusb_device *** list); void libusb_free_device_list(libusb_device ** list, int unref_devices); uint8_t libusb_get_bus_number(libusb_device * dev); uint8_t libusb_get_device_address(libusb_device * dev); +int libusb_clear_halt(libusb_device_handle *devh, unsigned char endpoint); int libusb_get_max_packet_size(libusb_device * dev, unsigned char endpoint); libusb_device *libusb_ref_device(libusb_device * dev); void libusb_unref_device(libusb_device * dev); diff --git a/lib/libusb/libusb10.c b/lib/libusb/libusb10.c index 223f18a..638f0c7 100644 --- a/lib/libusb/libusb10.c +++ b/lib/libusb/libusb10.c @@ -75,8 +75,8 @@ libusb_init(libusb_context ** context) pthread_mutex_init(&ctx->usb_devs_lock, NULL); pthread_mutex_init(&ctx->open_devs_lock, NULL); - USB_LIST_INIT(&ctx->usb_devs); - USB_LIST_INIT(&ctx->open_devs); + TAILQ_INIT(&ctx->usb_devs); + TAILQ_INIT(&ctx->open_devs); pthread_mutex_init(&ctx->flying_transfers_lock, NULL); pthread_mutex_init(&ctx->pollfds_lock, NULL); @@ -85,8 +85,8 @@ libusb_init(libusb_context ** context) pthread_mutex_init(&ctx->event_waiters_lock, NULL); pthread_cond_init(&ctx->event_waiters_cond, NULL); - USB_LIST_INIT(&ctx->flying_transfers); - USB_LIST_INIT(&ctx->pollfds); + TAILQ_INIT(&ctx->flying_transfers); + TAILQ_INIT(&ctx->pollfds); ret = pipe(ctx->ctrl_pipe); if (ret < 0) { @@ -123,7 +123,7 @@ libusb_exit(libusb_context * ctx) { GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_exit enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_exit enter"); usb_remove_pollfd(ctx, ctx->ctrl_pipe[0]); close(ctx->ctrl_pipe[0]); close(ctx->ctrl_pipe[1]); @@ -135,7 +135,7 @@ libusb_exit(libusb_context * ctx) pthread_mutex_unlock(&default_context_lock); free(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_exit leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_exit leave"); } /* Device handling and initialisation. */ @@ -150,7 +150,7 @@ libusb_get_device_list(libusb_context * ctx, libusb_device *** list) int i; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_device_list enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_device_list enter"); usb_backend = libusb20_be_alloc_default(); if (usb_backend == NULL) @@ -178,6 +178,10 @@ libusb_get_device_list(libusb_context * ctx, libusb_device *** list) ddesc = libusb20_dev_get_device_desc(pdev); dev = malloc(sizeof(*dev)); if (dev == NULL) { + while (i != 0) { + libusb_unref_device((*list)[i - 1]); + i--; + } free(*list); libusb20_be_free(usb_backend); return (LIBUSB_ERROR_NO_MEM); @@ -194,7 +198,7 @@ libusb_get_device_list(libusb_context * ctx, libusb_device *** list) dev->os_priv = pdev; pthread_mutex_lock(&ctx->usb_devs_lock); - LIST_ADD(&dev->list, &ctx->usb_devs); + TAILQ_INSERT_HEAD(&ctx->usb_devs, dev, list); pthread_mutex_unlock(&ctx->usb_devs_lock); (*list)[i] = libusb_ref_device(dev); @@ -203,7 +207,7 @@ libusb_get_device_list(libusb_context * ctx, libusb_device *** list) (*list)[i] = NULL; libusb20_be_free(usb_backend); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_device_list leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_device_list leave"); return (i); } @@ -219,7 +223,7 @@ libusb_free_device_list(libusb_device **list, int unref_devices) ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_free_device_list enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_free_device_list enter"); if (list == NULL) return ; @@ -229,7 +233,7 @@ libusb_free_device_list(libusb_device **list, int unref_devices) libusb_unref_device(list[i]); } free(list); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_free_device_list leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_free_device_list leave"); } uint8_t @@ -239,11 +243,11 @@ libusb_get_bus_number(libusb_device * dev) ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_bus_number enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_bus_number enter"); if (dev == NULL) return (LIBUSB_ERROR_NO_DEVICE); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_bus_number leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_bus_number leave"); return (dev->bus_number); } @@ -254,11 +258,11 @@ libusb_get_device_address(libusb_device * dev) ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_device_address enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_device_address enter"); if (dev == NULL) return (LIBUSB_ERROR_NO_DEVICE); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_device_address leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_device_address leave"); return (dev->device_address); } @@ -274,7 +278,7 @@ libusb_get_max_packet_size(libusb_device *dev, unsigned char endpoint) ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_max_packet_size enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_max_packet_size enter"); if (dev == NULL) return (LIBUSB_ERROR_NO_DEVICE); @@ -299,7 +303,7 @@ libusb_get_max_packet_size(libusb_device *dev, unsigned char endpoint) out: libusb_free_config_descriptor(pdconf); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_max_packet_size leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_max_packet_size leave"); return (ret); } @@ -310,7 +314,7 @@ libusb_ref_device(libusb_device * dev) ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_ref_device enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_ref_device enter"); if (dev == NULL) return (NULL); @@ -319,7 +323,7 @@ libusb_ref_device(libusb_device * dev) dev->refcnt++; pthread_mutex_unlock(&dev->lock); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_ref_device leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_ref_device leave"); return (dev); } @@ -330,7 +334,7 @@ libusb_unref_device(libusb_device * dev) ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_unref_device enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_unref_device enter"); if (dev == NULL) return; @@ -341,13 +345,13 @@ libusb_unref_device(libusb_device * dev) if (dev->refcnt == 0) { pthread_mutex_lock(&dev->ctx->usb_devs_lock); - LIST_DEL(&dev->list); + TAILQ_REMOVE(&ctx->usb_devs, dev, list); pthread_mutex_unlock(&dev->ctx->usb_devs_lock); libusb20_dev_free(dev->os_priv); free(dev); } - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_unref_device leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_unref_device leave"); } int @@ -360,7 +364,7 @@ libusb_open(libusb_device * dev, libusb_device_handle **devh) int err; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_open enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_open enter"); dummy = 1; if (devh == NULL) @@ -378,6 +382,7 @@ libusb_open(libusb_device * dev, libusb_device_handle **devh) memset(hdl, 0, sizeof(*hdl)); pthread_mutex_init(&hdl->lock, NULL); + TAILQ_INIT(&hdl->ep_list); hdl->dev = libusb_ref_device(dev); hdl->claimed_interfaces = 0; hdl->os_priv = dev->os_priv; @@ -390,7 +395,7 @@ libusb_open(libusb_device * dev, libusb_device_handle **devh) } pthread_mutex_lock(&ctx->open_devs_lock); - LIST_ADD(&hdl->list, &ctx->open_devs); + TAILQ_INSERT_HEAD(&ctx->open_devs, hdl, list); pthread_mutex_unlock(&ctx->open_devs_lock); *devh = hdl; @@ -414,7 +419,7 @@ libusb_open(libusb_device * dev, libusb_device_handle **devh) pthread_mutex_unlock(&ctx->pollfd_modify_lock); libusb_unlock_events(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_open leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_open leave"); return (0); } @@ -429,7 +434,7 @@ libusb_open_device_with_vid_pid(libusb_context * ctx, uint16_t vendor_id, int i, j; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_open_device_width_vid_pid enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_open_device_width_vid_pid enter"); devh = NULL; @@ -440,13 +445,15 @@ libusb_open_device_with_vid_pid(libusb_context * ctx, uint16_t vendor_id, pdev = (struct libusb20_device *)devs[j]->os_priv; pdesc = libusb20_dev_get_device_desc(pdev); if (pdesc->idVendor == vendor_id && - pdesc->idProduct == product_id) + pdesc->idProduct == product_id) { if (libusb_open(devs[j], &devh) < 0) devh = NULL; + break ; + } } libusb_free_device_list(devs, 1); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_open_device_width_vid_pid leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_open_device_width_vid_pid leave"); return (devh); } @@ -455,6 +462,7 @@ libusb_close(libusb_device_handle * devh) { libusb_context *ctx; struct libusb20_device *pdev; + struct usb_ep_tr *eptr; unsigned char dummy = 1; int err; @@ -465,7 +473,7 @@ libusb_close(libusb_device_handle * devh) pdev = devh->os_priv; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_close enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_close enter"); pthread_mutex_lock(&ctx->pollfd_modify_lock); ctx->pollfd_modify++; @@ -475,12 +483,21 @@ libusb_close(libusb_device_handle * devh) if (err <= 0) { pthread_mutex_lock(&ctx->open_devs_lock); - LIST_DEL(&devh->list); + TAILQ_REMOVE(&ctx->open_devs, devh, list); pthread_mutex_unlock(&ctx->open_devs_lock); usb_remove_pollfd(ctx, libusb20_dev_get_fd(pdev)); - libusb_unref_device(devh->dev); libusb20_dev_close(pdev); + libusb_unref_device(devh->dev); + TAILQ_FOREACH(eptr, &devh->ep_list, list) { + TAILQ_REMOVE(&devh->ep_list, eptr, list); + libusb20_tr_close(((struct libusb20_transfer **) + eptr->os_priv)[0]); + if (eptr->flags) + libusb20_tr_close(((struct libusb20_transfer **) + eptr->os_priv)[1]); + free((struct libusb20_transfer **)eptr->os_priv); + } free(devh); pthread_mutex_lock(&ctx->pollfd_modify_lock); @@ -492,12 +509,21 @@ libusb_close(libusb_device_handle * devh) read(ctx->ctrl_pipe[0], &dummy, sizeof(dummy)); pthread_mutex_lock(&ctx->open_devs_lock); - LIST_DEL(&devh->list); + TAILQ_REMOVE(&ctx->open_devs, devh, list); pthread_mutex_unlock(&ctx->open_devs_lock); usb_remove_pollfd(ctx, libusb20_dev_get_fd(pdev)); - libusb_unref_device(devh->dev); libusb20_dev_close(pdev); + libusb_unref_device(devh->dev); + TAILQ_FOREACH(eptr, &devh->ep_list, list) { + TAILQ_REMOVE(&devh->ep_list, eptr, list); + libusb20_tr_close(((struct libusb20_transfer **) + eptr->os_priv)[0]); + if (eptr->flags) + libusb20_tr_close(((struct libusb20_transfer **) + eptr->os_priv)[1]); + free((struct libusb20_transfer **)eptr->os_priv); + } free(devh); pthread_mutex_lock(&ctx->pollfd_modify_lock); @@ -505,7 +531,7 @@ libusb_close(libusb_device_handle * devh) pthread_mutex_unlock(&ctx->pollfd_modify_lock); libusb_unlock_events(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_close leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_close leave"); } libusb_device * @@ -515,12 +541,12 @@ libusb_get_device(libusb_device_handle * devh) ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_device enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_device enter"); if (devh == NULL) return (NULL); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_device leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_device leave"); return (devh->dev); } @@ -531,7 +557,7 @@ libusb_get_configuration(libusb_device_handle * devh, int *config) ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_configuration enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_configuration enter"); if (devh == NULL || config == NULL) return (LIBUSB_ERROR_INVALID_PARAM); @@ -539,14 +565,10 @@ libusb_get_configuration(libusb_device_handle * devh, int *config) *config = libusb20_dev_get_config_index((struct libusb20_device *) devh->dev->os_priv); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_configuration leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_configuration leave"); return (0); } -/* - * XXX this code is wrong. need update. - */ - int libusb_set_configuration(libusb_device_handle * devh, int configuration) { @@ -555,16 +577,15 @@ libusb_set_configuration(libusb_device_handle * devh, int configuration) ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_set_configuration enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_set_configuration enter"); if (devh == NULL) return (LIBUSB_ERROR_INVALID_PARAM); pdev = (struct libusb20_device *)devh->dev->os_priv; - libusb20_dev_set_alt_index(pdev, libusb20_dev_get_config_index(pdev), - configuration); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_set_configuration leave"); + libusb20_dev_set_config_index(pdev, configuration); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_set_configuration leave"); return (0); } @@ -576,7 +597,7 @@ libusb_claim_interface(libusb_device_handle * dev, int interface_number) ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_claim_interface enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_claim_interface enter"); if (dev == NULL) return (LIBUSB_ERROR_INVALID_PARAM); @@ -592,7 +613,7 @@ libusb_claim_interface(libusb_device_handle * dev, int interface_number) dev->claimed_interfaces |= (1 << interface_number); pthread_mutex_unlock(&(dev->lock)); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_claim_interface leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_claim_interface leave"); return (ret); } @@ -604,7 +625,7 @@ libusb_release_interface(libusb_device_handle * dev, int interface_number) ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_release_interface enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_release_interface enter"); ret = 0; if (dev == NULL) @@ -621,7 +642,7 @@ libusb_release_interface(libusb_device_handle * dev, int interface_number) dev->claimed_interfaces &= ~(1 << interface_number); pthread_mutex_unlock(&(dev->lock)); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_release_interface leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_release_interface leave"); return (ret); } @@ -630,11 +651,10 @@ libusb_set_interface_alt_setting(libusb_device_handle * dev, int interface_number, int alternate_setting) { libusb_context *ctx; - int ret; ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_set_interface_alt_setting enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_set_interface_alt_setting enter"); if (dev == NULL) return (LIBUSB_ERROR_INVALID_PARAM); @@ -653,7 +673,7 @@ libusb_set_interface_alt_setting(libusb_device_handle * dev, alternate_setting) != 0) return (LIBUSB_ERROR_OTHER); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_set_interface_alt_setting leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_set_interface_alt_setting leave"); return (0); } @@ -661,14 +681,19 @@ int libusb_clear_halt(libusb_device_handle * devh, unsigned char endpoint) { struct libusb20_transfer *xfer; + struct libusb20_device *pdev; libusb_context *ctx; int ret; ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_clear_halt enter"); - - GET_XFER(xfer, endpoint, devh->os_priv); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_clear_halt enter"); + + pdev = devh->os_priv; + xfer = libusb20_tr_get_pointer(pdev, + ((endpoint / 0x40) | (endpoint * 4)) % (16 * 4)); + if (xfer == NULL) + return (LIBUSB_ERROR_NO_MEM); pthread_mutex_lock(&libusb20_lock); ret = libusb20_tr_open(xfer, 0, 0, endpoint); @@ -682,7 +707,7 @@ libusb_clear_halt(libusb_device_handle * devh, unsigned char endpoint) libusb20_tr_close(xfer); pthread_mutex_unlock(&libusb20_lock); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_clear_halt leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_clear_halt leave"); return (0); } @@ -693,13 +718,13 @@ libusb_reset_device(libusb_device_handle * dev) ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_reset_device enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_reset_device enter"); if (dev == NULL) return (LIBUSB20_ERROR_INVALID_PARAM); libusb20_dev_reset(dev->os_priv); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_reset_device leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_reset_device leave"); return (0); } @@ -710,12 +735,12 @@ libusb_kernel_driver_active(libusb_device_handle * devh, int interface) ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_kernel_driver_active enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_kernel_driver_active enter"); if (devh == NULL) return (LIBUSB_ERROR_INVALID_PARAM); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_kernel_driver_active leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_kernel_driver_active leave"); return (libusb20_dev_kernel_driver_active(devh->os_priv, interface)); } @@ -727,7 +752,7 @@ libusb_detach_kernel_driver(libusb_device_handle * devh, int interface) ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_detach_kernel_driver enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_detach_kernel_driver enter"); if (devh == NULL) return (LIBUSB_ERROR_INVALID_PARAM); @@ -736,7 +761,7 @@ libusb_detach_kernel_driver(libusb_device_handle * devh, int interface) if (libusb20_dev_detach_kernel_driver(pdev, interface) == LIBUSB20_ERROR_OTHER) return (LIBUSB_ERROR_OTHER); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_detach_kernel_driver leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_detach_kernel_driver leave"); return (0); } @@ -751,12 +776,12 @@ libusb_attach_kernel_driver(libusb_device_handle * devh, int interface) ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_attach_kernel_driver enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_attach_kernel_driver enter"); if (devh == NULL) return (LIBUSB_ERROR_INVALID_PARAM); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_attach_kernel_driver leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_attach_kernel_driver leave"); return (0); } @@ -772,7 +797,7 @@ libusb_alloc_transfer(int iso_packets) ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_alloc_transfer enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_alloc_transfer enter"); len = sizeof(struct libusb_transfer) + sizeof(struct usb_transfer) + @@ -788,7 +813,7 @@ libusb_alloc_transfer(int iso_packets) xfer = (struct libusb_transfer *) ((uint8_t *)bxfer + sizeof(struct usb_transfer)); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_alloc_transfer leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_alloc_transfer leave"); return (xfer); } @@ -800,7 +825,7 @@ libusb_free_transfer(struct libusb_transfer *xfer) ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_free_transfer enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_free_transfer enter"); if (xfer == NULL) return ; @@ -809,10 +834,85 @@ libusb_free_transfer(struct libusb_transfer *xfer) sizeof(struct usb_transfer)); free(bxfer); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_free_transfer leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_free_transfer leave"); return; } +static int +libusb_get_maxframe(struct libusb20_device *pdev, libusb_transfer *xfer) +{ + int ret; + int usb_speed; + + usb_speed = libusb20_dev_get_speed(pdev); + + switch (xfer->type) { + case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS: + switch (usb_speed) { + case LIBUSB20_SPEED_LOW: + case LIBUSB20_SPEED_FULL: + ret = 60 * 1; + break ; + default : + ret = 60 * 8; + break ; + } + break ; + case LIBUSB_TRANSFER_TYPE_CONTROL: + ret = 2; + break ; + default: + ret = 1; + break ; + } + + return ret; +} + +static int +libusb_get_buffsize(struct libusb20_device *pdev, libusb_transfer *xfer) +{ + int ret; + int usb_speed; + + usb_speed = libusb20_dev_get_speed(pdev); + + switch (xfer->type) { + case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS: + ret = 0; + break ; + case LIBUSB_TRANSFER_TYPE_CONTROL: + switch (usb_speed) { + case LIBUSB20_SPEED_LOW: + ret = 8; + break ; + case LIBUSB20_SPEED_FULL: + ret = 64; + break ; + default: + ret = 64; + break ; + } + ret += 8; + break ; + default : + switch (usb_speed) { + case LIBUSB20_SPEED_LOW: + ret = 256; + break ; + case LIBUSB20_SPEED_FULL: + ret = 4096; + break ; + default: + ret = 16384; + break ; + } + break ; + } + + return ret; +} + static void libusb10_proxy(struct libusb20_transfer *xfer) { @@ -820,6 +920,9 @@ libusb10_proxy(struct libusb20_transfer *xfer) struct libusb20_device *pdev; libusb_transfer *usb_xfer; libusb_context *ctx; + uint32_t pos; + uint32_t max; + uint32_t size; uint8_t status; uint32_t iso_packets; int i; @@ -834,172 +937,97 @@ libusb10_proxy(struct libusb20_transfer *xfer) switch (status) { case LIBUSB20_TRANSFER_COMPLETED: - dprintf(ctx, LIBUSB_DEBUG_TRANSFER, "LIBUSB20 SUBMIT"); - usb_xfer->actual_length += libusb20_tr_get_actual_length(xfer); - usb_xfer->callback(usb_xfer); - - pthread_mutex_lock(&ctx->flying_transfers_lock); - LIST_DEL(&usb_backend->list); - pthread_mutex_unlock(&ctx->flying_transfers_lock); + usb_backend->transferred += libusb20_tr_get_actual_length(xfer); + DPRINTF(ctx, LIBUSB_DEBUG_TRANSFER, "LIBUSB20 TRANSFER %i bytes", + usb_backend->transferred); + if (usb_backend->transferred != usb_xfer->length) + goto tr_start; + + DPRINTF(ctx, LIBUSB_DEBUG_TRANSFER, "LIBUSB20 TRANSFER COMPLETE"); + usb_handle_transfer_completion(usb_backend, LIBUSB_TRANSFER_COMPLETED); + break ; case LIBUSB20_TRANSFER_START: - dprintf(ctx, LIBUSB_DEBUG_TRANSFER, "LIBUSB20 START"); +tr_start: + DPRINTF(ctx, LIBUSB_DEBUG_TRANSFER, "LIBUSB20 START"); + max = libusb_get_buffsize(pdev, usb_xfer); + pos = usb_backend->transferred; + size = (usb_xfer->length - pos); + size = (size > max) ? max : size; usb_xfer->actual_length = 0; switch (usb_xfer->type) { case LIBUSB_TRANSFER_TYPE_CONTROL: - dprintf(ctx, LIBUSB_DEBUG_TRANSFER, "TYPE CTR"); + DPRINTF(ctx, LIBUSB_DEBUG_TRANSFER, "TYPE CTR"); libusb20_tr_setup_control(xfer, usb_xfer->buffer, - (void *)(((uint8_t *) usb_xfer->buffer) + + (void *)(((uint8_t *) &usb_xfer->buffer[pos]) + sizeof(libusb_control_setup)), usb_xfer->timeout); break ; case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS: - dprintf(ctx, LIBUSB_DEBUG_TRANSFER, "TYPE ISO"); + DPRINTF(ctx, LIBUSB_DEBUG_TRANSFER, "TYPE ISO"); iso_packets = libusb20_tr_get_max_frames(xfer); if (usb_xfer->num_iso_packets > iso_packets) usb_xfer->num_iso_packets = iso_packets; for (i = 0 ; i < usb_xfer->num_iso_packets ; i++) { libusb20_tr_setup_isoc(xfer, - usb_xfer->buffer, usb_xfer->length, i); + &usb_xfer->buffer[pos], size, i); } libusb20_tr_set_total_frames(xfer, i); break ; case LIBUSB_TRANSFER_TYPE_BULK: - dprintf(ctx, LIBUSB_DEBUG_TRANSFER, "TYPE BULK"); - libusb20_tr_setup_bulk(xfer, usb_xfer->buffer, - usb_xfer->length, usb_xfer->timeout); + DPRINTF(ctx, LIBUSB_DEBUG_TRANSFER, "TYPE BULK"); + libusb20_tr_setup_bulk(xfer, &usb_xfer->buffer[pos], + size, usb_xfer->timeout); break ; case LIBUSB_TRANSFER_TYPE_INTERRUPT: - dprintf(ctx, LIBUSB_DEBUG_TRANSFER, "TYPE INTR"); - libusb20_tr_setup_intr(xfer, usb_xfer->buffer, - usb_xfer->length, usb_xfer->timeout); + DPRINTF(ctx, LIBUSB_DEBUG_TRANSFER, "TYPE INTR"); + libusb20_tr_setup_intr(xfer, &usb_xfer->buffer[pos], + size, usb_xfer->timeout); break ; } libusb20_tr_submit(xfer); - dprintf(ctx, LIBUSB_DEBUG_TRANSFER, "LIBUSB20 SUBMITED"); + DPRINTF(ctx, LIBUSB_DEBUG_TRANSFER, "LIBUSB20 SUBMITED"); break ; default: - if (ctx->debug == LIBUSB_DEBUG_TRANSFER) - printf("LIBUSB TRANSFER DEFAULT 0x%x\n", status); - usb_xfer->actual_length = 0; - usb_xfer->status = LIBUSB_TRANSFER_CANCELLED; - - pthread_mutex_lock(&ctx->flying_transfers_lock); - LIST_DEL(&usb_backend->list); - pthread_mutex_unlock(&ctx->flying_transfers_lock); - usb_xfer->callback(usb_xfer); - + DPRINTF(ctx, LIBUSB_DEBUG_TRANSFER, "TRANSFER DEFAULT 0x%x\n", + status); + usb_backend->transferred = 0; + usb_handle_transfer_completion(usb_backend, LIBUSB_TRANSFER_CANCELLED); break ; } switch (status) { case LIBUSB20_TRANSFER_COMPLETED: - dprintf(ctx, LIBUSB_DEBUG_TRANSFER, "STATUS COMPLETED"); + DPRINTF(ctx, LIBUSB_DEBUG_TRANSFER, "STATUS COMPLETED"); usb_xfer->status = LIBUSB_TRANSFER_COMPLETED; break ; case LIBUSB20_TRANSFER_OVERFLOW: - dprintf(ctx, LIBUSB_DEBUG_TRANSFER, "STATUS TR OVERFLOW"); + DPRINTF(ctx, LIBUSB_DEBUG_TRANSFER, "STATUS TR OVERFLOW"); usb_xfer->status = LIBUSB_TRANSFER_OVERFLOW; break ; case LIBUSB20_TRANSFER_NO_DEVICE: - dprintf(ctx, LIBUSB_DEBUG_TRANSFER, "STATUS TR NO DEVICE"); + DPRINTF(ctx, LIBUSB_DEBUG_TRANSFER, "STATUS TR NO DEVICE"); usb_xfer->status = LIBUSB_TRANSFER_NO_DEVICE; break ; case LIBUSB20_TRANSFER_STALL: - dprintf(ctx, LIBUSB_DEBUG_TRANSFER, "STATUS TR STALL"); + DPRINTF(ctx, LIBUSB_DEBUG_TRANSFER, "STATUS TR STALL"); usb_xfer->status = LIBUSB_TRANSFER_STALL; break ; case LIBUSB20_TRANSFER_CANCELLED: - dprintf(ctx, LIBUSB_DEBUG_TRANSFER, "STATUS TR CANCELLED"); + DPRINTF(ctx, LIBUSB_DEBUG_TRANSFER, "STATUS TR CANCELLED"); usb_xfer->status = LIBUSB_TRANSFER_CANCELLED; break ; case LIBUSB20_TRANSFER_TIMED_OUT: - dprintf(ctx, LIBUSB_DEBUG_TRANSFER, "STATUS TR TIMEOUT"); + DPRINTF(ctx, LIBUSB_DEBUG_TRANSFER, "STATUS TR TIMEOUT"); usb_xfer->status = LIBUSB_TRANSFER_TIMED_OUT; break ; case LIBUSB20_TRANSFER_ERROR: - dprintf(ctx, LIBUSB_DEBUG_TRANSFER, "ERROR"); + DPRINTF(ctx, LIBUSB_DEBUG_TRANSFER, "ERROR"); usb_xfer->status = LIBUSB_TRANSFER_ERROR; break ; } } -static int -libusb_get_maxframe(struct libusb20_device *pdev, libusb_transfer *xfer) -{ - int ret; - int usb_speed; - - usb_speed = libusb20_dev_get_speed(pdev); - - switch (xfer->type) { - case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS: - switch (usb_speed) { - case LIBUSB20_SPEED_LOW: - case LIBUSB20_SPEED_FULL: - ret = 60 * 1; - break ; - default : - ret = 60 * 8; - break ; - } - break ; - case LIBUSB_TRANSFER_TYPE_CONTROL: - ret = 2; - break ; - default: - ret = 1; - break ; - } - - return ret; -} - -static int -libusb_get_buffsize(struct libusb20_device *pdev, libusb_transfer *xfer) -{ - int ret; - int usb_speed; - - usb_speed = libusb20_dev_get_speed(pdev); - - switch (xfer->type) { - case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS: - ret = 0; - break ; - case LIBUSB_TRANSFER_TYPE_CONTROL: - switch (usb_speed) { - case LIBUSB20_SPEED_LOW: - ret = 8; - break ; - case LIBUSB20_SPEED_FULL: - ret = 64; - break ; - case LIBUSB20_SPEED_HIGH: - ret = 64; - break ; - } - /*add */ - ret += 8; - break ; - default : - switch (usb_speed) { - case LIBUSB20_SPEED_LOW: - ret = 256; - break ; - case LIBUSB20_SPEED_FULL: - ret = 4096; - break ; - default: - ret = 16384; - break ; - } - break ; - } - - return ret; -} - int libusb_submit_transfer(struct libusb_transfer *xfer) { @@ -1007,15 +1035,15 @@ libusb_submit_transfer(struct libusb_transfer *xfer) struct usb_transfer *usb_backend; struct usb_transfer *usb_node; struct libusb20_device *pdev; - struct libusb_context *ctx; + struct usb_ep_tr *eptr; struct timespec cur_ts; struct timeval *cur_tv; + libusb_device_handle *devh; + libusb_context *ctx; int maxframe; int buffsize; - int num_frame; int ep_idx; int ret; - int i; if (xfer == NULL) return (LIBUSB_ERROR_NO_MEM); @@ -1026,8 +1054,9 @@ libusb_submit_transfer(struct libusb_transfer *xfer) ctx = xfer->dev_handle->dev->ctx; pdev = xfer->dev_handle->os_priv; + devh = xfer->dev_handle; - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_submit_transfer enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_submit_transfer enter"); usb_backend = (struct usb_transfer *) ((uint8_t *)xfer - sizeof(struct usb_transfer)); @@ -1045,37 +1074,36 @@ libusb_submit_transfer(struct libusb_transfer *xfer) } TIMESPEC_TO_TIMEVAL(&usb_backend->timeout, &cur_ts); - } + } /*Add to flying list*/ pthread_mutex_lock(&ctx->flying_transfers_lock); - if (USB_LIST_EMPTY(&ctx->flying_transfers)) { - LIST_ADD(&usb_backend->list, &ctx->flying_transfers); + if (TAILQ_EMPTY(&ctx->flying_transfers)) { + TAILQ_INSERT_HEAD(&ctx->flying_transfers, usb_backend, list); goto out; } if (timerisset(&usb_backend->timeout) == 0) { - LIST_ADD_TAIL(&usb_backend->list, &ctx->flying_transfers); + TAILQ_INSERT_HEAD(&ctx->flying_transfers, usb_backend, list); goto out; } - LIST_FOREACH_ENTRY(usb_node, &ctx->flying_transfers, list) { + TAILQ_FOREACH(usb_node, &ctx->flying_transfers, list) { cur_tv = &usb_node->timeout; if (timerisset(cur_tv) == 0 || (cur_tv->tv_sec > usb_backend->timeout.tv_sec) || (cur_tv->tv_sec == usb_backend->timeout.tv_sec && cur_tv->tv_usec > usb_backend->timeout.tv_usec)) { - LIST_ADD_TAIL(&usb_backend->list, &usb_node->list); + TAILQ_INSERT_TAIL(&ctx->flying_transfers, usb_backend, list); goto out; } } - LIST_ADD_TAIL(&usb_backend->list, &ctx->flying_transfers); + TAILQ_INSERT_TAIL(&ctx->flying_transfers, usb_backend, list); out: pthread_mutex_unlock(&ctx->flying_transfers_lock); - usb20_xfer[0] = libusb20_tr_get_pointer(pdev, - ((xfer->endpoint / 0x40) | (xfer->endpoint * 4)) % (16 * 4)); - usb20_xfer[1] = libusb20_tr_get_pointer(pdev, - (((xfer->endpoint / 0x40) | (xfer->endpoint * 4)) % (16 * 4)) + 1); + ep_idx = (xfer->endpoint / 0x40) | (xfer->endpoint * 4) % (16 * 4); + usb20_xfer[0] = libusb20_tr_get_pointer(pdev, ep_idx); + usb20_xfer[1] = libusb20_tr_get_pointer(pdev, ep_idx + 1); if (usb20_xfer[0] == NULL) return (LIBUSB_ERROR_OTHER); @@ -1087,18 +1115,31 @@ out: buffsize = libusb_get_buffsize(pdev, xfer); maxframe = libusb_get_maxframe(pdev, xfer); - ret = libusb20_tr_open(usb20_xfer[0], buffsize, - maxframe, xfer->endpoint); - if (xfer->type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS) - ret |= libusb20_tr_open(usb20_xfer[1], buffsize, - maxframe, xfer->endpoint); + ret = 0; + TAILQ_FOREACH(eptr, &devh->ep_list, list) { + if (xfer->endpoint == eptr->addr) + ret++; + } + if (ret == 0) { + eptr = malloc(sizeof(struct usb_ep_tr)); + eptr->addr = xfer->endpoint; + eptr->idx = ep_idx; + eptr->os_priv = usb20_xfer; + eptr->flags = (xfer->type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS)?1:0; + TAILQ_INSERT_HEAD(&devh->ep_list, eptr, list); + ret = libusb20_tr_open(usb20_xfer[0], buffsize, + maxframe, xfer->endpoint); + if (xfer->type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS) + ret |= libusb20_tr_open(usb20_xfer[1], buffsize, + maxframe, xfer->endpoint); - if (ret != 0) { - pthread_mutex_unlock(&libusb20_lock); - pthread_mutex_lock(&ctx->flying_transfers_lock); - LIST_DEL(&usb_backend->list); - pthread_mutex_unlock(&ctx->flying_transfers_lock); - return (LIBUSB_ERROR_OTHER); + if (ret != 0) { + pthread_mutex_unlock(&libusb20_lock); + pthread_mutex_lock(&ctx->flying_transfers_lock); + TAILQ_REMOVE(&ctx->flying_transfers, usb_backend, list); + pthread_mutex_unlock(&ctx->flying_transfers_lock); + return (LIBUSB_ERROR_OTHER); + } } libusb20_tr_set_priv_sc0(usb20_xfer[0], xfer); @@ -1108,13 +1149,14 @@ out: libusb20_tr_set_callback(usb20_xfer[1], libusb10_proxy); } + DPRINTF(ctx, LIBUSB_DEBUG_TRANSFER, "LIBUSB20_TR_START"); libusb20_tr_start(usb20_xfer[0]); if (xfer->type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS) libusb20_tr_start(usb20_xfer[1]); pthread_mutex_unlock(&libusb20_lock); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_submit_transfer leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_submit_transfer leave"); return (0); } @@ -1125,7 +1167,7 @@ libusb_cancel_transfer(struct libusb_transfer *xfer) ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_cancel_transfer enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_cancel_transfer enter"); if (xfer == NULL) return (LIBUSB_ERROR_NO_MEM); @@ -1134,7 +1176,7 @@ libusb_cancel_transfer(struct libusb_transfer *xfer) libusb20_tr_stop(xfer->os_priv); pthread_mutex_unlock(&libusb20_lock); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_cancel_transfer leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_cancel_transfer leave"); return (0); } diff --git a/lib/libusb/libusb10.h b/lib/libusb/libusb10.h index 60a13da..3557ec0 100644 --- a/lib/libusb/libusb10.h +++ b/lib/libusb/libusb10.h @@ -31,44 +31,6 @@ * The two following macros were taken from the original LibUSB v1.0 * for sake of compatibility: */ -#define USB_LIST_INIT(entry) \ - (entry)->prev = (entry)->next = entry; -#define USB_LIST_EMPTY(entry) \ - ((entry)->next = (entry)) - -#define LIST_ADD(entry, head) \ - (entry)->next = (head)->next; \ - (entry)->prev = (head); \ - (head)->next->prev = (entry); \ - (head)->next = (entry); -#define LIST_ADD_TAIL(entry, head) \ - (entry)->next = (head); \ - (entry)->prev = (head)->prev; \ - (head)->prev->next = (entry); \ - (head)->prev = (entry); -#define LIST_DEL(entry) \ - (entry)->next->prev = (entry)->prev; \ - (entry)->prev->next = (entry)->next; - -#define LIST_ENT(ptr, type, member) \ - ((type *)((char *)(ptr) - (unsigned long) (&((type*)0L)->member))) -#define LIST_FOREACH_ENTRY(pos, head, member) \ - for (pos = LIST_ENT((head)->next, typeof(*pos), member) ; \ - &pos->member != head ; \ - pos = LIST_ENT(pos->member.next, typeof(*pos), member)) -#define LIST_FOREACH_ENTRY_SAFE(pos, n, head, member) \ - for (pos = LIST_ENT((head)->next, typeof(*pos), member), \ - n = LIST_ENT(pos->member.next, typeof(*pos), member); \ - &pos->member != (head); \ - pos = n, n = LIST_ENT(n->member.next, typeof(*n), member)) - -/* fetch libusb20_transfer from libusb20_device */ -#define GET_XFER(xfer, endpoint, pdev)\ - xfer = libusb20_tr_get_pointer(pdev, \ - (2 *endpoint)|(endpoint/0x80)); \ - if (xfer == NULL) \ - return (LIBUSB_ERROR_OTHER); - static int get_next_timeout(libusb_context *ctx, struct timeval *tv, struct timeval *out); static int handle_timeouts(struct libusb_context *ctx); @@ -83,163 +45,26 @@ extern pthread_mutex_t libusb20_lock; #define MAX(a,b) (((a)>(b))?(a):(b)) #define USB_TIMED_OUT (1<<0) - -static inline void -dprintf(libusb_context *ctx, int debug, char *str) -{ - if (ctx->debug != debug) - return ; - - switch (ctx->debug) { - case LIBUSB_DEBUG_NO: - break ; - case LIBUSB_DEBUG_FUNCTION: - printf("LIBUSB FUNCTION : %s\n", str); - break ; - case LIBUSB_DEBUG_TRANSFER: - printf("LIBUSB TRANSFER : %s\n", str); - break ; - default: - printf("LIBUSB UNKNOW DEBUG\n"); - break ; - } - return ; +#define UNEXPORTED __attribute__((__visibility__("hidden"))) + +#define DPRINTF(ctx, dbg, format, args...) \ +if (ctx->debug == dbg) { \ + printf("LIBUSB_%s : ", (ctx->debug == LIBUSB_DEBUG_FUNCTION) ? "FUNCTION" : "TRANSFER"); \ + switch(ctx->debug) { \ + case LIBUSB_DEBUG_FUNCTION: \ + printf(format, ## args);\ + break ; \ + case LIBUSB_DEBUG_TRANSFER: \ + printf(format, ## args);\ + break ; \ + } \ + printf("\n"); \ } -struct usb_pollfd { - struct libusb_pollfd pollfd; - struct list_head list; -}; - -struct usb_transfer { - int num_iso_packets; - struct list_head list; - struct timeval timeout; - int transferred; - uint8_t flags; -}; - -static inline int -usb_add_pollfd(libusb_context *ctx, int fd, short events) -{ - struct usb_pollfd *pollfd; - - if (ctx == NULL) - return (LIBUSB_ERROR_INVALID_PARAM); - - pollfd = malloc(sizeof(*pollfd)); - if (pollfd == NULL) - return (LIBUSB_ERROR_NO_MEM); - - pollfd->pollfd.fd = fd; - pollfd->pollfd.events = events; - - pthread_mutex_lock(&ctx->pollfds_lock); - LIST_ADD_TAIL(&pollfd->list, &ctx->pollfds); - pthread_mutex_unlock(&ctx->pollfds_lock); - - if (ctx->fd_added_cb) - ctx->fd_added_cb(fd, events, ctx->fd_cb_user_data); - return (0); -} - -static inline void -usb_remove_pollfd(libusb_context *ctx, int fd) -{ - struct usb_pollfd *pollfd; - int found; - - found = 0; - pthread_mutex_lock(&ctx->pollfds_lock); - - LIST_FOREACH_ENTRY(pollfd, &ctx->pollfds, list) { - if (pollfd->pollfd.fd == fd) { - found = 1; - break ; - } - } - - if (found == 0) { - pthread_mutex_unlock(&ctx->pollfds_lock); - return ; - } - - LIST_DEL(&pollfd->list); - pthread_mutex_unlock(&ctx->pollfds_lock); - free(pollfd); - - if (ctx->fd_removed_cb) - ctx->fd_removed_cb(fd, ctx->fd_cb_user_data); -} - -static inline void -usb_handle_transfer_completion(struct usb_transfer *uxfer, - enum libusb_transfer_status status) -{ - libusb_transfer *xfer; - libusb_context *ctx; - int len; - - xfer = (struct libusb_transfer *) ((uint8_t *)uxfer + - sizeof(struct usb_transfer)); - ctx = xfer->dev_handle->dev->ctx; - - pthread_mutex_lock(&ctx->flying_transfers_lock); - LIST_DEL(&uxfer->list); - pthread_mutex_unlock(&ctx->flying_transfers_lock); - - if (status == LIBUSB_TRANSFER_COMPLETED && xfer->flags & - LIBUSB_TRANSFER_SHORT_NOT_OK) { - len = xfer->length; - if (xfer->type == LIBUSB_TRANSFER_TYPE_CONTROL) - len -= sizeof(libusb_control_setup); - if (len != uxfer->transferred) { - status = LIBUSB_TRANSFER_ERROR; - } - } - - xfer->status = status; - xfer->actual_length = uxfer->transferred; - - if (xfer->callback) - xfer->callback(xfer); - if (xfer->flags & LIBUSB_TRANSFER_FREE_TRANSFER) - libusb_free_transfer(xfer); - - pthread_mutex_lock(&ctx->event_waiters_lock); - pthread_cond_broadcast(&ctx->event_waiters_cond); - pthread_mutex_unlock(&ctx->event_waiters_lock); -} - -static inline void -usb_handle_disconnect(struct libusb_device_handle *devh) -{ - struct libusb_context *ctx; - struct libusb_transfer *xfer; - struct usb_transfer *cur; - struct usb_transfer *to_cancel; - - ctx = devh->dev->ctx; - - while (1) { - pthread_mutex_lock(&ctx->flying_transfers_lock); - to_cancel = NULL; - LIST_FOREACH_ENTRY(cur, &ctx->flying_transfers, list) { - xfer = (struct libusb_transfer *) ((uint8_t *)cur + - sizeof(struct usb_transfer)); - if (xfer->dev_handle == devh) { - to_cancel = cur; - break ; - } - } - pthread_mutex_unlock(&ctx->flying_transfers_lock); - - if (to_cancel == NULL) - break ; - - usb_handle_transfer_completion(to_cancel, LIBUSB_TRANSFER_NO_DEVICE); - } - return ; -} +UNEXPORTED int usb_add_pollfd(libusb_context *ctx, int fd, short events); +UNEXPORTED void usb_remove_pollfd(libusb_context *ctx, int fd); +UNEXPORTED void usb_handle_transfer_completion(struct usb_transfer *uxfer, + enum libusb_transfer_status status); +UNEXPORTED void usb_handle_disconnect(struct libusb_device_handle *devh); #endif /*__LIBUSB10_H__*/ diff --git a/lib/libusb/libusb10_desc.c b/lib/libusb/libusb10_desc.c index a150f4d..b218c2e 100644 --- a/lib/libusb/libusb10_desc.c +++ b/lib/libusb/libusb10_desc.c @@ -47,7 +47,7 @@ libusb_get_device_descriptor(libusb_device * dev, ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_device_descriptor enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_device_descriptor enter"); if ((dev == NULL) || (desc == NULL)) return (LIBUSB_ERROR_INVALID_PARAM); @@ -70,7 +70,7 @@ libusb_get_device_descriptor(libusb_device * dev, desc->iSerialNumber = pdesc->iSerialNumber; desc->bNumConfigurations = pdesc->bNumConfigurations; - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_device_descriptor leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_device_descriptor leave"); return (0); } @@ -84,12 +84,12 @@ libusb_get_active_config_descriptor(libusb_device * dev, ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_active_config_descriptor enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_active_config_descriptor enter"); pdev = dev->os_priv; idx = libusb20_dev_get_config_index(pdev); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_active_config_descriptor leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_active_config_descriptor leave"); return (libusb_get_config_descriptor(dev, idx, config)); } @@ -113,7 +113,7 @@ libusb_get_config_descriptor(libusb_device * dev, uint8_t config_index, ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_config_descriptor enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_config_descriptor enter"); if (dev == NULL || config == NULL) return (LIBUSB_ERROR_INVALID_PARAM); @@ -225,7 +225,7 @@ libusb_get_config_descriptor(libusb_device * dev, uint8_t config_index, } free(pconf); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_config_descriptor leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_config_descriptor leave"); return (0); } @@ -241,7 +241,7 @@ libusb_get_config_descriptor_by_value(libusb_device * dev, ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_config_descriptor_by_value enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_config_descriptor_by_value enter"); if (dev == NULL || config == NULL) return (LIBUSB_ERROR_INVALID_PARAM); @@ -259,7 +259,7 @@ libusb_get_config_descriptor_by_value(libusb_device * dev, free(pconf); } - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_config_descriptor_by_value leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_config_descriptor_by_value leave"); return (LIBUSB_ERROR_NOT_FOUND); } @@ -270,10 +270,10 @@ libusb_free_config_descriptor(struct libusb_config_descriptor *config) ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_free_config_descriptor enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_free_config_descriptor enter"); free(config); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_free_config_descriptor leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_free_config_descriptor leave"); } int @@ -282,17 +282,16 @@ libusb_get_string_descriptor_ascii(libusb_device_handle * dev, { struct libusb20_device *pdev; libusb_context *ctx; - int ret; ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_string_descriptor_ascii enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_string_descriptor_ascii enter"); if (dev == NULL || data == NULL) return (LIBUSB20_ERROR_INVALID_PARAM); pdev = dev->os_priv; - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_string_descriptor_ascii leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_string_descriptor_ascii leave"); if (libusb20_dev_req_string_simple_sync(pdev, desc_index, data, length) == 0) return (strlen(data)); diff --git a/lib/libusb/libusb10_io.c b/lib/libusb/libusb10_io.c index 4eb30c4..b1cf75fa 100644 --- a/lib/libusb/libusb10_io.c +++ b/lib/libusb/libusb10_io.c @@ -39,15 +39,135 @@ #include "libusb.h" #include "libusb10.h" -static int +UNEXPORTED int +usb_add_pollfd(libusb_context *ctx, int fd, short events) +{ + struct usb_pollfd *pollfd; + + if (ctx == NULL) + return (LIBUSB_ERROR_INVALID_PARAM); + + pollfd = malloc(sizeof(*pollfd)); + if (pollfd == NULL) + return (LIBUSB_ERROR_NO_MEM); + + pollfd->pollfd.fd = fd; + pollfd->pollfd.events = events; + + pthread_mutex_lock(&ctx->pollfds_lock); + TAILQ_INSERT_TAIL(&ctx->pollfds, pollfd, list); + pthread_mutex_unlock(&ctx->pollfds_lock); + + if (ctx->fd_added_cb) + ctx->fd_added_cb(fd, events, ctx->fd_cb_user_data); + return (0); +} + +UNEXPORTED void +usb_remove_pollfd(libusb_context *ctx, int fd) +{ + struct usb_pollfd *pollfd; + int found; + + found = 0; + pthread_mutex_lock(&ctx->pollfds_lock); + + TAILQ_FOREACH(pollfd, &ctx->pollfds, list) { + if (pollfd->pollfd.fd == fd) { + found = 1; + break ; + } + } + + if (found == 0) { + pthread_mutex_unlock(&ctx->pollfds_lock); + return ; + } + + TAILQ_REMOVE(&ctx->pollfds, pollfd, list); + pthread_mutex_unlock(&ctx->pollfds_lock); + free(pollfd); + + if (ctx->fd_removed_cb) + ctx->fd_removed_cb(fd, ctx->fd_cb_user_data); +} + +UNEXPORTED void +usb_handle_transfer_completion(struct usb_transfer *uxfer, + enum libusb_transfer_status status) +{ + libusb_transfer *xfer; + libusb_context *ctx; + int len; + + xfer = (struct libusb_transfer *) ((uint8_t *)uxfer + + sizeof(struct usb_transfer)); + ctx = xfer->dev_handle->dev->ctx; + + pthread_mutex_lock(&ctx->flying_transfers_lock); + TAILQ_REMOVE(&ctx->flying_transfers, uxfer, list); + pthread_mutex_unlock(&ctx->flying_transfers_lock); + + if (status == LIBUSB_TRANSFER_COMPLETED && xfer->flags & + LIBUSB_TRANSFER_SHORT_NOT_OK) { + len = xfer->length; + if (xfer->type == LIBUSB_TRANSFER_TYPE_CONTROL) + len -= sizeof(libusb_control_setup); + if (len != uxfer->transferred) { + status = LIBUSB_TRANSFER_ERROR; + } + } + + xfer->status = status; + xfer->actual_length = uxfer->transferred; + + if (xfer->callback) + xfer->callback(xfer); + if (xfer->flags & LIBUSB_TRANSFER_FREE_TRANSFER) + libusb_free_transfer(xfer); + + pthread_mutex_lock(&ctx->event_waiters_lock); + pthread_cond_broadcast(&ctx->event_waiters_cond); + pthread_mutex_unlock(&ctx->event_waiters_lock); +} + +UNEXPORTED void +usb_handle_disconnect(struct libusb_device_handle *devh) +{ + struct libusb_context *ctx; + struct libusb_transfer *xfer; + struct usb_transfer *cur; + struct usb_transfer *to_cancel; + + ctx = devh->dev->ctx; + + while (1) { + pthread_mutex_lock(&ctx->flying_transfers_lock); + to_cancel = NULL; + TAILQ_FOREACH(cur, &ctx->flying_transfers, list) { + xfer = (struct libusb_transfer *) ((uint8_t *)cur + + sizeof(struct usb_transfer)); + if (xfer->dev_handle == devh) { + to_cancel = cur; + break ; + } + } + pthread_mutex_unlock(&ctx->flying_transfers_lock); + + if (to_cancel == NULL) + break ; + + usb_handle_transfer_completion(to_cancel, LIBUSB_TRANSFER_NO_DEVICE); + } + return ; +} + +UNEXPORTED int get_next_timeout(libusb_context *ctx, struct timeval *tv, struct timeval *out) { struct timeval timeout; - int ret; - ret = libusb_get_next_timeout(ctx, &timeout); - - if (ret) { + if (libusb_get_next_timeout(ctx, &timeout)) { if (timerisset(&timeout) == 0) return 1; if (timercmp(&timeout, tv, <) != 0) @@ -61,7 +181,7 @@ get_next_timeout(libusb_context *ctx, struct timeval *tv, struct timeval *out) return (0); } -static int +UNEXPORTED int handle_timeouts(struct libusb_context *ctx) { struct timespec sys_ts; @@ -75,13 +195,13 @@ handle_timeouts(struct libusb_context *ctx) ret = 0; pthread_mutex_lock(&ctx->flying_transfers_lock); - if (USB_LIST_EMPTY(&ctx->flying_transfers)) + if (TAILQ_EMPTY(&ctx->flying_transfers)) goto out; ret = clock_gettime(CLOCK_MONOTONIC, &sys_ts); TIMESPEC_TO_TIMEVAL(&sys_tv, &sys_ts); - LIST_FOREACH_ENTRY(xfer, &ctx->flying_transfers, list) { + TAILQ_FOREACH(xfer, &ctx->flying_transfers, list) { cur_tv = &xfer->timeout; if (timerisset(cur_tv) == 0) @@ -104,39 +224,35 @@ out: return (ret); } -static int +UNEXPORTED int handle_events(struct libusb_context *ctx, struct timeval *tv) { struct libusb_pollfd *tmppollfd; struct libusb_device_handle *devh; struct usb_pollfd *ipollfd; - struct usb_transfer *cur; - struct usb_transfer *cancel; - struct libusb_transfer *xfer; struct pollfd *fds; struct pollfd *tfds; nfds_t nfds; int tmpfd; - int tmp; int ret; int timeout; int i; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "handle_events enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "handle_events enter"); nfds = 0; i = -1; pthread_mutex_lock(&ctx->pollfds_lock); - LIST_FOREACH_ENTRY(ipollfd, &ctx->pollfds, list) + TAILQ_FOREACH(ipollfd, &ctx->pollfds, list) nfds++; - fds = malloc(sizeof(*fds) * nfds); + fds = alloca(sizeof(*fds) * nfds); if (fds == NULL) return (LIBUSB_ERROR_NO_MEM); - LIST_FOREACH_ENTRY(ipollfd, &ctx->pollfds, list) { + TAILQ_FOREACH(ipollfd, &ctx->pollfds, list) { tmppollfd = &ipollfd->pollfd; tmpfd = tmppollfd->fd; i++; @@ -152,16 +268,12 @@ handle_events(struct libusb_context *ctx, struct timeval *tv) timeout++; ret = poll(fds, nfds, timeout); - if (ret == 0) { - free(fds); + if (ret == 0) return (handle_timeouts(ctx)); - } else if (ret == -1 && errno == EINTR) { - free(fds); + else if (ret == -1 && errno == EINTR) return (LIBUSB_ERROR_INTERRUPTED); - } else if (ret < 0) { - free(fds); + else if (ret < 0) return (LIBUSB_ERROR_IO); - } if (fds[0].revents) { if (ret == 1){ @@ -174,28 +286,30 @@ handle_events(struct libusb_context *ctx, struct timeval *tv) } pthread_mutex_lock(&ctx->open_devs_lock); - for (i = 0 ; i < nfds && ret > 0 ; i++) { + for (i = 0, devh = NULL ; i < nfds && ret > 0 ; i++) { tfds = &fds[i]; if (!tfds->revents) continue; ret--; - LIST_FOREACH_ENTRY(devh, &ctx->open_devs, list) { + TAILQ_FOREACH(devh, &ctx->open_devs, list) { if (libusb20_dev_get_fd(devh->os_priv) == tfds->fd) break ; } if (tfds->revents & POLLERR) { usb_remove_pollfd(ctx, libusb20_dev_get_fd(devh->os_priv)); - usb_handle_disconnect(devh); + if (devh != NULL) + usb_handle_disconnect(devh); continue ; } pthread_mutex_lock(&libusb20_lock); - dprintf(ctx, LIBUSB_DEBUG_TRANSFER, "LIBUSB20_PROCESS"); - ret = libusb20_dev_process(devh->os_priv); + DPRINTF(ctx, LIBUSB_DEBUG_TRANSFER, "LIBUSB20_PROCESS"); + if (devh != NULL) + ret = libusb20_dev_process(devh->os_priv); pthread_mutex_unlock(&libusb20_lock); @@ -210,8 +324,7 @@ out: pthread_mutex_unlock(&ctx->open_devs_lock); handled: - free(fds); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "handle_events leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "handle_events leave"); return ret; } @@ -223,7 +336,7 @@ libusb_try_lock_events(libusb_context * ctx) int ret; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_try_lock_events enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_try_lock_events enter"); pthread_mutex_lock(&ctx->pollfd_modify_lock); ret = ctx->pollfd_modify; @@ -239,7 +352,7 @@ libusb_try_lock_events(libusb_context * ctx) ctx->event_handler_active = 1; - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_try_lock_events leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_try_lock_events leave"); return (0); } @@ -247,19 +360,19 @@ void libusb_lock_events(libusb_context * ctx) { GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_lock_events enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_lock_events enter"); pthread_mutex_lock(&ctx->events_lock); ctx->event_handler_active = 1; - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_lock_events leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_lock_events leave"); } void libusb_unlock_events(libusb_context * ctx) { GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_unlock_events enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_unlock_events enter"); ctx->event_handler_active = 0; pthread_mutex_unlock(&ctx->events_lock); @@ -268,7 +381,7 @@ libusb_unlock_events(libusb_context * ctx) pthread_cond_broadcast(&ctx->event_waiters_cond); pthread_mutex_unlock(&ctx->event_waiters_lock); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_unlock_events leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_unlock_events leave"); } int @@ -277,7 +390,7 @@ libusb_event_handling_ok(libusb_context * ctx) int ret; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_event_handling_ok enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_event_handling_ok enter"); pthread_mutex_lock(&ctx->pollfd_modify_lock); ret = ctx->pollfd_modify; @@ -286,7 +399,7 @@ libusb_event_handling_ok(libusb_context * ctx) if (ret != 0) return (0); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_event_handling_ok leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_event_handling_ok leave"); return (1); } @@ -296,7 +409,7 @@ libusb_event_handler_active(libusb_context * ctx) int ret; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_event_handler_active enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_event_handler_active enter"); pthread_mutex_lock(&ctx->pollfd_modify_lock); ret = ctx->pollfd_modify; @@ -305,7 +418,7 @@ libusb_event_handler_active(libusb_context * ctx) if (ret != 0) return (1); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_event_handler_active leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_event_handler_active leave"); return (ctx->event_handler_active); } @@ -313,22 +426,22 @@ void libusb_lock_event_waiters(libusb_context * ctx) { GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_lock_event_waiters enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_lock_event_waiters enter"); pthread_mutex_lock(&ctx->event_waiters_lock); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_lock_event_waiters leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_lock_event_waiters leave"); } void libusb_unlock_event_waiters(libusb_context * ctx) { GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_unlock_event_waiters enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_unlock_event_waiters enter"); pthread_mutex_unlock(&ctx->event_waiters_lock); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_unlock_event_waiters leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_unlock_event_waiters leave"); } int @@ -338,7 +451,7 @@ libusb_wait_for_event(libusb_context * ctx, struct timeval *tv) struct timespec ts; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_wait_for_event enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_wait_for_event enter"); if (tv == NULL) { pthread_cond_wait(&ctx->event_waiters_cond, @@ -363,19 +476,18 @@ libusb_wait_for_event(libusb_context * ctx, struct timeval *tv) if (ret == ETIMEDOUT) return (1); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_wait_for_event leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_wait_for_event leave"); return (0); } int libusb_handle_events_timeout(libusb_context * ctx, struct timeval *tv) { - struct timeval timeout; struct timeval poll_timeout; int ret; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_handle_events_timeout enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_handle_events_timeout enter"); ret = get_next_timeout(ctx, tv, &poll_timeout); if (ret != 0) { @@ -402,7 +514,7 @@ retry: else if (ret == 1) return (handle_timeouts(ctx)); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_handle_events_timeout leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_handle_events_timeout leave"); return (0); } @@ -413,13 +525,13 @@ libusb_handle_events(libusb_context * ctx) int ret; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_handle_events enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_handle_events enter"); tv.tv_sec = 2; tv.tv_usec = 0; ret = libusb_handle_events_timeout(ctx, &tv); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_handle_events leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_handle_events leave"); return (ret); } @@ -430,7 +542,7 @@ libusb_handle_events_locked(libusb_context * ctx, struct timeval *tv) struct timeval poll_tv; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_handle_events_locked enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_handle_events_locked enter"); ret = get_next_timeout(ctx, tv, &poll_tv); if (ret != 0) { @@ -439,7 +551,7 @@ libusb_handle_events_locked(libusb_context * ctx, struct timeval *tv) ret = handle_events(ctx, &poll_tv); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_handle_events_locked leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_handle_events_locked leave"); return (ret); } @@ -454,16 +566,16 @@ libusb_get_next_timeout(libusb_context * ctx, struct timeval *tv) int ret; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_next_timeout enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_next_timeout enter"); found = 0; pthread_mutex_lock(&ctx->flying_transfers_lock); - if (USB_LIST_EMPTY(&ctx->flying_transfers)) { + if (TAILQ_EMPTY(&ctx->flying_transfers)) { pthread_mutex_unlock(&ctx->flying_transfers_lock); return (0); } - LIST_FOREACH_ENTRY(xfer, &ctx->flying_transfers, list) { + TAILQ_FOREACH(xfer, &ctx->flying_transfers, list) { if (!(xfer->flags & USB_TIMED_OUT)) { found = 1; break ; @@ -489,7 +601,7 @@ libusb_get_next_timeout(libusb_context * ctx, struct timeval *tv) else timersub(next_tv, &cur_tv, tv); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_next_timeout leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_next_timeout leave"); return (1); } @@ -499,13 +611,13 @@ libusb_set_pollfd_notifiers(libusb_context * ctx, void *user_data) { GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_set_pollfd_notifiers enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_set_pollfd_notifiers enter"); ctx->fd_added_cb = added_cb; ctx->fd_removed_cb = removed_cb; ctx->fd_cb_user_data = user_data; - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_set_pollfd_notifiers leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_set_pollfd_notifiers leave"); } struct libusb_pollfd ** @@ -516,11 +628,11 @@ libusb_get_pollfds(libusb_context * ctx) int i; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_pollfds enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_pollfds enter"); i = 0; pthread_mutex_lock(&ctx->pollfds_lock); - LIST_FOREACH_ENTRY(pollfd, &ctx->pollfds, list) + TAILQ_FOREACH(pollfd, &ctx->pollfds, list) i++; ret = calloc(i + 1 , sizeof(struct libusb_pollfd *)); @@ -530,11 +642,11 @@ libusb_get_pollfds(libusb_context * ctx) } i = 0; - LIST_FOREACH_ENTRY(pollfd, &ctx->pollfds, list) + TAILQ_FOREACH(pollfd, &ctx->pollfds, list) ret[i++] = (struct libusb_pollfd *) pollfd; ret[i] = NULL; - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_pollfds leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_pollfds leave"); return (ret); } @@ -548,7 +660,7 @@ static void ctrl_tr_cb(struct libusb_transfer *transfer) ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_TRANSFER, "CALLBACK ENTER"); + DPRINTF(ctx, LIBUSB_DEBUG_TRANSFER, "CALLBACK ENTER"); complet = transfer->user_data; *complet = 1; @@ -568,7 +680,7 @@ libusb_control_transfer(libusb_device_handle * devh, ctx = devh->dev->ctx; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_control_transfer enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_control_transfer enter"); if (devh == NULL || data == NULL) return (LIBUSB_ERROR_NO_MEM); @@ -637,7 +749,7 @@ libusb_control_transfer(libusb_device_handle * devh, } libusb_free_transfer(xfer); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_control_transfer leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_control_transfer leave"); return (ret); } @@ -659,6 +771,7 @@ do_transfer(struct libusb_device_handle *devh, return (LIBUSB_ERROR_NO_MEM); ctx = devh->dev->ctx; + GET_CONTEXT(ctx); xfer->dev_handle = devh; xfer->endpoint = endpoint; @@ -670,8 +783,10 @@ do_transfer(struct libusb_device_handle *devh, xfer->callback = ctrl_tr_cb; complet = 0; + DPRINTF(ctx, LIBUSB_DEBUG_TRANSFER, "SUBMIT_TRANSFER"); if ((ret = libusb_submit_transfer(xfer)) < 0) { libusb_free_transfer(xfer); + DPRINTF(ctx, LIBUSB_DEBUG_TRANSFER, "SUBMIT_TRANSFER FAILED %i", ret); return (ret); } @@ -688,6 +803,7 @@ do_transfer(struct libusb_device_handle *devh, } *transferred = xfer->actual_length; + DPRINTF(ctx, LIBUSB_DEBUG_TRANSFER, "xfer->status %i", xfer->status); switch (xfer->status) { case LIBUSB_TRANSFER_COMPLETED: ret = xfer->actual_length; @@ -716,12 +832,12 @@ libusb_bulk_transfer(struct libusb_device_handle *devh, ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_bulk_transfer enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_bulk_transfer enter"); ret = do_transfer(devh, endpoint, data, length, transferred, timeout, LIBUSB_TRANSFER_TYPE_BULK); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_bulk_transfer leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_bulk_transfer leave"); return (ret); } @@ -738,11 +854,11 @@ libusb_interrupt_transfer(struct libusb_device_handle *devh, ctx = NULL; GET_CONTEXT(ctx); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_interrupt_transfer enter"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_interrupt_transfer enter"); ret = do_transfer(devh, endpoint, data, length, transferred, timeout, LIBUSB_TRANSFER_TYPE_INTERRUPT); - dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_interrupt_transfer leave"); + DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_interrupt_transfer leave"); return (ret); } |