18c8fff31SAndrew Thompson /* $FreeBSD$ */ 28c8fff31SAndrew Thompson /*- 38c8fff31SAndrew Thompson * Copyright (c) 2009 Sylvestre Gallon. All rights reserved. 4390065b1SAlfred Perlstein * Copyright (c) 2009 Hans Petter Selasky. All rights reserved. 58c8fff31SAndrew Thompson * 68c8fff31SAndrew Thompson * Redistribution and use in source and binary forms, with or without 78c8fff31SAndrew Thompson * modification, are permitted provided that the following conditions 88c8fff31SAndrew Thompson * are met: 98c8fff31SAndrew Thompson * 1. Redistributions of source code must retain the above copyright 108c8fff31SAndrew Thompson * notice, this list of conditions and the following disclaimer. 118c8fff31SAndrew Thompson * 2. Redistributions in binary form must reproduce the above copyright 128c8fff31SAndrew Thompson * notice, this list of conditions and the following disclaimer in the 138c8fff31SAndrew Thompson * documentation and/or other materials provided with the distribution. 148c8fff31SAndrew Thompson * 158c8fff31SAndrew Thompson * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 168c8fff31SAndrew Thompson * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 178c8fff31SAndrew Thompson * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 188c8fff31SAndrew Thompson * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 198c8fff31SAndrew Thompson * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 208c8fff31SAndrew Thompson * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 218c8fff31SAndrew Thompson * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 228c8fff31SAndrew Thompson * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 238c8fff31SAndrew Thompson * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 248c8fff31SAndrew Thompson * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 258c8fff31SAndrew Thompson * SUCH DAMAGE. 268c8fff31SAndrew Thompson */ 278c8fff31SAndrew Thompson 28f3cba95cSWojciech A. Koszek #include <sys/fcntl.h> 29f3cba95cSWojciech A. Koszek #include <sys/ioctl.h> 30f3cba95cSWojciech A. Koszek #include <sys/queue.h> 31f3cba95cSWojciech A. Koszek 32ac840bfcSWojciech A. Koszek #include <assert.h> 33f3cba95cSWojciech A. Koszek #include <errno.h> 348c8fff31SAndrew Thompson #include <poll.h> 358c8fff31SAndrew Thompson #include <pthread.h> 36f3cba95cSWojciech A. Koszek #include <stdio.h> 37f3cba95cSWojciech A. Koszek #include <stdlib.h> 38f3cba95cSWojciech A. Koszek #include <unistd.h> 398c8fff31SAndrew Thompson 409c087c5aSAndrew Thompson #define libusb_device_handle libusb20_device 419c087c5aSAndrew Thompson 428c8fff31SAndrew Thompson #include "libusb20.h" 438c8fff31SAndrew Thompson #include "libusb20_desc.h" 448c8fff31SAndrew Thompson #include "libusb20_int.h" 458c8fff31SAndrew Thompson #include "libusb.h" 468c8fff31SAndrew Thompson #include "libusb10.h" 478c8fff31SAndrew Thompson 488c8fff31SAndrew Thompson static pthread_mutex_t default_context_lock = PTHREAD_MUTEX_INITIALIZER; 498c8fff31SAndrew Thompson struct libusb_context *usbi_default_context = NULL; 50390065b1SAlfred Perlstein 51390065b1SAlfred Perlstein /* Prototypes */ 52390065b1SAlfred Perlstein 53390065b1SAlfred Perlstein static struct libusb20_transfer *libusb10_get_transfer(struct libusb20_device *, uint8_t, uint8_t); 54390065b1SAlfred Perlstein static int libusb10_get_buffsize(struct libusb20_device *, libusb_transfer *); 55390065b1SAlfred Perlstein static int libusb10_convert_error(uint8_t status); 56390065b1SAlfred Perlstein static void libusb10_complete_transfer(struct libusb20_transfer *, struct libusb_super_transfer *, int); 57390065b1SAlfred Perlstein static void libusb10_isoc_proxy(struct libusb20_transfer *); 58390065b1SAlfred Perlstein static void libusb10_bulk_intr_proxy(struct libusb20_transfer *); 59390065b1SAlfred Perlstein static void libusb10_ctrl_proxy(struct libusb20_transfer *); 60390065b1SAlfred Perlstein static void libusb10_submit_transfer_sub(struct libusb20_device *, uint8_t); 618c8fff31SAndrew Thompson 628c8fff31SAndrew Thompson /* Library initialisation / deinitialisation */ 638c8fff31SAndrew Thompson 648c8fff31SAndrew Thompson void 658c8fff31SAndrew Thompson libusb_set_debug(libusb_context *ctx, int level) 668c8fff31SAndrew Thompson { 67390065b1SAlfred Perlstein ctx = GET_CONTEXT(ctx); 688c8fff31SAndrew Thompson if (ctx) 698c8fff31SAndrew Thompson ctx->debug = level; 708c8fff31SAndrew Thompson } 718c8fff31SAndrew Thompson 72698e791aSHans Petter Selasky static void 73698e791aSHans Petter Selasky libusb_set_nonblocking(int f) 74698e791aSHans Petter Selasky { 75698e791aSHans Petter Selasky int flags; 76698e791aSHans Petter Selasky 77698e791aSHans Petter Selasky /* 78698e791aSHans Petter Selasky * We ignore any failures in this function, hence the 79698e791aSHans Petter Selasky * non-blocking flag is not critical to the operation of 80698e791aSHans Petter Selasky * libUSB. We use F_GETFL and F_SETFL to be compatible with 81698e791aSHans Petter Selasky * Linux. 82698e791aSHans Petter Selasky */ 83698e791aSHans Petter Selasky 84698e791aSHans Petter Selasky flags = fcntl(f, F_GETFL, NULL); 85698e791aSHans Petter Selasky if (flags == -1) 86698e791aSHans Petter Selasky return; 87698e791aSHans Petter Selasky flags |= O_NONBLOCK; 88698e791aSHans Petter Selasky fcntl(f, F_SETFL, flags); 89698e791aSHans Petter Selasky } 90698e791aSHans Petter Selasky 918c8fff31SAndrew Thompson int 928c8fff31SAndrew Thompson libusb_init(libusb_context **context) 938c8fff31SAndrew Thompson { 948c8fff31SAndrew Thompson struct libusb_context *ctx; 958c8fff31SAndrew Thompson char *debug; 968c8fff31SAndrew Thompson int ret; 978c8fff31SAndrew Thompson 988c8fff31SAndrew Thompson ctx = malloc(sizeof(*ctx)); 998c8fff31SAndrew Thompson if (!ctx) 1008c8fff31SAndrew Thompson return (LIBUSB_ERROR_INVALID_PARAM); 1018c8fff31SAndrew Thompson 1028c8fff31SAndrew Thompson memset(ctx, 0, sizeof(*ctx)); 1038c8fff31SAndrew Thompson 1048c8fff31SAndrew Thompson debug = getenv("LIBUSB_DEBUG"); 1058c8fff31SAndrew Thompson if (debug != NULL) { 1068c8fff31SAndrew Thompson ctx->debug = atoi(debug); 1078c8fff31SAndrew Thompson if (ctx->debug != 0) 1088c8fff31SAndrew Thompson ctx->debug_fixed = 1; 1098c8fff31SAndrew Thompson } 110c500e4ddSAndrew Thompson TAILQ_INIT(&ctx->pollfds); 111390065b1SAlfred Perlstein TAILQ_INIT(&ctx->tr_done); 112390065b1SAlfred Perlstein 113390065b1SAlfred Perlstein pthread_mutex_init(&ctx->ctx_lock, NULL); 114390065b1SAlfred Perlstein pthread_cond_init(&ctx->ctx_cond, NULL); 115390065b1SAlfred Perlstein 116390065b1SAlfred Perlstein ctx->ctx_handler = NO_THREAD; 1178c8fff31SAndrew Thompson 1188c8fff31SAndrew Thompson ret = pipe(ctx->ctrl_pipe); 1198c8fff31SAndrew Thompson if (ret < 0) { 120390065b1SAlfred Perlstein pthread_mutex_destroy(&ctx->ctx_lock); 121390065b1SAlfred Perlstein pthread_cond_destroy(&ctx->ctx_cond); 1228c8fff31SAndrew Thompson free(ctx); 1238c8fff31SAndrew Thompson return (LIBUSB_ERROR_OTHER); 1248c8fff31SAndrew Thompson } 125390065b1SAlfred Perlstein /* set non-blocking mode on the control pipe to avoid deadlock */ 126698e791aSHans Petter Selasky libusb_set_nonblocking(ctx->ctrl_pipe[0]); 127698e791aSHans Petter Selasky libusb_set_nonblocking(ctx->ctrl_pipe[1]); 1288c8fff31SAndrew Thompson 129390065b1SAlfred Perlstein libusb10_add_pollfd(ctx, &ctx->ctx_poll, NULL, ctx->ctrl_pipe[0], POLLIN); 1308c8fff31SAndrew Thompson 1318c8fff31SAndrew Thompson pthread_mutex_lock(&default_context_lock); 1328c8fff31SAndrew Thompson if (usbi_default_context == NULL) { 1338c8fff31SAndrew Thompson usbi_default_context = ctx; 1348c8fff31SAndrew Thompson } 1358c8fff31SAndrew Thompson pthread_mutex_unlock(&default_context_lock); 1368c8fff31SAndrew Thompson 1378c8fff31SAndrew Thompson if (context) 1388c8fff31SAndrew Thompson *context = ctx; 1398c8fff31SAndrew Thompson 140390065b1SAlfred Perlstein DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_init complete"); 141390065b1SAlfred Perlstein 1428c8fff31SAndrew Thompson return (0); 1438c8fff31SAndrew Thompson } 1448c8fff31SAndrew Thompson 1458c8fff31SAndrew Thompson void 1468c8fff31SAndrew Thompson libusb_exit(libusb_context *ctx) 1478c8fff31SAndrew Thompson { 148390065b1SAlfred Perlstein ctx = GET_CONTEXT(ctx); 1498c8fff31SAndrew Thompson 150390065b1SAlfred Perlstein if (ctx == NULL) 151390065b1SAlfred Perlstein return; 152390065b1SAlfred Perlstein 153390065b1SAlfred Perlstein /* XXX cleanup devices */ 154390065b1SAlfred Perlstein 155390065b1SAlfred Perlstein libusb10_remove_pollfd(ctx, &ctx->ctx_poll); 1568c8fff31SAndrew Thompson close(ctx->ctrl_pipe[0]); 1578c8fff31SAndrew Thompson close(ctx->ctrl_pipe[1]); 158390065b1SAlfred Perlstein pthread_mutex_destroy(&ctx->ctx_lock); 159390065b1SAlfred Perlstein pthread_cond_destroy(&ctx->ctx_cond); 1608c8fff31SAndrew Thompson 1618c8fff31SAndrew Thompson pthread_mutex_lock(&default_context_lock); 1628c8fff31SAndrew Thompson if (ctx == usbi_default_context) { 1638c8fff31SAndrew Thompson usbi_default_context = NULL; 1648c8fff31SAndrew Thompson } 1658c8fff31SAndrew Thompson pthread_mutex_unlock(&default_context_lock); 1668c8fff31SAndrew Thompson 1678c8fff31SAndrew Thompson free(ctx); 1688c8fff31SAndrew Thompson } 1698c8fff31SAndrew Thompson 1708c8fff31SAndrew Thompson /* Device handling and initialisation. */ 1718c8fff31SAndrew Thompson 1728c8fff31SAndrew Thompson ssize_t 1738c8fff31SAndrew Thompson libusb_get_device_list(libusb_context *ctx, libusb_device ***list) 1748c8fff31SAndrew Thompson { 1758c8fff31SAndrew Thompson struct libusb20_backend *usb_backend; 176390065b1SAlfred Perlstein struct libusb20_device *pdev; 177390065b1SAlfred Perlstein struct libusb_device *dev; 1788c8fff31SAndrew Thompson int i; 1798c8fff31SAndrew Thompson 180390065b1SAlfred Perlstein ctx = GET_CONTEXT(ctx); 181390065b1SAlfred Perlstein 182390065b1SAlfred Perlstein if (ctx == NULL) 183390065b1SAlfred Perlstein return (LIBUSB_ERROR_INVALID_PARAM); 184390065b1SAlfred Perlstein 185390065b1SAlfred Perlstein if (list == NULL) 186390065b1SAlfred Perlstein return (LIBUSB_ERROR_INVALID_PARAM); 1878c8fff31SAndrew Thompson 1888c8fff31SAndrew Thompson usb_backend = libusb20_be_alloc_default(); 1898c8fff31SAndrew Thompson if (usb_backend == NULL) 190390065b1SAlfred Perlstein return (LIBUSB_ERROR_NO_MEM); 1918c8fff31SAndrew Thompson 192390065b1SAlfred Perlstein /* figure out how many USB devices are present */ 1938c8fff31SAndrew Thompson pdev = NULL; 1948c8fff31SAndrew Thompson i = 0; 1958c8fff31SAndrew Thompson while ((pdev = libusb20_be_device_foreach(usb_backend, pdev))) 1968c8fff31SAndrew Thompson i++; 1978c8fff31SAndrew Thompson 198390065b1SAlfred Perlstein /* allocate device pointer list */ 1998c8fff31SAndrew Thompson *list = malloc((i + 1) * sizeof(void *)); 2008c8fff31SAndrew Thompson if (*list == NULL) { 2018c8fff31SAndrew Thompson libusb20_be_free(usb_backend); 2028c8fff31SAndrew Thompson return (LIBUSB_ERROR_NO_MEM); 2038c8fff31SAndrew Thompson } 204390065b1SAlfred Perlstein /* create libusb v1.0 compliant devices */ 2058c8fff31SAndrew Thompson i = 0; 2068c8fff31SAndrew Thompson while ((pdev = libusb20_be_device_foreach(usb_backend, NULL))) { 2078c8fff31SAndrew Thompson 2088c8fff31SAndrew Thompson dev = malloc(sizeof(*dev)); 2098c8fff31SAndrew Thompson if (dev == NULL) { 210c500e4ddSAndrew Thompson while (i != 0) { 211c500e4ddSAndrew Thompson libusb_unref_device((*list)[i - 1]); 212c500e4ddSAndrew Thompson i--; 213c500e4ddSAndrew Thompson } 2148c8fff31SAndrew Thompson free(*list); 215390065b1SAlfred Perlstein *list = NULL; 2168c8fff31SAndrew Thompson libusb20_be_free(usb_backend); 2178c8fff31SAndrew Thompson return (LIBUSB_ERROR_NO_MEM); 2188c8fff31SAndrew Thompson } 219ccef4ddfSAndrew Thompson 220ccef4ddfSAndrew Thompson /* get device into libUSB v1.0 list */ 221ccef4ddfSAndrew Thompson libusb20_be_dequeue_device(usb_backend, pdev); 222ccef4ddfSAndrew Thompson 2238c8fff31SAndrew Thompson memset(dev, 0, sizeof(*dev)); 2248c8fff31SAndrew Thompson 225390065b1SAlfred Perlstein /* init transfer queues */ 226390065b1SAlfred Perlstein TAILQ_INIT(&dev->tr_head); 227390065b1SAlfred Perlstein 228390065b1SAlfred Perlstein /* set context we belong to */ 2298c8fff31SAndrew Thompson dev->ctx = ctx; 2308c8fff31SAndrew Thompson 2318c8fff31SAndrew Thompson /* link together the two structures */ 2328c8fff31SAndrew Thompson dev->os_priv = pdev; 233390065b1SAlfred Perlstein pdev->privLuData = dev; 2348c8fff31SAndrew Thompson 2358c8fff31SAndrew Thompson (*list)[i] = libusb_ref_device(dev); 2368c8fff31SAndrew Thompson i++; 2378c8fff31SAndrew Thompson } 2388c8fff31SAndrew Thompson (*list)[i] = NULL; 2398c8fff31SAndrew Thompson 2408c8fff31SAndrew Thompson libusb20_be_free(usb_backend); 2418c8fff31SAndrew Thompson return (i); 2428c8fff31SAndrew Thompson } 2438c8fff31SAndrew Thompson 2448c8fff31SAndrew Thompson void 2458c8fff31SAndrew Thompson libusb_free_device_list(libusb_device **list, int unref_devices) 2468c8fff31SAndrew Thompson { 2478c8fff31SAndrew Thompson int i; 2488c8fff31SAndrew Thompson 2498c8fff31SAndrew Thompson if (list == NULL) 250390065b1SAlfred Perlstein return; /* be NULL safe */ 2518c8fff31SAndrew Thompson 2528c8fff31SAndrew Thompson if (unref_devices) { 2538c8fff31SAndrew Thompson for (i = 0; list[i] != NULL; i++) 2548c8fff31SAndrew Thompson libusb_unref_device(list[i]); 2558c8fff31SAndrew Thompson } 2568c8fff31SAndrew Thompson free(list); 2578c8fff31SAndrew Thompson } 2588c8fff31SAndrew Thompson 2598c8fff31SAndrew Thompson uint8_t 2608c8fff31SAndrew Thompson libusb_get_bus_number(libusb_device *dev) 2618c8fff31SAndrew Thompson { 2628c8fff31SAndrew Thompson if (dev == NULL) 263390065b1SAlfred Perlstein return (0); /* should not happen */ 264390065b1SAlfred Perlstein return (libusb20_dev_get_bus_number(dev->os_priv)); 2658c8fff31SAndrew Thompson } 2668c8fff31SAndrew Thompson 2678c8fff31SAndrew Thompson uint8_t 2688c8fff31SAndrew Thompson libusb_get_device_address(libusb_device *dev) 2698c8fff31SAndrew Thompson { 2708c8fff31SAndrew Thompson if (dev == NULL) 271390065b1SAlfred Perlstein return (0); /* should not happen */ 272390065b1SAlfred Perlstein return (libusb20_dev_get_address(dev->os_priv)); 2738c8fff31SAndrew Thompson } 2748c8fff31SAndrew Thompson 2758c8fff31SAndrew Thompson int 276390065b1SAlfred Perlstein libusb_get_max_packet_size(libusb_device *dev, uint8_t endpoint) 2778c8fff31SAndrew Thompson { 2788c8fff31SAndrew Thompson struct libusb_config_descriptor *pdconf; 2798c8fff31SAndrew Thompson struct libusb_interface *pinf; 2808c8fff31SAndrew Thompson struct libusb_interface_descriptor *pdinf; 2818c8fff31SAndrew Thompson struct libusb_endpoint_descriptor *pdend; 282390065b1SAlfred Perlstein int i; 283390065b1SAlfred Perlstein int j; 284390065b1SAlfred Perlstein int k; 285390065b1SAlfred Perlstein int ret; 2868c8fff31SAndrew Thompson 2878c8fff31SAndrew Thompson if (dev == NULL) 2888c8fff31SAndrew Thompson return (LIBUSB_ERROR_NO_DEVICE); 2898c8fff31SAndrew Thompson 290390065b1SAlfred Perlstein ret = libusb_get_active_config_descriptor(dev, &pdconf); 291390065b1SAlfred Perlstein if (ret < 0) 292390065b1SAlfred Perlstein return (ret); 2938c8fff31SAndrew Thompson 2948c8fff31SAndrew Thompson ret = LIBUSB_ERROR_NOT_FOUND; 2958c8fff31SAndrew Thompson for (i = 0; i < pdconf->bNumInterfaces; i++) { 2968c8fff31SAndrew Thompson pinf = &pdconf->interface[i]; 2978c8fff31SAndrew Thompson for (j = 0; j < pinf->num_altsetting; j++) { 2988c8fff31SAndrew Thompson pdinf = &pinf->altsetting[j]; 2998c8fff31SAndrew Thompson for (k = 0; k < pdinf->bNumEndpoints; k++) { 3008c8fff31SAndrew Thompson pdend = &pdinf->endpoint[k]; 3018c8fff31SAndrew Thompson if (pdend->bEndpointAddress == endpoint) { 3028c8fff31SAndrew Thompson ret = pdend->wMaxPacketSize; 3038c8fff31SAndrew Thompson goto out; 3048c8fff31SAndrew Thompson } 3058c8fff31SAndrew Thompson } 3068c8fff31SAndrew Thompson } 3078c8fff31SAndrew Thompson } 3088c8fff31SAndrew Thompson 3098c8fff31SAndrew Thompson out: 3108c8fff31SAndrew Thompson libusb_free_config_descriptor(pdconf); 3118c8fff31SAndrew Thompson return (ret); 3128c8fff31SAndrew Thompson } 3138c8fff31SAndrew Thompson 3148c8fff31SAndrew Thompson libusb_device * 3158c8fff31SAndrew Thompson libusb_ref_device(libusb_device *dev) 3168c8fff31SAndrew Thompson { 3178c8fff31SAndrew Thompson if (dev == NULL) 318390065b1SAlfred Perlstein return (NULL); /* be NULL safe */ 3198c8fff31SAndrew Thompson 320390065b1SAlfred Perlstein CTX_LOCK(dev->ctx); 3218c8fff31SAndrew Thompson dev->refcnt++; 322390065b1SAlfred Perlstein CTX_UNLOCK(dev->ctx); 3238c8fff31SAndrew Thompson 3248c8fff31SAndrew Thompson return (dev); 3258c8fff31SAndrew Thompson } 3268c8fff31SAndrew Thompson 3278c8fff31SAndrew Thompson void 3288c8fff31SAndrew Thompson libusb_unref_device(libusb_device *dev) 3298c8fff31SAndrew Thompson { 3308c8fff31SAndrew Thompson if (dev == NULL) 331390065b1SAlfred Perlstein return; /* be NULL safe */ 3328c8fff31SAndrew Thompson 333390065b1SAlfred Perlstein CTX_LOCK(dev->ctx); 3348c8fff31SAndrew Thompson dev->refcnt--; 335390065b1SAlfred Perlstein CTX_UNLOCK(dev->ctx); 3368c8fff31SAndrew Thompson 3378c8fff31SAndrew Thompson if (dev->refcnt == 0) { 3388c8fff31SAndrew Thompson libusb20_dev_free(dev->os_priv); 3398c8fff31SAndrew Thompson free(dev); 3408c8fff31SAndrew Thompson } 3418c8fff31SAndrew Thompson } 3428c8fff31SAndrew Thompson 3438c8fff31SAndrew Thompson int 3448c8fff31SAndrew Thompson libusb_open(libusb_device *dev, libusb_device_handle **devh) 3458c8fff31SAndrew Thompson { 3468c8fff31SAndrew Thompson libusb_context *ctx = dev->ctx; 3478c8fff31SAndrew Thompson struct libusb20_device *pdev = dev->os_priv; 348390065b1SAlfred Perlstein uint8_t dummy; 3498c8fff31SAndrew Thompson int err; 3508c8fff31SAndrew Thompson 3518c8fff31SAndrew Thompson if (devh == NULL) 3528c8fff31SAndrew Thompson return (LIBUSB_ERROR_INVALID_PARAM); 3538c8fff31SAndrew Thompson 354390065b1SAlfred Perlstein /* set default device handle value */ 355390065b1SAlfred Perlstein *devh = NULL; 356390065b1SAlfred Perlstein 357390065b1SAlfred Perlstein dev = libusb_ref_device(dev); 358390065b1SAlfred Perlstein if (dev == NULL) 359390065b1SAlfred Perlstein return (LIBUSB_ERROR_INVALID_PARAM); 3608c8fff31SAndrew Thompson 3618c8fff31SAndrew Thompson err = libusb20_dev_open(pdev, 16 * 4 /* number of endpoints */ ); 3628c8fff31SAndrew Thompson if (err) { 363390065b1SAlfred Perlstein libusb_unref_device(dev); 3648c8fff31SAndrew Thompson return (LIBUSB_ERROR_NO_MEM); 3658c8fff31SAndrew Thompson } 366390065b1SAlfred Perlstein libusb10_add_pollfd(ctx, &dev->dev_poll, pdev, libusb20_dev_get_fd(pdev), POLLIN | 3678c8fff31SAndrew Thompson POLLOUT | POLLRDNORM | POLLWRNORM); 3688c8fff31SAndrew Thompson 369390065b1SAlfred Perlstein /* make sure our event loop detects the new device */ 370390065b1SAlfred Perlstein dummy = 0; 3718c8fff31SAndrew Thompson err = write(ctx->ctrl_pipe[1], &dummy, sizeof(dummy)); 372698e791aSHans Petter Selasky if (err < (int)sizeof(dummy)) { 373390065b1SAlfred Perlstein /* ignore error, if any */ 374390065b1SAlfred Perlstein DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_open write failed!"); 3758c8fff31SAndrew Thompson } 376390065b1SAlfred Perlstein *devh = pdev; 3778c8fff31SAndrew Thompson 3788c8fff31SAndrew Thompson return (0); 3798c8fff31SAndrew Thompson } 3808c8fff31SAndrew Thompson 3818c8fff31SAndrew Thompson libusb_device_handle * 3828c8fff31SAndrew Thompson libusb_open_device_with_vid_pid(libusb_context *ctx, uint16_t vendor_id, 3838c8fff31SAndrew Thompson uint16_t product_id) 3848c8fff31SAndrew Thompson { 3858c8fff31SAndrew Thompson struct libusb_device **devs; 3868c8fff31SAndrew Thompson struct libusb20_device *pdev; 3878c8fff31SAndrew Thompson struct LIBUSB20_DEVICE_DESC_DECODED *pdesc; 388390065b1SAlfred Perlstein int i; 389390065b1SAlfred Perlstein int j; 3908c8fff31SAndrew Thompson 391390065b1SAlfred Perlstein ctx = GET_CONTEXT(ctx); 392390065b1SAlfred Perlstein if (ctx == NULL) 393390065b1SAlfred Perlstein return (NULL); /* be NULL safe */ 394390065b1SAlfred Perlstein 395c500e4ddSAndrew Thompson DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_open_device_width_vid_pid enter"); 3968c8fff31SAndrew Thompson 3978c8fff31SAndrew Thompson if ((i = libusb_get_device_list(ctx, &devs)) < 0) 3988c8fff31SAndrew Thompson return (NULL); 3998c8fff31SAndrew Thompson 4008c8fff31SAndrew Thompson for (j = 0; j < i; j++) { 401390065b1SAlfred Perlstein pdev = devs[j]->os_priv; 4028c8fff31SAndrew Thompson pdesc = libusb20_dev_get_device_desc(pdev); 403390065b1SAlfred Perlstein /* 404390065b1SAlfred Perlstein * NOTE: The USB library will automatically swap the 405390065b1SAlfred Perlstein * fields in the device descriptor to be of host 406390065b1SAlfred Perlstein * endian type! 407390065b1SAlfred Perlstein */ 4088c8fff31SAndrew Thompson if (pdesc->idVendor == vendor_id && 409c500e4ddSAndrew Thompson pdesc->idProduct == product_id) { 410390065b1SAlfred Perlstein if (libusb_open(devs[j], &pdev) < 0) 411390065b1SAlfred Perlstein pdev = NULL; 412c500e4ddSAndrew Thompson break; 413c500e4ddSAndrew Thompson } 4148c8fff31SAndrew Thompson } 415abdbb3feSSean Farley if (j == i) 416abdbb3feSSean Farley pdev = NULL; 4178c8fff31SAndrew Thompson 4188c8fff31SAndrew Thompson libusb_free_device_list(devs, 1); 419c500e4ddSAndrew Thompson DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_open_device_width_vid_pid leave"); 420390065b1SAlfred Perlstein return (pdev); 4218c8fff31SAndrew Thompson } 4228c8fff31SAndrew Thompson 4238c8fff31SAndrew Thompson void 424390065b1SAlfred Perlstein libusb_close(struct libusb20_device *pdev) 4258c8fff31SAndrew Thompson { 4268c8fff31SAndrew Thompson libusb_context *ctx; 427390065b1SAlfred Perlstein struct libusb_device *dev; 428390065b1SAlfred Perlstein uint8_t dummy; 4298c8fff31SAndrew Thompson int err; 4308c8fff31SAndrew Thompson 431390065b1SAlfred Perlstein if (pdev == NULL) 432390065b1SAlfred Perlstein return; /* be NULL safe */ 4338c8fff31SAndrew Thompson 434390065b1SAlfred Perlstein dev = libusb_get_device(pdev); 435390065b1SAlfred Perlstein ctx = dev->ctx; 4368c8fff31SAndrew Thompson 437390065b1SAlfred Perlstein libusb10_remove_pollfd(ctx, &dev->dev_poll); 4388c8fff31SAndrew Thompson 439390065b1SAlfred Perlstein libusb20_dev_close(pdev); 440ccef4ddfSAndrew Thompson 441ccef4ddfSAndrew Thompson /* unref will free the "pdev" when the refcount reaches zero */ 442390065b1SAlfred Perlstein libusb_unref_device(dev); 4438c8fff31SAndrew Thompson 444390065b1SAlfred Perlstein /* make sure our event loop detects the closed device */ 445390065b1SAlfred Perlstein dummy = 0; 4468c8fff31SAndrew Thompson err = write(ctx->ctrl_pipe[1], &dummy, sizeof(dummy)); 447698e791aSHans Petter Selasky if (err < (int)sizeof(dummy)) { 448390065b1SAlfred Perlstein /* ignore error, if any */ 449390065b1SAlfred Perlstein DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_close write failed!"); 450c500e4ddSAndrew Thompson } 4518c8fff31SAndrew Thompson } 4528c8fff31SAndrew Thompson 4538c8fff31SAndrew Thompson libusb_device * 454390065b1SAlfred Perlstein libusb_get_device(struct libusb20_device *pdev) 4558c8fff31SAndrew Thompson { 456390065b1SAlfred Perlstein if (pdev == NULL) 4578c8fff31SAndrew Thompson return (NULL); 458390065b1SAlfred Perlstein return ((libusb_device *)pdev->privLuData); 4598c8fff31SAndrew Thompson } 4608c8fff31SAndrew Thompson 4618c8fff31SAndrew Thompson int 462390065b1SAlfred Perlstein libusb_get_configuration(struct libusb20_device *pdev, int *config) 4638c8fff31SAndrew Thompson { 464390065b1SAlfred Perlstein struct libusb20_config *pconf; 4658c8fff31SAndrew Thompson 466390065b1SAlfred Perlstein if (pdev == NULL || config == NULL) 4678c8fff31SAndrew Thompson return (LIBUSB_ERROR_INVALID_PARAM); 4688c8fff31SAndrew Thompson 469390065b1SAlfred Perlstein pconf = libusb20_dev_alloc_config(pdev, libusb20_dev_get_config_index(pdev)); 470390065b1SAlfred Perlstein if (pconf == NULL) 471c500e4ddSAndrew Thompson return (LIBUSB_ERROR_NO_MEM); 4728c8fff31SAndrew Thompson 473390065b1SAlfred Perlstein *config = pconf->desc.bConfigurationValue; 4748c8fff31SAndrew Thompson 475390065b1SAlfred Perlstein free(pconf); 4768c8fff31SAndrew Thompson 4778c8fff31SAndrew Thompson return (0); 4788c8fff31SAndrew Thompson } 4798c8fff31SAndrew Thompson 4808c8fff31SAndrew Thompson int 481390065b1SAlfred Perlstein libusb_set_configuration(struct libusb20_device *pdev, int configuration) 4828c8fff31SAndrew Thompson { 483390065b1SAlfred Perlstein struct libusb20_config *pconf; 484390065b1SAlfred Perlstein struct libusb_device *dev; 485390065b1SAlfred Perlstein int err; 486390065b1SAlfred Perlstein uint8_t i; 4878c8fff31SAndrew Thompson 488390065b1SAlfred Perlstein dev = libusb_get_device(pdev); 4898c8fff31SAndrew Thompson if (dev == NULL) 490390065b1SAlfred Perlstein return (LIBUSB_ERROR_INVALID_PARAM); 491390065b1SAlfred Perlstein 492390065b1SAlfred Perlstein if (configuration < 1) { 493390065b1SAlfred Perlstein /* unconfigure */ 494390065b1SAlfred Perlstein i = 255; 495390065b1SAlfred Perlstein } else { 496390065b1SAlfred Perlstein for (i = 0; i != 255; i++) { 497390065b1SAlfred Perlstein uint8_t found; 498390065b1SAlfred Perlstein 499390065b1SAlfred Perlstein pconf = libusb20_dev_alloc_config(pdev, i); 500390065b1SAlfred Perlstein if (pconf == NULL) 501390065b1SAlfred Perlstein return (LIBUSB_ERROR_INVALID_PARAM); 502390065b1SAlfred Perlstein found = (pconf->desc.bConfigurationValue 503390065b1SAlfred Perlstein == configuration); 504390065b1SAlfred Perlstein free(pconf); 505390065b1SAlfred Perlstein 506390065b1SAlfred Perlstein if (found) 507390065b1SAlfred Perlstein goto set_config; 508390065b1SAlfred Perlstein } 509390065b1SAlfred Perlstein return (LIBUSB_ERROR_INVALID_PARAM); 510390065b1SAlfred Perlstein } 511390065b1SAlfred Perlstein 512390065b1SAlfred Perlstein set_config: 513390065b1SAlfred Perlstein 514390065b1SAlfred Perlstein libusb10_cancel_all_transfer(dev); 515390065b1SAlfred Perlstein 516390065b1SAlfred Perlstein libusb10_remove_pollfd(dev->ctx, &dev->dev_poll); 517390065b1SAlfred Perlstein 518390065b1SAlfred Perlstein err = libusb20_dev_set_config_index(pdev, i); 519390065b1SAlfred Perlstein 520390065b1SAlfred Perlstein libusb10_add_pollfd(dev->ctx, &dev->dev_poll, pdev, libusb20_dev_get_fd(pdev), POLLIN | 521390065b1SAlfred Perlstein POLLOUT | POLLRDNORM | POLLWRNORM); 522390065b1SAlfred Perlstein 523390065b1SAlfred Perlstein return (err ? LIBUSB_ERROR_INVALID_PARAM : 0); 524390065b1SAlfred Perlstein } 525390065b1SAlfred Perlstein 526390065b1SAlfred Perlstein int 527390065b1SAlfred Perlstein libusb_claim_interface(struct libusb20_device *pdev, int interface_number) 528390065b1SAlfred Perlstein { 529390065b1SAlfred Perlstein libusb_device *dev; 530390065b1SAlfred Perlstein int err = 0; 531390065b1SAlfred Perlstein 532390065b1SAlfred Perlstein dev = libusb_get_device(pdev); 533390065b1SAlfred Perlstein if (dev == NULL) 534390065b1SAlfred Perlstein return (LIBUSB_ERROR_INVALID_PARAM); 535390065b1SAlfred Perlstein 536390065b1SAlfred Perlstein if (interface_number < 0 || interface_number > 31) 537390065b1SAlfred Perlstein return (LIBUSB_ERROR_INVALID_PARAM); 538390065b1SAlfred Perlstein 539390065b1SAlfred Perlstein CTX_LOCK(dev->ctx); 540390065b1SAlfred Perlstein if (dev->claimed_interfaces & (1 << interface_number)) 541390065b1SAlfred Perlstein err = LIBUSB_ERROR_BUSY; 542390065b1SAlfred Perlstein 543390065b1SAlfred Perlstein if (!err) 544390065b1SAlfred Perlstein dev->claimed_interfaces |= (1 << interface_number); 545390065b1SAlfred Perlstein CTX_UNLOCK(dev->ctx); 546390065b1SAlfred Perlstein return (err); 547390065b1SAlfred Perlstein } 548390065b1SAlfred Perlstein 549390065b1SAlfred Perlstein int 550390065b1SAlfred Perlstein libusb_release_interface(struct libusb20_device *pdev, int interface_number) 551390065b1SAlfred Perlstein { 552390065b1SAlfred Perlstein libusb_device *dev; 553390065b1SAlfred Perlstein int err = 0; 554390065b1SAlfred Perlstein 555390065b1SAlfred Perlstein dev = libusb_get_device(pdev); 556390065b1SAlfred Perlstein if (dev == NULL) 557390065b1SAlfred Perlstein return (LIBUSB_ERROR_INVALID_PARAM); 558390065b1SAlfred Perlstein 559390065b1SAlfred Perlstein if (interface_number < 0 || interface_number > 31) 560390065b1SAlfred Perlstein return (LIBUSB_ERROR_INVALID_PARAM); 561390065b1SAlfred Perlstein 562390065b1SAlfred Perlstein CTX_LOCK(dev->ctx); 563390065b1SAlfred Perlstein if (!(dev->claimed_interfaces & (1 << interface_number))) 564390065b1SAlfred Perlstein err = LIBUSB_ERROR_NOT_FOUND; 565390065b1SAlfred Perlstein 566390065b1SAlfred Perlstein if (!err) 567390065b1SAlfred Perlstein dev->claimed_interfaces &= ~(1 << interface_number); 568390065b1SAlfred Perlstein CTX_UNLOCK(dev->ctx); 569390065b1SAlfred Perlstein return (err); 570390065b1SAlfred Perlstein } 571390065b1SAlfred Perlstein 572390065b1SAlfred Perlstein int 573390065b1SAlfred Perlstein libusb_set_interface_alt_setting(struct libusb20_device *pdev, 574390065b1SAlfred Perlstein int interface_number, int alternate_setting) 575390065b1SAlfred Perlstein { 576390065b1SAlfred Perlstein libusb_device *dev; 577390065b1SAlfred Perlstein int err = 0; 578390065b1SAlfred Perlstein 579390065b1SAlfred Perlstein dev = libusb_get_device(pdev); 580390065b1SAlfred Perlstein if (dev == NULL) 581390065b1SAlfred Perlstein return (LIBUSB_ERROR_INVALID_PARAM); 582390065b1SAlfred Perlstein 583390065b1SAlfred Perlstein if (interface_number < 0 || interface_number > 31) 584390065b1SAlfred Perlstein return (LIBUSB_ERROR_INVALID_PARAM); 585390065b1SAlfred Perlstein 586390065b1SAlfred Perlstein CTX_LOCK(dev->ctx); 587390065b1SAlfred Perlstein if (!(dev->claimed_interfaces & (1 << interface_number))) 588390065b1SAlfred Perlstein err = LIBUSB_ERROR_NOT_FOUND; 589390065b1SAlfred Perlstein CTX_UNLOCK(dev->ctx); 590390065b1SAlfred Perlstein 591390065b1SAlfred Perlstein if (err) 592390065b1SAlfred Perlstein return (err); 593390065b1SAlfred Perlstein 594390065b1SAlfred Perlstein libusb10_cancel_all_transfer(dev); 595390065b1SAlfred Perlstein 596390065b1SAlfred Perlstein libusb10_remove_pollfd(dev->ctx, &dev->dev_poll); 597390065b1SAlfred Perlstein 598390065b1SAlfred Perlstein err = libusb20_dev_set_alt_index(pdev, 599390065b1SAlfred Perlstein interface_number, alternate_setting); 600390065b1SAlfred Perlstein 601390065b1SAlfred Perlstein libusb10_add_pollfd(dev->ctx, &dev->dev_poll, 602390065b1SAlfred Perlstein pdev, libusb20_dev_get_fd(pdev), 603390065b1SAlfred Perlstein POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM); 604390065b1SAlfred Perlstein 605390065b1SAlfred Perlstein return (err ? LIBUSB_ERROR_OTHER : 0); 606390065b1SAlfred Perlstein } 607390065b1SAlfred Perlstein 608390065b1SAlfred Perlstein static struct libusb20_transfer * 609390065b1SAlfred Perlstein libusb10_get_transfer(struct libusb20_device *pdev, 610390065b1SAlfred Perlstein uint8_t endpoint, uint8_t index) 611390065b1SAlfred Perlstein { 612390065b1SAlfred Perlstein index &= 1; /* double buffering */ 613390065b1SAlfred Perlstein 614390065b1SAlfred Perlstein index |= (endpoint & LIBUSB20_ENDPOINT_ADDRESS_MASK) * 4; 615390065b1SAlfred Perlstein 616390065b1SAlfred Perlstein if (endpoint & LIBUSB20_ENDPOINT_DIR_MASK) { 617390065b1SAlfred Perlstein /* this is an IN endpoint */ 618390065b1SAlfred Perlstein index |= 2; 619390065b1SAlfred Perlstein } 620390065b1SAlfred Perlstein return (libusb20_tr_get_pointer(pdev, index)); 621390065b1SAlfred Perlstein } 622390065b1SAlfred Perlstein 623390065b1SAlfred Perlstein int 624390065b1SAlfred Perlstein libusb_clear_halt(struct libusb20_device *pdev, uint8_t endpoint) 625390065b1SAlfred Perlstein { 626390065b1SAlfred Perlstein struct libusb20_transfer *xfer; 627390065b1SAlfred Perlstein struct libusb_device *dev; 628390065b1SAlfred Perlstein int err; 629390065b1SAlfred Perlstein 630390065b1SAlfred Perlstein xfer = libusb10_get_transfer(pdev, endpoint, 0); 631390065b1SAlfred Perlstein if (xfer == NULL) 632390065b1SAlfred Perlstein return (LIBUSB_ERROR_INVALID_PARAM); 633390065b1SAlfred Perlstein 634390065b1SAlfred Perlstein dev = libusb_get_device(pdev); 635698e791aSHans Petter Selasky if (dev == NULL) 636698e791aSHans Petter Selasky return (LIBUSB_ERROR_INVALID_PARAM); 637390065b1SAlfred Perlstein 638390065b1SAlfred Perlstein CTX_LOCK(dev->ctx); 639390065b1SAlfred Perlstein err = libusb20_tr_open(xfer, 0, 0, endpoint); 640390065b1SAlfred Perlstein CTX_UNLOCK(dev->ctx); 641390065b1SAlfred Perlstein 642390065b1SAlfred Perlstein if (err != 0 && err != LIBUSB20_ERROR_BUSY) 643390065b1SAlfred Perlstein return (LIBUSB_ERROR_OTHER); 644390065b1SAlfred Perlstein 645390065b1SAlfred Perlstein libusb20_tr_clear_stall_sync(xfer); 646390065b1SAlfred Perlstein 647390065b1SAlfred Perlstein /* check if we opened the transfer */ 648390065b1SAlfred Perlstein if (err == 0) { 649390065b1SAlfred Perlstein CTX_LOCK(dev->ctx); 650390065b1SAlfred Perlstein libusb20_tr_close(xfer); 651390065b1SAlfred Perlstein CTX_UNLOCK(dev->ctx); 652390065b1SAlfred Perlstein } 653390065b1SAlfred Perlstein return (0); /* success */ 654390065b1SAlfred Perlstein } 655390065b1SAlfred Perlstein 656390065b1SAlfred Perlstein int 657390065b1SAlfred Perlstein libusb_reset_device(struct libusb20_device *pdev) 658390065b1SAlfred Perlstein { 659390065b1SAlfred Perlstein libusb_device *dev; 660390065b1SAlfred Perlstein int err; 661390065b1SAlfred Perlstein 662390065b1SAlfred Perlstein dev = libusb_get_device(pdev); 663390065b1SAlfred Perlstein if (dev == NULL) 664698e791aSHans Petter Selasky return (LIBUSB_ERROR_INVALID_PARAM); 6658c8fff31SAndrew Thompson 666390065b1SAlfred Perlstein libusb10_cancel_all_transfer(dev); 667390065b1SAlfred Perlstein 668390065b1SAlfred Perlstein libusb10_remove_pollfd(dev->ctx, &dev->dev_poll); 669390065b1SAlfred Perlstein 670390065b1SAlfred Perlstein err = libusb20_dev_reset(pdev); 671390065b1SAlfred Perlstein 672390065b1SAlfred Perlstein libusb10_add_pollfd(dev->ctx, &dev->dev_poll, 673390065b1SAlfred Perlstein pdev, libusb20_dev_get_fd(pdev), 674390065b1SAlfred Perlstein POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM); 675390065b1SAlfred Perlstein 676390065b1SAlfred Perlstein return (err ? LIBUSB_ERROR_OTHER : 0); 6778c8fff31SAndrew Thompson } 6788c8fff31SAndrew Thompson 6798c8fff31SAndrew Thompson int 680f1b5fa6eSHans Petter Selasky libusb_check_connected(struct libusb20_device *pdev) 681f1b5fa6eSHans Petter Selasky { 682f1b5fa6eSHans Petter Selasky libusb_device *dev; 683f1b5fa6eSHans Petter Selasky int err; 684f1b5fa6eSHans Petter Selasky 685f1b5fa6eSHans Petter Selasky dev = libusb_get_device(pdev); 686f1b5fa6eSHans Petter Selasky if (dev == NULL) 687f1b5fa6eSHans Petter Selasky return (LIBUSB_ERROR_INVALID_PARAM); 688f1b5fa6eSHans Petter Selasky 689f1b5fa6eSHans Petter Selasky err = libusb20_dev_check_connected(pdev); 690f1b5fa6eSHans Petter Selasky 691f1b5fa6eSHans Petter Selasky return (err ? LIBUSB_ERROR_NO_DEVICE : 0); 692f1b5fa6eSHans Petter Selasky } 693f1b5fa6eSHans Petter Selasky 694f1b5fa6eSHans Petter Selasky int 695390065b1SAlfred Perlstein libusb_kernel_driver_active(struct libusb20_device *pdev, int interface) 6968c8fff31SAndrew Thompson { 697390065b1SAlfred Perlstein if (pdev == NULL) 6988c8fff31SAndrew Thompson return (LIBUSB_ERROR_INVALID_PARAM); 6998c8fff31SAndrew Thompson 700390065b1SAlfred Perlstein return (libusb20_dev_kernel_driver_active( 701390065b1SAlfred Perlstein pdev, interface)); 7028c8fff31SAndrew Thompson } 7038c8fff31SAndrew Thompson 7048c8fff31SAndrew Thompson int 705698e791aSHans Petter Selasky libusb_get_driver_np(struct libusb20_device *pdev, int interface, 706698e791aSHans Petter Selasky char *name, int namelen) 707698e791aSHans Petter Selasky { 708698e791aSHans Petter Selasky return (libusb_get_driver(pdev, interface, name, namelen)); 709698e791aSHans Petter Selasky } 710698e791aSHans Petter Selasky 711698e791aSHans Petter Selasky int 712698e791aSHans Petter Selasky libusb_get_driver(struct libusb20_device *pdev, int interface, 713698e791aSHans Petter Selasky char *name, int namelen) 714698e791aSHans Petter Selasky { 715698e791aSHans Petter Selasky char *ptr; 716698e791aSHans Petter Selasky int err; 717698e791aSHans Petter Selasky 718698e791aSHans Petter Selasky if (pdev == NULL) 719698e791aSHans Petter Selasky return (LIBUSB_ERROR_INVALID_PARAM); 720698e791aSHans Petter Selasky if (namelen < 1) 721698e791aSHans Petter Selasky return (LIBUSB_ERROR_INVALID_PARAM); 722698e791aSHans Petter Selasky 723698e791aSHans Petter Selasky err = libusb20_dev_get_iface_desc( 724698e791aSHans Petter Selasky pdev, interface, name, namelen); 725698e791aSHans Petter Selasky 726698e791aSHans Petter Selasky if (err != 0) 727698e791aSHans Petter Selasky return (LIBUSB_ERROR_OTHER); 728698e791aSHans Petter Selasky 729698e791aSHans Petter Selasky /* we only want the driver name */ 730698e791aSHans Petter Selasky ptr = strstr(name, ":"); 731698e791aSHans Petter Selasky if (ptr != NULL) 732698e791aSHans Petter Selasky *ptr = 0; 733698e791aSHans Petter Selasky 734698e791aSHans Petter Selasky return (0); 735698e791aSHans Petter Selasky } 736698e791aSHans Petter Selasky 737698e791aSHans Petter Selasky int 738698e791aSHans Petter Selasky libusb_detach_kernel_driver_np(struct libusb20_device *pdev, int interface) 739698e791aSHans Petter Selasky { 740698e791aSHans Petter Selasky return (libusb_detach_kernel_driver(pdev, interface)); 741698e791aSHans Petter Selasky } 742698e791aSHans Petter Selasky 743698e791aSHans Petter Selasky int 744390065b1SAlfred Perlstein libusb_detach_kernel_driver(struct libusb20_device *pdev, int interface) 7458c8fff31SAndrew Thompson { 746390065b1SAlfred Perlstein int err; 7478c8fff31SAndrew Thompson 748390065b1SAlfred Perlstein if (pdev == NULL) 7498c8fff31SAndrew Thompson return (LIBUSB_ERROR_INVALID_PARAM); 7508c8fff31SAndrew Thompson 751390065b1SAlfred Perlstein err = libusb20_dev_detach_kernel_driver( 752390065b1SAlfred Perlstein pdev, interface); 7538c8fff31SAndrew Thompson 754698e791aSHans Petter Selasky return (err ? LIBUSB_ERROR_OTHER : 0); 7558c8fff31SAndrew Thompson } 7568c8fff31SAndrew Thompson 7578c8fff31SAndrew Thompson int 758390065b1SAlfred Perlstein libusb_attach_kernel_driver(struct libusb20_device *pdev, int interface) 7598c8fff31SAndrew Thompson { 760390065b1SAlfred Perlstein if (pdev == NULL) 7618c8fff31SAndrew Thompson return (LIBUSB_ERROR_INVALID_PARAM); 762390065b1SAlfred Perlstein /* stub - currently not supported by libusb20 */ 7638c8fff31SAndrew Thompson return (0); 7648c8fff31SAndrew Thompson } 7658c8fff31SAndrew Thompson 7668c8fff31SAndrew Thompson /* Asynchronous device I/O */ 7678c8fff31SAndrew Thompson 7688c8fff31SAndrew Thompson struct libusb_transfer * 7698c8fff31SAndrew Thompson libusb_alloc_transfer(int iso_packets) 7708c8fff31SAndrew Thompson { 771390065b1SAlfred Perlstein struct libusb_transfer *uxfer; 772390065b1SAlfred Perlstein struct libusb_super_transfer *sxfer; 7738c8fff31SAndrew Thompson int len; 7748c8fff31SAndrew Thompson 7758c8fff31SAndrew Thompson len = sizeof(struct libusb_transfer) + 776390065b1SAlfred Perlstein sizeof(struct libusb_super_transfer) + 7778c8fff31SAndrew Thompson (iso_packets * sizeof(libusb_iso_packet_descriptor)); 7788c8fff31SAndrew Thompson 779390065b1SAlfred Perlstein sxfer = malloc(len); 780390065b1SAlfred Perlstein if (sxfer == NULL) 7818c8fff31SAndrew Thompson return (NULL); 7828c8fff31SAndrew Thompson 783390065b1SAlfred Perlstein memset(sxfer, 0, len); 7848c8fff31SAndrew Thompson 785390065b1SAlfred Perlstein uxfer = (struct libusb_transfer *)( 786390065b1SAlfred Perlstein ((uint8_t *)sxfer) + sizeof(*sxfer)); 7878c8fff31SAndrew Thompson 788390065b1SAlfred Perlstein /* set default value */ 789390065b1SAlfred Perlstein uxfer->num_iso_packets = iso_packets; 790390065b1SAlfred Perlstein 791390065b1SAlfred Perlstein return (uxfer); 7928c8fff31SAndrew Thompson } 7938c8fff31SAndrew Thompson 7948c8fff31SAndrew Thompson void 795390065b1SAlfred Perlstein libusb_free_transfer(struct libusb_transfer *uxfer) 7968c8fff31SAndrew Thompson { 797390065b1SAlfred Perlstein struct libusb_super_transfer *sxfer; 7988c8fff31SAndrew Thompson 799390065b1SAlfred Perlstein if (uxfer == NULL) 800390065b1SAlfred Perlstein return; /* be NULL safe */ 8018c8fff31SAndrew Thompson 80231f7072cSHans Petter Selasky /* check if we should free the transfer buffer */ 80331f7072cSHans Petter Selasky if (uxfer->flags & LIBUSB_TRANSFER_FREE_BUFFER) 80431f7072cSHans Petter Selasky free(uxfer->buffer); 80531f7072cSHans Petter Selasky 806390065b1SAlfred Perlstein sxfer = (struct libusb_super_transfer *)( 807390065b1SAlfred Perlstein (uint8_t *)uxfer - sizeof(*sxfer)); 8088c8fff31SAndrew Thompson 809390065b1SAlfred Perlstein free(sxfer); 8108c8fff31SAndrew Thompson } 8118c8fff31SAndrew Thompson 812*1c497368SHans Petter Selasky static uint32_t 813390065b1SAlfred Perlstein libusb10_get_maxframe(struct libusb20_device *pdev, libusb_transfer *xfer) 8148c8fff31SAndrew Thompson { 815*1c497368SHans Petter Selasky uint32_t ret; 8168c8fff31SAndrew Thompson 8178c8fff31SAndrew Thompson switch (xfer->type) { 8188c8fff31SAndrew Thompson case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS: 819*1c497368SHans Petter Selasky ret = 60 | LIBUSB20_MAX_FRAME_PRE_SCALE; /* 60ms */ 8208c8fff31SAndrew Thompson break; 8218c8fff31SAndrew Thompson case LIBUSB_TRANSFER_TYPE_CONTROL: 8228c8fff31SAndrew Thompson ret = 2; 8238c8fff31SAndrew Thompson break; 8248c8fff31SAndrew Thompson default: 8258c8fff31SAndrew Thompson ret = 1; 8268c8fff31SAndrew Thompson break; 8278c8fff31SAndrew Thompson } 828390065b1SAlfred Perlstein return (ret); 8298c8fff31SAndrew Thompson } 8308c8fff31SAndrew Thompson 8318c8fff31SAndrew Thompson static int 832390065b1SAlfred Perlstein libusb10_get_buffsize(struct libusb20_device *pdev, libusb_transfer *xfer) 8338c8fff31SAndrew Thompson { 8348c8fff31SAndrew Thompson int ret; 8358c8fff31SAndrew Thompson int usb_speed; 8368c8fff31SAndrew Thompson 8378c8fff31SAndrew Thompson usb_speed = libusb20_dev_get_speed(pdev); 8388c8fff31SAndrew Thompson 8398c8fff31SAndrew Thompson switch (xfer->type) { 8408c8fff31SAndrew Thompson case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS: 841390065b1SAlfred Perlstein ret = 0; /* kernel will auto-select */ 8428c8fff31SAndrew Thompson break; 8438c8fff31SAndrew Thompson case LIBUSB_TRANSFER_TYPE_CONTROL: 844390065b1SAlfred Perlstein ret = 1024; 8458c8fff31SAndrew Thompson break; 8468c8fff31SAndrew Thompson default: 8478c8fff31SAndrew Thompson switch (usb_speed) { 8488c8fff31SAndrew Thompson case LIBUSB20_SPEED_LOW: 8498c8fff31SAndrew Thompson ret = 256; 8508c8fff31SAndrew Thompson break; 8518c8fff31SAndrew Thompson case LIBUSB20_SPEED_FULL: 8528c8fff31SAndrew Thompson ret = 4096; 8538c8fff31SAndrew Thompson break; 8548c8fff31SAndrew Thompson default: 8558c8fff31SAndrew Thompson ret = 16384; 8568c8fff31SAndrew Thompson break; 8578c8fff31SAndrew Thompson } 8588c8fff31SAndrew Thompson break; 8598c8fff31SAndrew Thompson } 860390065b1SAlfred Perlstein return (ret); 8618c8fff31SAndrew Thompson } 8628c8fff31SAndrew Thompson 863390065b1SAlfred Perlstein static int 864390065b1SAlfred Perlstein libusb10_convert_error(uint8_t status) 865390065b1SAlfred Perlstein { 866390065b1SAlfred Perlstein ; /* indent fix */ 867390065b1SAlfred Perlstein 868390065b1SAlfred Perlstein switch (status) { 869390065b1SAlfred Perlstein case LIBUSB20_TRANSFER_START: 870390065b1SAlfred Perlstein case LIBUSB20_TRANSFER_COMPLETED: 871390065b1SAlfred Perlstein return (LIBUSB_TRANSFER_COMPLETED); 872390065b1SAlfred Perlstein case LIBUSB20_TRANSFER_OVERFLOW: 873390065b1SAlfred Perlstein return (LIBUSB_TRANSFER_OVERFLOW); 874390065b1SAlfred Perlstein case LIBUSB20_TRANSFER_NO_DEVICE: 875390065b1SAlfred Perlstein return (LIBUSB_TRANSFER_NO_DEVICE); 876390065b1SAlfred Perlstein case LIBUSB20_TRANSFER_STALL: 877390065b1SAlfred Perlstein return (LIBUSB_TRANSFER_STALL); 878390065b1SAlfred Perlstein case LIBUSB20_TRANSFER_CANCELLED: 879390065b1SAlfred Perlstein return (LIBUSB_TRANSFER_CANCELLED); 880390065b1SAlfred Perlstein case LIBUSB20_TRANSFER_TIMED_OUT: 881390065b1SAlfred Perlstein return (LIBUSB_TRANSFER_TIMED_OUT); 882390065b1SAlfred Perlstein default: 883390065b1SAlfred Perlstein return (LIBUSB_TRANSFER_ERROR); 884390065b1SAlfred Perlstein } 885390065b1SAlfred Perlstein } 886390065b1SAlfred Perlstein 887390065b1SAlfred Perlstein /* This function must be called locked */ 888390065b1SAlfred Perlstein 889c500e4ddSAndrew Thompson static void 890390065b1SAlfred Perlstein libusb10_complete_transfer(struct libusb20_transfer *pxfer, 891390065b1SAlfred Perlstein struct libusb_super_transfer *sxfer, int status) 892c500e4ddSAndrew Thompson { 893390065b1SAlfred Perlstein struct libusb_transfer *uxfer; 894390065b1SAlfred Perlstein struct libusb_device *dev; 895c500e4ddSAndrew Thompson 896390065b1SAlfred Perlstein uxfer = (struct libusb_transfer *)( 897390065b1SAlfred Perlstein ((uint8_t *)sxfer) + sizeof(*sxfer)); 898390065b1SAlfred Perlstein 899390065b1SAlfred Perlstein if (pxfer != NULL) 900390065b1SAlfred Perlstein libusb20_tr_set_priv_sc1(pxfer, NULL); 901390065b1SAlfred Perlstein 9024594d907SAndrew Thompson /* set transfer status */ 903390065b1SAlfred Perlstein uxfer->status = status; 904390065b1SAlfred Perlstein 9054594d907SAndrew Thompson /* update super transfer state */ 9064594d907SAndrew Thompson sxfer->state = LIBUSB_SUPER_XFER_ST_NONE; 9074594d907SAndrew Thompson 908390065b1SAlfred Perlstein dev = libusb_get_device(uxfer->dev_handle); 909390065b1SAlfred Perlstein 910390065b1SAlfred Perlstein TAILQ_INSERT_TAIL(&dev->ctx->tr_done, sxfer, entry); 911390065b1SAlfred Perlstein } 912390065b1SAlfred Perlstein 913390065b1SAlfred Perlstein /* This function must be called locked */ 914390065b1SAlfred Perlstein 915390065b1SAlfred Perlstein static void 916390065b1SAlfred Perlstein libusb10_isoc_proxy(struct libusb20_transfer *pxfer) 917390065b1SAlfred Perlstein { 918390065b1SAlfred Perlstein struct libusb_super_transfer *sxfer; 919390065b1SAlfred Perlstein struct libusb_transfer *uxfer; 920390065b1SAlfred Perlstein uint32_t actlen; 921390065b1SAlfred Perlstein uint16_t iso_packets; 922390065b1SAlfred Perlstein uint16_t i; 923390065b1SAlfred Perlstein uint8_t status; 924390065b1SAlfred Perlstein uint8_t flags; 925390065b1SAlfred Perlstein 926390065b1SAlfred Perlstein status = libusb20_tr_get_status(pxfer); 927390065b1SAlfred Perlstein sxfer = libusb20_tr_get_priv_sc1(pxfer); 928390065b1SAlfred Perlstein actlen = libusb20_tr_get_actual_length(pxfer); 929390065b1SAlfred Perlstein iso_packets = libusb20_tr_get_max_frames(pxfer); 930390065b1SAlfred Perlstein 931390065b1SAlfred Perlstein if (sxfer == NULL) 932390065b1SAlfred Perlstein return; /* cancelled - nothing to do */ 933390065b1SAlfred Perlstein 934390065b1SAlfred Perlstein uxfer = (struct libusb_transfer *)( 935390065b1SAlfred Perlstein ((uint8_t *)sxfer) + sizeof(*sxfer)); 936390065b1SAlfred Perlstein 937390065b1SAlfred Perlstein if (iso_packets > uxfer->num_iso_packets) 938390065b1SAlfred Perlstein iso_packets = uxfer->num_iso_packets; 939390065b1SAlfred Perlstein 940390065b1SAlfred Perlstein if (iso_packets == 0) 941390065b1SAlfred Perlstein return; /* nothing to do */ 942390065b1SAlfred Perlstein 943390065b1SAlfred Perlstein /* make sure that the number of ISOCHRONOUS packets is valid */ 944390065b1SAlfred Perlstein uxfer->num_iso_packets = iso_packets; 945390065b1SAlfred Perlstein 946390065b1SAlfred Perlstein flags = uxfer->flags; 947c500e4ddSAndrew Thompson 948c500e4ddSAndrew Thompson switch (status) { 949c500e4ddSAndrew Thompson case LIBUSB20_TRANSFER_COMPLETED: 950c500e4ddSAndrew Thompson 951390065b1SAlfred Perlstein /* update actual length */ 952390065b1SAlfred Perlstein uxfer->actual_length = actlen; 953390065b1SAlfred Perlstein for (i = 0; i != iso_packets; i++) { 954390065b1SAlfred Perlstein uxfer->iso_packet_desc[i].actual_length = 955390065b1SAlfred Perlstein libusb20_tr_get_length(pxfer, i); 956390065b1SAlfred Perlstein } 957390065b1SAlfred Perlstein libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED); 958c500e4ddSAndrew Thompson break; 959390065b1SAlfred Perlstein 960c500e4ddSAndrew Thompson case LIBUSB20_TRANSFER_START: 961390065b1SAlfred Perlstein 962390065b1SAlfred Perlstein /* setup length(s) */ 963390065b1SAlfred Perlstein actlen = 0; 964390065b1SAlfred Perlstein for (i = 0; i != iso_packets; i++) { 965390065b1SAlfred Perlstein libusb20_tr_setup_isoc(pxfer, 966390065b1SAlfred Perlstein &uxfer->buffer[actlen], 967390065b1SAlfred Perlstein uxfer->iso_packet_desc[i].length, i); 968390065b1SAlfred Perlstein actlen += uxfer->iso_packet_desc[i].length; 969c500e4ddSAndrew Thompson } 970390065b1SAlfred Perlstein 971390065b1SAlfred Perlstein /* no remainder */ 972390065b1SAlfred Perlstein sxfer->rem_len = 0; 973390065b1SAlfred Perlstein 974390065b1SAlfred Perlstein libusb20_tr_set_total_frames(pxfer, iso_packets); 975390065b1SAlfred Perlstein libusb20_tr_submit(pxfer); 976390065b1SAlfred Perlstein 977390065b1SAlfred Perlstein /* fork another USB transfer, if any */ 978390065b1SAlfred Perlstein libusb10_submit_transfer_sub(libusb20_tr_get_priv_sc0(pxfer), uxfer->endpoint); 979c500e4ddSAndrew Thompson break; 980390065b1SAlfred Perlstein 981390065b1SAlfred Perlstein default: 982390065b1SAlfred Perlstein libusb10_complete_transfer(pxfer, sxfer, libusb10_convert_error(status)); 983c500e4ddSAndrew Thompson break; 984c500e4ddSAndrew Thompson } 985390065b1SAlfred Perlstein } 986390065b1SAlfred Perlstein 987390065b1SAlfred Perlstein /* This function must be called locked */ 988390065b1SAlfred Perlstein 989390065b1SAlfred Perlstein static void 990390065b1SAlfred Perlstein libusb10_bulk_intr_proxy(struct libusb20_transfer *pxfer) 991390065b1SAlfred Perlstein { 992390065b1SAlfred Perlstein struct libusb_super_transfer *sxfer; 993390065b1SAlfred Perlstein struct libusb_transfer *uxfer; 994390065b1SAlfred Perlstein uint32_t max_bulk; 995390065b1SAlfred Perlstein uint32_t actlen; 996390065b1SAlfred Perlstein uint8_t status; 997390065b1SAlfred Perlstein uint8_t flags; 998390065b1SAlfred Perlstein 999390065b1SAlfred Perlstein status = libusb20_tr_get_status(pxfer); 1000390065b1SAlfred Perlstein sxfer = libusb20_tr_get_priv_sc1(pxfer); 1001390065b1SAlfred Perlstein max_bulk = libusb20_tr_get_max_total_length(pxfer); 1002390065b1SAlfred Perlstein actlen = libusb20_tr_get_actual_length(pxfer); 1003390065b1SAlfred Perlstein 1004390065b1SAlfred Perlstein if (sxfer == NULL) 1005390065b1SAlfred Perlstein return; /* cancelled - nothing to do */ 1006390065b1SAlfred Perlstein 1007390065b1SAlfred Perlstein uxfer = (struct libusb_transfer *)( 1008390065b1SAlfred Perlstein ((uint8_t *)sxfer) + sizeof(*sxfer)); 1009390065b1SAlfred Perlstein 1010390065b1SAlfred Perlstein flags = uxfer->flags; 1011390065b1SAlfred Perlstein 1012390065b1SAlfred Perlstein switch (status) { 1013390065b1SAlfred Perlstein case LIBUSB20_TRANSFER_COMPLETED: 1014390065b1SAlfred Perlstein 1015390065b1SAlfred Perlstein uxfer->actual_length += actlen; 1016390065b1SAlfred Perlstein 1017390065b1SAlfred Perlstein /* check for short packet */ 1018390065b1SAlfred Perlstein if (sxfer->last_len != actlen) { 1019390065b1SAlfred Perlstein if (flags & LIBUSB_TRANSFER_SHORT_NOT_OK) { 1020390065b1SAlfred Perlstein libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_ERROR); 1021390065b1SAlfred Perlstein } else { 1022390065b1SAlfred Perlstein libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED); 1023390065b1SAlfred Perlstein } 1024390065b1SAlfred Perlstein break; 1025390065b1SAlfred Perlstein } 1026390065b1SAlfred Perlstein /* check for end of data */ 1027390065b1SAlfred Perlstein if (sxfer->rem_len == 0) { 1028390065b1SAlfred Perlstein libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED); 1029390065b1SAlfred Perlstein break; 1030390065b1SAlfred Perlstein } 1031390065b1SAlfred Perlstein /* FALLTHROUGH */ 1032390065b1SAlfred Perlstein 1033390065b1SAlfred Perlstein case LIBUSB20_TRANSFER_START: 1034390065b1SAlfred Perlstein if (max_bulk > sxfer->rem_len) { 1035390065b1SAlfred Perlstein max_bulk = sxfer->rem_len; 1036390065b1SAlfred Perlstein } 1037390065b1SAlfred Perlstein /* setup new BULK or INTERRUPT transaction */ 1038390065b1SAlfred Perlstein libusb20_tr_setup_bulk(pxfer, 1039390065b1SAlfred Perlstein sxfer->curr_data, max_bulk, uxfer->timeout); 1040390065b1SAlfred Perlstein 1041390065b1SAlfred Perlstein /* update counters */ 1042390065b1SAlfred Perlstein sxfer->last_len = max_bulk; 1043390065b1SAlfred Perlstein sxfer->curr_data += max_bulk; 1044390065b1SAlfred Perlstein sxfer->rem_len -= max_bulk; 1045390065b1SAlfred Perlstein 1046390065b1SAlfred Perlstein libusb20_tr_submit(pxfer); 1047390065b1SAlfred Perlstein 1048390065b1SAlfred Perlstein /* check if we can fork another USB transfer */ 1049390065b1SAlfred Perlstein if (sxfer->rem_len == 0) 1050390065b1SAlfred Perlstein libusb10_submit_transfer_sub(libusb20_tr_get_priv_sc0(pxfer), uxfer->endpoint); 1051390065b1SAlfred Perlstein break; 1052390065b1SAlfred Perlstein 1053390065b1SAlfred Perlstein default: 1054390065b1SAlfred Perlstein libusb10_complete_transfer(pxfer, sxfer, libusb10_convert_error(status)); 1055390065b1SAlfred Perlstein break; 1056390065b1SAlfred Perlstein } 1057390065b1SAlfred Perlstein } 1058390065b1SAlfred Perlstein 1059390065b1SAlfred Perlstein /* This function must be called locked */ 1060390065b1SAlfred Perlstein 1061390065b1SAlfred Perlstein static void 1062390065b1SAlfred Perlstein libusb10_ctrl_proxy(struct libusb20_transfer *pxfer) 1063390065b1SAlfred Perlstein { 1064390065b1SAlfred Perlstein struct libusb_super_transfer *sxfer; 1065390065b1SAlfred Perlstein struct libusb_transfer *uxfer; 1066390065b1SAlfred Perlstein uint32_t max_bulk; 1067390065b1SAlfred Perlstein uint32_t actlen; 1068390065b1SAlfred Perlstein uint8_t status; 1069390065b1SAlfred Perlstein uint8_t flags; 1070390065b1SAlfred Perlstein 1071390065b1SAlfred Perlstein status = libusb20_tr_get_status(pxfer); 1072390065b1SAlfred Perlstein sxfer = libusb20_tr_get_priv_sc1(pxfer); 1073390065b1SAlfred Perlstein max_bulk = libusb20_tr_get_max_total_length(pxfer); 1074390065b1SAlfred Perlstein actlen = libusb20_tr_get_actual_length(pxfer); 1075390065b1SAlfred Perlstein 1076390065b1SAlfred Perlstein if (sxfer == NULL) 1077390065b1SAlfred Perlstein return; /* cancelled - nothing to do */ 1078390065b1SAlfred Perlstein 1079390065b1SAlfred Perlstein uxfer = (struct libusb_transfer *)( 1080390065b1SAlfred Perlstein ((uint8_t *)sxfer) + sizeof(*sxfer)); 1081390065b1SAlfred Perlstein 1082390065b1SAlfred Perlstein flags = uxfer->flags; 1083390065b1SAlfred Perlstein 1084390065b1SAlfred Perlstein switch (status) { 1085390065b1SAlfred Perlstein case LIBUSB20_TRANSFER_COMPLETED: 1086390065b1SAlfred Perlstein 1087390065b1SAlfred Perlstein uxfer->actual_length += actlen; 1088390065b1SAlfred Perlstein 1089390065b1SAlfred Perlstein /* subtract length of SETUP packet, if any */ 1090390065b1SAlfred Perlstein actlen -= libusb20_tr_get_length(pxfer, 0); 1091390065b1SAlfred Perlstein 1092390065b1SAlfred Perlstein /* check for short packet */ 1093390065b1SAlfred Perlstein if (sxfer->last_len != actlen) { 1094390065b1SAlfred Perlstein if (flags & LIBUSB_TRANSFER_SHORT_NOT_OK) { 1095390065b1SAlfred Perlstein libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_ERROR); 1096390065b1SAlfred Perlstein } else { 1097390065b1SAlfred Perlstein libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED); 1098390065b1SAlfred Perlstein } 1099390065b1SAlfred Perlstein break; 1100390065b1SAlfred Perlstein } 1101390065b1SAlfred Perlstein /* check for end of data */ 1102390065b1SAlfred Perlstein if (sxfer->rem_len == 0) { 1103390065b1SAlfred Perlstein libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED); 1104390065b1SAlfred Perlstein break; 1105390065b1SAlfred Perlstein } 1106390065b1SAlfred Perlstein /* FALLTHROUGH */ 1107390065b1SAlfred Perlstein 1108390065b1SAlfred Perlstein case LIBUSB20_TRANSFER_START: 1109390065b1SAlfred Perlstein if (max_bulk > sxfer->rem_len) { 1110390065b1SAlfred Perlstein max_bulk = sxfer->rem_len; 1111390065b1SAlfred Perlstein } 1112390065b1SAlfred Perlstein /* setup new CONTROL transaction */ 1113390065b1SAlfred Perlstein if (status == LIBUSB20_TRANSFER_COMPLETED) { 1114390065b1SAlfred Perlstein /* next fragment - don't send SETUP packet */ 1115390065b1SAlfred Perlstein libusb20_tr_set_length(pxfer, 0, 0); 1116390065b1SAlfred Perlstein } else { 1117390065b1SAlfred Perlstein /* first fragment - send SETUP packet */ 1118390065b1SAlfred Perlstein libusb20_tr_set_length(pxfer, 8, 0); 1119390065b1SAlfred Perlstein libusb20_tr_set_buffer(pxfer, uxfer->buffer, 0); 1120390065b1SAlfred Perlstein } 1121390065b1SAlfred Perlstein 1122390065b1SAlfred Perlstein if (max_bulk != 0) { 1123390065b1SAlfred Perlstein libusb20_tr_set_length(pxfer, max_bulk, 1); 1124390065b1SAlfred Perlstein libusb20_tr_set_buffer(pxfer, sxfer->curr_data, 1); 1125390065b1SAlfred Perlstein libusb20_tr_set_total_frames(pxfer, 2); 1126390065b1SAlfred Perlstein } else { 1127390065b1SAlfred Perlstein libusb20_tr_set_total_frames(pxfer, 1); 1128390065b1SAlfred Perlstein } 1129390065b1SAlfred Perlstein 1130390065b1SAlfred Perlstein /* update counters */ 1131390065b1SAlfred Perlstein sxfer->last_len = max_bulk; 1132390065b1SAlfred Perlstein sxfer->curr_data += max_bulk; 1133390065b1SAlfred Perlstein sxfer->rem_len -= max_bulk; 1134390065b1SAlfred Perlstein 1135390065b1SAlfred Perlstein libusb20_tr_submit(pxfer); 1136390065b1SAlfred Perlstein 1137390065b1SAlfred Perlstein /* check if we can fork another USB transfer */ 1138390065b1SAlfred Perlstein if (sxfer->rem_len == 0) 1139390065b1SAlfred Perlstein libusb10_submit_transfer_sub(libusb20_tr_get_priv_sc0(pxfer), uxfer->endpoint); 1140390065b1SAlfred Perlstein break; 1141390065b1SAlfred Perlstein 1142390065b1SAlfred Perlstein default: 1143390065b1SAlfred Perlstein libusb10_complete_transfer(pxfer, sxfer, libusb10_convert_error(status)); 1144390065b1SAlfred Perlstein break; 1145390065b1SAlfred Perlstein } 1146390065b1SAlfred Perlstein } 1147390065b1SAlfred Perlstein 1148390065b1SAlfred Perlstein /* The following function must be called locked */ 1149390065b1SAlfred Perlstein 1150390065b1SAlfred Perlstein static void 1151390065b1SAlfred Perlstein libusb10_submit_transfer_sub(struct libusb20_device *pdev, uint8_t endpoint) 1152390065b1SAlfred Perlstein { 1153390065b1SAlfred Perlstein struct libusb20_transfer *pxfer0; 1154390065b1SAlfred Perlstein struct libusb20_transfer *pxfer1; 1155390065b1SAlfred Perlstein struct libusb_super_transfer *sxfer; 1156390065b1SAlfred Perlstein struct libusb_transfer *uxfer; 1157390065b1SAlfred Perlstein struct libusb_device *dev; 1158390065b1SAlfred Perlstein int err; 1159390065b1SAlfred Perlstein int buffsize; 1160390065b1SAlfred Perlstein int maxframe; 1161390065b1SAlfred Perlstein int temp; 1162390065b1SAlfred Perlstein uint8_t dummy; 1163390065b1SAlfred Perlstein 1164390065b1SAlfred Perlstein dev = libusb_get_device(pdev); 1165390065b1SAlfred Perlstein 1166390065b1SAlfred Perlstein pxfer0 = libusb10_get_transfer(pdev, endpoint, 0); 1167390065b1SAlfred Perlstein pxfer1 = libusb10_get_transfer(pdev, endpoint, 1); 1168390065b1SAlfred Perlstein 1169390065b1SAlfred Perlstein if (pxfer0 == NULL || pxfer1 == NULL) 1170390065b1SAlfred Perlstein return; /* shouldn't happen */ 1171390065b1SAlfred Perlstein 1172390065b1SAlfred Perlstein temp = 0; 1173390065b1SAlfred Perlstein if (libusb20_tr_pending(pxfer0)) 1174390065b1SAlfred Perlstein temp |= 1; 1175390065b1SAlfred Perlstein if (libusb20_tr_pending(pxfer1)) 1176390065b1SAlfred Perlstein temp |= 2; 1177390065b1SAlfred Perlstein 1178390065b1SAlfred Perlstein switch (temp) { 1179390065b1SAlfred Perlstein case 3: 1180390065b1SAlfred Perlstein /* wait till one of the transfers complete */ 1181390065b1SAlfred Perlstein return; 1182390065b1SAlfred Perlstein case 2: 1183390065b1SAlfred Perlstein sxfer = libusb20_tr_get_priv_sc1(pxfer1); 11844594d907SAndrew Thompson if (sxfer == NULL) 11854594d907SAndrew Thompson return; /* cancelling */ 1186390065b1SAlfred Perlstein if (sxfer->rem_len) 1187390065b1SAlfred Perlstein return; /* cannot queue another one */ 1188390065b1SAlfred Perlstein /* swap transfers */ 1189390065b1SAlfred Perlstein pxfer1 = pxfer0; 1190390065b1SAlfred Perlstein break; 1191390065b1SAlfred Perlstein case 1: 1192390065b1SAlfred Perlstein sxfer = libusb20_tr_get_priv_sc1(pxfer0); 11934594d907SAndrew Thompson if (sxfer == NULL) 11944594d907SAndrew Thompson return; /* cancelling */ 1195390065b1SAlfred Perlstein if (sxfer->rem_len) 1196390065b1SAlfred Perlstein return; /* cannot queue another one */ 1197390065b1SAlfred Perlstein /* swap transfers */ 1198390065b1SAlfred Perlstein pxfer0 = pxfer1; 1199c500e4ddSAndrew Thompson break; 1200c500e4ddSAndrew Thompson default: 1201c500e4ddSAndrew Thompson break; 1202c500e4ddSAndrew Thompson } 1203c500e4ddSAndrew Thompson 1204390065b1SAlfred Perlstein /* find next transfer on same endpoint */ 1205390065b1SAlfred Perlstein TAILQ_FOREACH(sxfer, &dev->tr_head, entry) { 1206390065b1SAlfred Perlstein 1207390065b1SAlfred Perlstein uxfer = (struct libusb_transfer *)( 1208390065b1SAlfred Perlstein ((uint8_t *)sxfer) + sizeof(*sxfer)); 1209390065b1SAlfred Perlstein 1210390065b1SAlfred Perlstein if (uxfer->endpoint == endpoint) { 1211390065b1SAlfred Perlstein TAILQ_REMOVE(&dev->tr_head, sxfer, entry); 1212390065b1SAlfred Perlstein sxfer->entry.tqe_prev = NULL; 1213390065b1SAlfred Perlstein goto found; 1214c500e4ddSAndrew Thompson } 1215c500e4ddSAndrew Thompson } 1216390065b1SAlfred Perlstein return; /* success */ 1217390065b1SAlfred Perlstein 1218390065b1SAlfred Perlstein found: 1219390065b1SAlfred Perlstein 1220390065b1SAlfred Perlstein libusb20_tr_set_priv_sc0(pxfer0, pdev); 1221390065b1SAlfred Perlstein libusb20_tr_set_priv_sc1(pxfer0, sxfer); 1222390065b1SAlfred Perlstein 1223390065b1SAlfred Perlstein /* reset super transfer state */ 1224390065b1SAlfred Perlstein sxfer->rem_len = uxfer->length; 1225390065b1SAlfred Perlstein sxfer->curr_data = uxfer->buffer; 1226390065b1SAlfred Perlstein uxfer->actual_length = 0; 1227390065b1SAlfred Perlstein 1228390065b1SAlfred Perlstein switch (uxfer->type) { 1229390065b1SAlfred Perlstein case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS: 1230390065b1SAlfred Perlstein libusb20_tr_set_callback(pxfer0, libusb10_isoc_proxy); 1231390065b1SAlfred Perlstein break; 1232390065b1SAlfred Perlstein case LIBUSB_TRANSFER_TYPE_BULK: 1233390065b1SAlfred Perlstein case LIBUSB_TRANSFER_TYPE_INTERRUPT: 1234390065b1SAlfred Perlstein libusb20_tr_set_callback(pxfer0, libusb10_bulk_intr_proxy); 1235390065b1SAlfred Perlstein break; 1236390065b1SAlfred Perlstein case LIBUSB_TRANSFER_TYPE_CONTROL: 1237390065b1SAlfred Perlstein libusb20_tr_set_callback(pxfer0, libusb10_ctrl_proxy); 1238390065b1SAlfred Perlstein if (sxfer->rem_len < 8) 1239390065b1SAlfred Perlstein goto failure; 1240390065b1SAlfred Perlstein 1241390065b1SAlfred Perlstein /* remove SETUP packet from data */ 1242390065b1SAlfred Perlstein sxfer->rem_len -= 8; 1243390065b1SAlfred Perlstein sxfer->curr_data += 8; 1244390065b1SAlfred Perlstein break; 1245390065b1SAlfred Perlstein default: 1246390065b1SAlfred Perlstein goto failure; 1247390065b1SAlfred Perlstein } 1248390065b1SAlfred Perlstein 1249390065b1SAlfred Perlstein buffsize = libusb10_get_buffsize(pdev, uxfer); 1250390065b1SAlfred Perlstein maxframe = libusb10_get_maxframe(pdev, uxfer); 1251390065b1SAlfred Perlstein 1252390065b1SAlfred Perlstein /* make sure the transfer is opened */ 1253390065b1SAlfred Perlstein err = libusb20_tr_open(pxfer0, buffsize, maxframe, endpoint); 1254390065b1SAlfred Perlstein if (err && (err != LIBUSB20_ERROR_BUSY)) { 1255390065b1SAlfred Perlstein goto failure; 1256390065b1SAlfred Perlstein } 1257390065b1SAlfred Perlstein libusb20_tr_start(pxfer0); 1258390065b1SAlfred Perlstein return; 1259390065b1SAlfred Perlstein 1260390065b1SAlfred Perlstein failure: 1261390065b1SAlfred Perlstein libusb10_complete_transfer(pxfer0, sxfer, LIBUSB_TRANSFER_ERROR); 1262390065b1SAlfred Perlstein 1263390065b1SAlfred Perlstein /* make sure our event loop spins the done handler */ 1264390065b1SAlfred Perlstein dummy = 0; 1265390065b1SAlfred Perlstein write(dev->ctx->ctrl_pipe[1], &dummy, sizeof(dummy)); 1266390065b1SAlfred Perlstein } 1267390065b1SAlfred Perlstein 1268390065b1SAlfred Perlstein /* The following function must be called unlocked */ 1269c500e4ddSAndrew Thompson 12708c8fff31SAndrew Thompson int 1271390065b1SAlfred Perlstein libusb_submit_transfer(struct libusb_transfer *uxfer) 12728c8fff31SAndrew Thompson { 1273390065b1SAlfred Perlstein struct libusb20_transfer *pxfer0; 1274390065b1SAlfred Perlstein struct libusb20_transfer *pxfer1; 1275390065b1SAlfred Perlstein struct libusb_super_transfer *sxfer; 1276390065b1SAlfred Perlstein struct libusb_device *dev; 1277ccef4ddfSAndrew Thompson uint32_t endpoint; 1278390065b1SAlfred Perlstein int err; 12798c8fff31SAndrew Thompson 1280390065b1SAlfred Perlstein if (uxfer == NULL) 1281390065b1SAlfred Perlstein return (LIBUSB_ERROR_INVALID_PARAM); 12828c8fff31SAndrew Thompson 1283390065b1SAlfred Perlstein if (uxfer->dev_handle == NULL) 1284390065b1SAlfred Perlstein return (LIBUSB_ERROR_INVALID_PARAM); 12858c8fff31SAndrew Thompson 1286390065b1SAlfred Perlstein endpoint = uxfer->endpoint; 12878c8fff31SAndrew Thompson 1288390065b1SAlfred Perlstein if (endpoint > 255) 1289390065b1SAlfred Perlstein return (LIBUSB_ERROR_INVALID_PARAM); 12908c8fff31SAndrew Thompson 1291390065b1SAlfred Perlstein dev = libusb_get_device(uxfer->dev_handle); 12928c8fff31SAndrew Thompson 1293390065b1SAlfred Perlstein DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_submit_transfer enter"); 12948c8fff31SAndrew Thompson 1295390065b1SAlfred Perlstein sxfer = (struct libusb_super_transfer *)( 1296390065b1SAlfred Perlstein (uint8_t *)uxfer - sizeof(*sxfer)); 1297390065b1SAlfred Perlstein 1298390065b1SAlfred Perlstein CTX_LOCK(dev->ctx); 1299390065b1SAlfred Perlstein 1300390065b1SAlfred Perlstein pxfer0 = libusb10_get_transfer(uxfer->dev_handle, endpoint, 0); 1301390065b1SAlfred Perlstein pxfer1 = libusb10_get_transfer(uxfer->dev_handle, endpoint, 1); 1302390065b1SAlfred Perlstein 1303390065b1SAlfred Perlstein if (pxfer0 == NULL || pxfer1 == NULL) { 1304390065b1SAlfred Perlstein err = LIBUSB_ERROR_OTHER; 1305390065b1SAlfred Perlstein } else if ((sxfer->entry.tqe_prev != NULL) || 1306390065b1SAlfred Perlstein (libusb20_tr_get_priv_sc1(pxfer0) == sxfer) || 1307390065b1SAlfred Perlstein (libusb20_tr_get_priv_sc1(pxfer1) == sxfer)) { 1308390065b1SAlfred Perlstein err = LIBUSB_ERROR_BUSY; 1309390065b1SAlfred Perlstein } else { 13104594d907SAndrew Thompson 13114594d907SAndrew Thompson /* set pending state */ 13124594d907SAndrew Thompson sxfer->state = LIBUSB_SUPER_XFER_ST_PEND; 13134594d907SAndrew Thompson 13144594d907SAndrew Thompson /* insert transfer into transfer head list */ 1315390065b1SAlfred Perlstein TAILQ_INSERT_TAIL(&dev->tr_head, sxfer, entry); 1316390065b1SAlfred Perlstein 13174594d907SAndrew Thompson /* start work transfers */ 1318390065b1SAlfred Perlstein libusb10_submit_transfer_sub( 1319390065b1SAlfred Perlstein uxfer->dev_handle, endpoint); 1320390065b1SAlfred Perlstein 1321390065b1SAlfred Perlstein err = 0; /* success */ 13228c8fff31SAndrew Thompson } 13238c8fff31SAndrew Thompson 1324390065b1SAlfred Perlstein CTX_UNLOCK(dev->ctx); 1325390065b1SAlfred Perlstein 1326390065b1SAlfred Perlstein DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_submit_transfer leave %d", err); 1327390065b1SAlfred Perlstein 1328390065b1SAlfred Perlstein return (err); 13298c8fff31SAndrew Thompson } 13308c8fff31SAndrew Thompson 1331390065b1SAlfred Perlstein /* Asynchronous transfer cancel */ 13328c8fff31SAndrew Thompson 1333390065b1SAlfred Perlstein int 1334390065b1SAlfred Perlstein libusb_cancel_transfer(struct libusb_transfer *uxfer) 1335390065b1SAlfred Perlstein { 1336390065b1SAlfred Perlstein struct libusb20_transfer *pxfer0; 1337390065b1SAlfred Perlstein struct libusb20_transfer *pxfer1; 1338390065b1SAlfred Perlstein struct libusb_super_transfer *sxfer; 1339390065b1SAlfred Perlstein struct libusb_device *dev; 1340ccef4ddfSAndrew Thompson uint32_t endpoint; 13414594d907SAndrew Thompson int retval; 13428c8fff31SAndrew Thompson 1343390065b1SAlfred Perlstein if (uxfer == NULL) 1344390065b1SAlfred Perlstein return (LIBUSB_ERROR_INVALID_PARAM); 13458c8fff31SAndrew Thompson 13464594d907SAndrew Thompson /* check if not initialised */ 1347390065b1SAlfred Perlstein if (uxfer->dev_handle == NULL) 13484594d907SAndrew Thompson return (LIBUSB_ERROR_NOT_FOUND); 13498c8fff31SAndrew Thompson 1350390065b1SAlfred Perlstein endpoint = uxfer->endpoint; 13518c8fff31SAndrew Thompson 1352390065b1SAlfred Perlstein if (endpoint > 255) 1353390065b1SAlfred Perlstein return (LIBUSB_ERROR_INVALID_PARAM); 13548c8fff31SAndrew Thompson 1355390065b1SAlfred Perlstein dev = libusb_get_device(uxfer->dev_handle); 13568c8fff31SAndrew Thompson 1357390065b1SAlfred Perlstein DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_cancel_transfer enter"); 13588c8fff31SAndrew Thompson 1359390065b1SAlfred Perlstein sxfer = (struct libusb_super_transfer *)( 1360390065b1SAlfred Perlstein (uint8_t *)uxfer - sizeof(*sxfer)); 1361390065b1SAlfred Perlstein 13624594d907SAndrew Thompson retval = 0; 13634594d907SAndrew Thompson 1364390065b1SAlfred Perlstein CTX_LOCK(dev->ctx); 1365390065b1SAlfred Perlstein 1366390065b1SAlfred Perlstein pxfer0 = libusb10_get_transfer(uxfer->dev_handle, endpoint, 0); 1367390065b1SAlfred Perlstein pxfer1 = libusb10_get_transfer(uxfer->dev_handle, endpoint, 1); 1368390065b1SAlfred Perlstein 13694594d907SAndrew Thompson if (sxfer->state != LIBUSB_SUPER_XFER_ST_PEND) { 13704594d907SAndrew Thompson /* only update the transfer status */ 13714594d907SAndrew Thompson uxfer->status = LIBUSB_TRANSFER_CANCELLED; 13724594d907SAndrew Thompson retval = LIBUSB_ERROR_NOT_FOUND; 13734594d907SAndrew Thompson } else if (sxfer->entry.tqe_prev != NULL) { 1374390065b1SAlfred Perlstein /* we are lucky - transfer is on a queue */ 1375390065b1SAlfred Perlstein TAILQ_REMOVE(&dev->tr_head, sxfer, entry); 1376390065b1SAlfred Perlstein sxfer->entry.tqe_prev = NULL; 13774594d907SAndrew Thompson libusb10_complete_transfer(NULL, 13784594d907SAndrew Thompson sxfer, LIBUSB_TRANSFER_CANCELLED); 1379390065b1SAlfred Perlstein } else if (pxfer0 == NULL || pxfer1 == NULL) { 1380390065b1SAlfred Perlstein /* not started */ 13814594d907SAndrew Thompson retval = LIBUSB_ERROR_NOT_FOUND; 1382390065b1SAlfred Perlstein } else if (libusb20_tr_get_priv_sc1(pxfer0) == sxfer) { 13834594d907SAndrew Thompson libusb10_complete_transfer(pxfer0, 13844594d907SAndrew Thompson sxfer, LIBUSB_TRANSFER_CANCELLED); 1385390065b1SAlfred Perlstein libusb20_tr_stop(pxfer0); 1386390065b1SAlfred Perlstein /* make sure the queue doesn't stall */ 1387390065b1SAlfred Perlstein libusb10_submit_transfer_sub( 1388390065b1SAlfred Perlstein uxfer->dev_handle, endpoint); 1389390065b1SAlfred Perlstein } else if (libusb20_tr_get_priv_sc1(pxfer1) == sxfer) { 13904594d907SAndrew Thompson libusb10_complete_transfer(pxfer1, 13914594d907SAndrew Thompson sxfer, LIBUSB_TRANSFER_CANCELLED); 1392390065b1SAlfred Perlstein libusb20_tr_stop(pxfer1); 1393390065b1SAlfred Perlstein /* make sure the queue doesn't stall */ 1394390065b1SAlfred Perlstein libusb10_submit_transfer_sub( 1395390065b1SAlfred Perlstein uxfer->dev_handle, endpoint); 1396390065b1SAlfred Perlstein } else { 1397390065b1SAlfred Perlstein /* not started */ 13984594d907SAndrew Thompson retval = LIBUSB_ERROR_NOT_FOUND; 1399c500e4ddSAndrew Thompson } 14008c8fff31SAndrew Thompson 1401390065b1SAlfred Perlstein CTX_UNLOCK(dev->ctx); 14028c8fff31SAndrew Thompson 1403390065b1SAlfred Perlstein DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_cancel_transfer leave"); 14048c8fff31SAndrew Thompson 14054594d907SAndrew Thompson return (retval); 14068c8fff31SAndrew Thompson } 14078c8fff31SAndrew Thompson 1408390065b1SAlfred Perlstein UNEXPORTED void 1409390065b1SAlfred Perlstein libusb10_cancel_all_transfer(libusb_device *dev) 14108c8fff31SAndrew Thompson { 1411390065b1SAlfred Perlstein /* TODO */ 14128c8fff31SAndrew Thompson } 1413ccef4ddfSAndrew Thompson 1414ccef4ddfSAndrew Thompson uint16_t 1415ccef4ddfSAndrew Thompson libusb_cpu_to_le16(uint16_t x) 1416ccef4ddfSAndrew Thompson { 1417ccef4ddfSAndrew Thompson return (htole16(x)); 1418ccef4ddfSAndrew Thompson } 1419ccef4ddfSAndrew Thompson 1420ccef4ddfSAndrew Thompson uint16_t 1421ccef4ddfSAndrew Thompson libusb_le16_to_cpu(uint16_t x) 1422ccef4ddfSAndrew Thompson { 1423ccef4ddfSAndrew Thompson return (le16toh(x)); 1424ccef4ddfSAndrew Thompson } 1425ccef4ddfSAndrew Thompson 1426698e791aSHans Petter Selasky const char * 1427698e791aSHans Petter Selasky libusb_strerror(int code) 1428698e791aSHans Petter Selasky { 1429698e791aSHans Petter Selasky /* TODO */ 1430698e791aSHans Petter Selasky return ("Unknown error"); 1431698e791aSHans Petter Selasky } 1432