Index: stable/11/lib/libusb/libusb10.h =================================================================== --- stable/11/lib/libusb/libusb10.h (revision 349667) +++ stable/11/lib/libusb/libusb10.h (revision 349668) @@ -1,141 +1,143 @@ /* $FreeBSD$ */ /*- * Copyright (c) 2009 Sylvestre Gallon. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifndef __LIBUSB10_H__ #define __LIBUSB10_H__ #ifndef LIBUSB_GLOBAL_INCLUDE_FILE #include #endif #define GET_CONTEXT(ctx) (((ctx) == NULL) ? usbi_default_context : (ctx)) #define UNEXPORTED __attribute__((__visibility__("hidden"))) #define CTX_LOCK(ctx) pthread_mutex_lock(&(ctx)->ctx_lock) #define CTX_TRYLOCK(ctx) pthread_mutex_trylock(&(ctx)->ctx_lock) #define CTX_UNLOCK(ctx) pthread_mutex_unlock(&(ctx)->ctx_lock) #define HOTPLUG_LOCK(ctx) pthread_mutex_lock(&(ctx)->hotplug_lock) #define HOTPLUG_UNLOCK(ctx) pthread_mutex_unlock(&(ctx)->hotplug_lock) #define DPRINTF(ctx, dbg, format, ...) do { \ switch (dbg) { \ case LIBUSB_DEBUG_FUNCTION: \ if ((ctx)->debug & LIBUSB_DEBUG_FUNCTION) { \ printf("LIBUSB_FUNCTION: " \ format "\n", ## __VA_ARGS__); \ } \ break; \ case LIBUSB_DEBUG_TRANSFER: \ if ((ctx)->debug & LIBUSB_DEBUG_TRANSFER) { \ printf("LIBUSB_TRANSFER: " \ format "\n", ## __VA_ARGS__); \ } \ break; \ default: \ break; \ } \ } while (0) /* internal structures */ struct libusb_super_pollfd { TAILQ_ENTRY(libusb_super_pollfd) entry; struct libusb20_device *pdev; struct libusb_pollfd pollfd; }; struct libusb_super_transfer { TAILQ_ENTRY(libusb_super_transfer) entry; uint8_t *curr_data; uint32_t rem_len; uint32_t last_len; uint32_t stream_id; uint8_t state; #define LIBUSB_SUPER_XFER_ST_NONE 0 #define LIBUSB_SUPER_XFER_ST_PEND 1 }; struct libusb_hotplug_callback_handle_struct { TAILQ_ENTRY(libusb_hotplug_callback_handle_struct) entry; int events; int vendor; int product; int devclass; libusb_hotplug_callback_fn fn; void *user_data; }; +TAILQ_HEAD(libusb_device_head, libusb_device); + struct libusb_context { int debug; int debug_fixed; int ctrl_pipe[2]; int tr_done_ref; int tr_done_gen; pthread_mutex_t ctx_lock; pthread_mutex_t hotplug_lock; pthread_cond_t ctx_cond; pthread_t hotplug_handler; pthread_t ctx_handler; #define NO_THREAD ((pthread_t)-1) TAILQ_HEAD(, libusb_super_pollfd) pollfds; TAILQ_HEAD(, libusb_super_transfer) tr_done; TAILQ_HEAD(, libusb_hotplug_callback_handle_struct) hotplug_cbh; - TAILQ_HEAD(, libusb_device) hotplug_devs; + struct libusb_device_head hotplug_devs; struct libusb_super_pollfd ctx_poll; libusb_pollfd_added_cb fd_added_cb; libusb_pollfd_removed_cb fd_removed_cb; void *fd_cb_user_data; }; struct libusb_device { int refcnt; int device_is_gone; uint32_t claimed_interfaces; struct libusb_super_pollfd dev_poll; struct libusb_context *ctx; TAILQ_ENTRY(libusb_device) hotplug_entry; TAILQ_HEAD(, libusb_super_transfer) tr_head; struct libusb20_device *os_priv; }; extern struct libusb_context *usbi_default_context; void libusb10_add_pollfd(libusb_context *ctx, struct libusb_super_pollfd *pollfd, struct libusb20_device *pdev, int fd, short events); void libusb10_remove_pollfd(libusb_context *ctx, struct libusb_super_pollfd *pollfd); void libusb10_cancel_all_transfer(libusb_device *dev); void libusb10_cancel_all_transfer_locked(struct libusb20_device *pdev, struct libusb_device *dev); #endif /* __LIBUSB10_H__ */ Index: stable/11/lib/libusb/libusb10_hotplug.c =================================================================== --- stable/11/lib/libusb/libusb10_hotplug.c (revision 349667) +++ stable/11/lib/libusb/libusb10_hotplug.c (revision 349668) @@ -1,237 +1,248 @@ /* $FreeBSD$ */ /*- - * Copyright (c) 2016 Hans Petter Selasky. All rights reserved. + * Copyright (c) 2016-2019 Hans Petter Selasky. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifdef LIBUSB_GLOBAL_INCLUDE_FILE #include LIBUSB_GLOBAL_INCLUDE_FILE #else #include #include #include #include #include #include #include #include #include #include #include #include #include #endif #define libusb_device_handle libusb20_device #include "libusb20.h" #include "libusb20_desc.h" #include "libusb20_int.h" #include "libusb.h" #include "libusb10.h" static int libusb_hotplug_equal(libusb_device *_adev, libusb_device *_bdev) { struct libusb20_device *adev = _adev->os_priv; struct libusb20_device *bdev = _bdev->os_priv; if (adev->bus_number != bdev->bus_number) return (0); if (adev->device_address != bdev->device_address) return (0); if (memcmp(&adev->ddesc, &bdev->ddesc, sizeof(adev->ddesc))) return (0); if (memcmp(&adev->session_data, &bdev->session_data, sizeof(adev->session_data))) return (0); return (1); } static int libusb_hotplug_filter(libusb_context *ctx, libusb_hotplug_callback_handle pcbh, libusb_device *dev, libusb_hotplug_event event) { if (!(pcbh->events & event)) return (0); if (pcbh->vendor != LIBUSB_HOTPLUG_MATCH_ANY && pcbh->vendor != libusb20_dev_get_device_desc(dev->os_priv)->idVendor) return (0); if (pcbh->product != LIBUSB_HOTPLUG_MATCH_ANY && pcbh->product != libusb20_dev_get_device_desc(dev->os_priv)->idProduct) return (0); if (pcbh->devclass != LIBUSB_HOTPLUG_MATCH_ANY && pcbh->devclass != libusb20_dev_get_device_desc(dev->os_priv)->bDeviceClass) return (0); return (pcbh->fn(ctx, dev, event, pcbh->user_data)); } +static int +libusb_hotplug_enumerate(libusb_context *ctx, struct libusb_device_head *phead) +{ + libusb_device **ppdev; + ssize_t count; + ssize_t x; + + count = libusb_get_device_list(ctx, &ppdev); + if (count < 0) + return (-1); + + for (x = 0; x != count; x++) + TAILQ_INSERT_TAIL(phead, ppdev[x], hotplug_entry); + + libusb_free_device_list(ppdev, 0); + return (0); +} + static void * libusb_hotplug_scan(void *arg) { - TAILQ_HEAD(, libusb_device) hotplug_devs; + struct libusb_device_head hotplug_devs; libusb_hotplug_callback_handle acbh; libusb_hotplug_callback_handle bcbh; libusb_context *ctx = arg; - libusb_device **ppdev; libusb_device *temp; libusb_device *adev; libusb_device *bdev; unsigned do_loop = 1; - ssize_t count; - ssize_t x; while (do_loop) { usleep(4000000); HOTPLUG_LOCK(ctx); TAILQ_INIT(&hotplug_devs); if (ctx->hotplug_handler != NO_THREAD) { - count = libusb_get_device_list(ctx, &ppdev); - if (count < 0) + if (libusb_hotplug_enumerate(ctx, &hotplug_devs) < 0) continue; - for (x = 0; x != count; x++) { - TAILQ_INSERT_TAIL(&hotplug_devs, ppdev[x], - hotplug_entry); - } - libusb_free_device_list(ppdev, 0); } else { do_loop = 0; } /* figure out which devices are gone */ TAILQ_FOREACH_SAFE(adev, &ctx->hotplug_devs, hotplug_entry, temp) { TAILQ_FOREACH(bdev, &hotplug_devs, hotplug_entry) { if (libusb_hotplug_equal(adev, bdev)) break; } if (bdev == NULL) { TAILQ_REMOVE(&ctx->hotplug_devs, adev, hotplug_entry); TAILQ_FOREACH_SAFE(acbh, &ctx->hotplug_cbh, entry, bcbh) { if (libusb_hotplug_filter(ctx, acbh, adev, LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT) == 0) continue; TAILQ_REMOVE(&ctx->hotplug_cbh, acbh, entry); free(acbh); } libusb_unref_device(adev); } } /* figure out which devices are new */ TAILQ_FOREACH_SAFE(adev, &hotplug_devs, hotplug_entry, temp) { TAILQ_FOREACH(bdev, &ctx->hotplug_devs, hotplug_entry) { if (libusb_hotplug_equal(adev, bdev)) break; } if (bdev == NULL) { TAILQ_REMOVE(&hotplug_devs, adev, hotplug_entry); TAILQ_INSERT_TAIL(&ctx->hotplug_devs, adev, hotplug_entry); TAILQ_FOREACH_SAFE(acbh, &ctx->hotplug_cbh, entry, bcbh) { if (libusb_hotplug_filter(ctx, acbh, adev, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED) == 0) continue; TAILQ_REMOVE(&ctx->hotplug_cbh, acbh, entry); free(acbh); } } } HOTPLUG_UNLOCK(ctx); /* unref remaining devices */ while ((adev = TAILQ_FIRST(&hotplug_devs)) != NULL) { TAILQ_REMOVE(&hotplug_devs, adev, hotplug_entry); libusb_unref_device(adev); } } return (NULL); } int libusb_hotplug_register_callback(libusb_context *ctx, libusb_hotplug_event events, libusb_hotplug_flag flags, int vendor_id, int product_id, int dev_class, libusb_hotplug_callback_fn cb_fn, void *user_data, libusb_hotplug_callback_handle *phandle) { libusb_hotplug_callback_handle handle; struct libusb_device *adev; ctx = GET_CONTEXT(ctx); if (ctx == NULL || cb_fn == NULL || events == 0 || vendor_id < -1 || vendor_id > 0xffff || product_id < -1 || product_id > 0xffff || dev_class < -1 || dev_class > 0xff) return (LIBUSB_ERROR_INVALID_PARAM); handle = malloc(sizeof(*handle)); if (handle == NULL) return (LIBUSB_ERROR_NO_MEM); HOTPLUG_LOCK(ctx); if (ctx->hotplug_handler == NO_THREAD) { + libusb_hotplug_enumerate(ctx, &ctx->hotplug_devs); + if (pthread_create(&ctx->hotplug_handler, NULL, &libusb_hotplug_scan, ctx) != 0) ctx->hotplug_handler = NO_THREAD; } handle->events = events; handle->vendor = vendor_id; handle->product = product_id; handle->devclass = dev_class; handle->fn = cb_fn; handle->user_data = user_data; if (flags & LIBUSB_HOTPLUG_ENUMERATE) { TAILQ_FOREACH(adev, &ctx->hotplug_devs, hotplug_entry) { if (libusb_hotplug_filter(ctx, handle, adev, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED) == 0) continue; free(handle); handle = NULL; break; } } if (handle != NULL) TAILQ_INSERT_TAIL(&ctx->hotplug_cbh, handle, entry); HOTPLUG_UNLOCK(ctx); if (phandle != NULL) *phandle = handle; return (LIBUSB_SUCCESS); } void libusb_hotplug_deregister_callback(libusb_context *ctx, libusb_hotplug_callback_handle handle) { ctx = GET_CONTEXT(ctx); if (ctx == NULL || handle == NULL) return; HOTPLUG_LOCK(ctx); TAILQ_REMOVE(&ctx->hotplug_cbh, handle, entry); HOTPLUG_UNLOCK(ctx); free(handle); } Index: stable/11 =================================================================== --- stable/11 (revision 349667) +++ stable/11 (revision 349668) Property changes on: stable/11 ___________________________________________________________________ Modified: svn:mergeinfo ## -0,0 +0,1 ## Merged /head:r349409-349410