dlls/wineusb.sys/unixlib.c

   1 /*
   2  * libusb backend
   3  *
   4  * Copyright 2020 Zebediah Figura
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #if 0
  22 #pragma makedep unix
  23 #endif
  24
  25 #include <stdarg.h>
  26 #include <stdbool.h>
  27 #include <stdlib.h>
  28 #include <libusb.h>
  29 #include <pthread.h>
  30 #include "ntstatus.h"
  31 #define WIN32_NO_STATUS
  32 #include "windef.h"
  33 #include "winternl.h"
  34 #include "ddk/wdm.h"
  35 #include "ddk/usb.h"
  36 #include "wine/debug.h"
  37 #include "wine/list.h"
  38
  39 #include "unixlib.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(wineusb);
  42
  43 struct unix_device
  44 {
  45     struct list entry;
  46
  47     libusb_device_handle *handle;
  48     struct unix_device *parent;
  49     unsigned int refcount;
  50 };
  51
  52 static libusb_hotplug_callback_handle hotplug_cb_handle;
  53
  54 static volatile bool thread_shutdown;
  55
  56 static struct usb_event *usb_events;
  57 static size_t usb_event_count, usb_events_capacity;
  58
  59 static pthread_mutex_t device_mutex = PTHREAD_MUTEX_INITIALIZER;
  60
  61 static struct list device_list = LIST_INIT(device_list);
  62
  63 static bool array_reserve(void **elements, size_t *capacity, size_t count, size_t size)
  64 {
  65     unsigned int new_capacity, max_capacity;
  66     void *new_elements;
  67
  68     if (count <= *capacity)
  69         return true;
  70
  71     max_capacity = ~(size_t)0 / size;
  72     if (count > max_capacity)
  73         return false;
  74
  75     new_capacity = max(4, *capacity);
  76     while (new_capacity < count && new_capacity <= max_capacity / 2)
  77         new_capacity *= 2;
  78     if (new_capacity < count)
  79         new_capacity = max_capacity;
  80
  81     if (!(new_elements = realloc(*elements, new_capacity * size)))
  82         return false;
  83
  84     *elements = new_elements;
  85     *capacity = new_capacity;
  86
  87     return true;
  88 }
  89
  90 static void queue_event(const struct usb_event *event)
  91 {
  92     if (array_reserve((void **)&usb_events, &usb_events_capacity, usb_event_count + 1, sizeof(*usb_events)))
  93         usb_events[usb_event_count++] = *event;
  94     else
  95         ERR("Failed to queue event.\n");
  96 }
  97
  98 static bool get_event(struct usb_event *event)
  99 {
 100     if (!usb_event_count) return false;
 101
 102     *event = usb_events[0];
 103     if (--usb_event_count)
 104         memmove(usb_events, usb_events + 1, usb_event_count * sizeof(*usb_events));
 105
 106     return true;
 107 }
 108
 109 static void add_usb_device(libusb_device *libusb_device)
 110 {
 111     struct libusb_config_descriptor *config_desc;
 112     struct libusb_device_descriptor device_desc;
 113     struct unix_device *unix_device;
 114     struct usb_event usb_event;
 115     int ret;
 116
 117     libusb_get_device_descriptor(libusb_device, &device_desc);
 118
 119     TRACE("Adding new device %p, vendor %04x, product %04x.\n", libusb_device,
 120             device_desc.idVendor, device_desc.idProduct);
 121
 122     if (!(unix_device = calloc(1, sizeof(*unix_device))))
 123         return;
 124
 125     if ((ret = libusb_open(libusb_device, &unix_device->handle)))
 126     {
 127         WARN("Failed to open device: %s\n", libusb_strerror(ret));
 128         free(unix_device);
 129         return;
 130     }
 131     unix_device->refcount = 1;
 132
 133     pthread_mutex_lock(&device_mutex);
 134     list_add_tail(&device_list, &unix_device->entry);
 135     pthread_mutex_unlock(&device_mutex);
 136
 137     usb_event.type = USB_EVENT_ADD_DEVICE;
 138     usb_event.u.added_device.device = unix_device;
 139     usb_event.u.added_device.vendor = device_desc.idVendor;
 140     usb_event.u.added_device.product = device_desc.idProduct;
 141     usb_event.u.added_device.revision = device_desc.bcdDevice;
 142     usb_event.u.added_device.usbver = device_desc.bcdUSB;
 143     usb_event.u.added_device.class = device_desc.bDeviceClass;
 144     usb_event.u.added_device.subclass = device_desc.bDeviceSubClass;
 145     usb_event.u.added_device.protocol = device_desc.bDeviceProtocol;
 146     usb_event.u.added_device.busnum = libusb_get_bus_number(libusb_device);
 147     usb_event.u.added_device.portnum = libusb_get_port_number(libusb_device);
 148     usb_event.u.added_device.interface = false;
 149     usb_event.u.added_device.interface_index = -1;
 150
 151     if (!(ret = libusb_get_active_config_descriptor(libusb_device, &config_desc)))
 152     {
 153         const struct libusb_interface *interface;
 154         const struct libusb_interface_descriptor *iface_desc;
 155
 156         if (config_desc->bNumInterfaces == 1)
 157         {
 158             interface = &config_desc->interface[0];
 159             if (interface->num_altsetting != 1)
 160                 FIXME("Interface 0 has %u alternate settings; using the first one.\n",
 161                         interface->num_altsetting);
 162             iface_desc = &interface->altsetting[0];
 163
 164             usb_event.u.added_device.class = iface_desc->bInterfaceClass;
 165             usb_event.u.added_device.subclass = iface_desc->bInterfaceSubClass;
 166             usb_event.u.added_device.protocol = iface_desc->bInterfaceProtocol;
 167             usb_event.u.added_device.interface_index = iface_desc->bInterfaceNumber;
 168         }
 169         queue_event(&usb_event);
 170
 171         /* Create new devices for interfaces of composite devices.
 172          *
 173          * On Windows this is the job of usbccgp.sys, a separate driver that
 174          * layers on top of the base USB driver. While we could take this
 175          * approach as well, implementing usbccgp is a lot more work, whereas
 176          * interface support is effectively built into libusb.
 177          *
 178          * FIXME: usbccgp does not create separate interfaces in some cases,
 179          * e.g. when there is an interface association descriptor available.
 180          */
 181         if (config_desc->bNumInterfaces > 1)
 182         {
 183             uint8_t i;
 184
 185             for (i = 0; i < config_desc->bNumInterfaces; ++i)
 186             {
 187                 struct unix_device *unix_iface;
 188
 189                 interface = &config_desc->interface[i];
 190                 if (interface->num_altsetting != 1)
 191                     FIXME("Interface %u has %u alternate settings; using the first one.\n",
 192                             i, interface->num_altsetting);
 193                 iface_desc = &interface->altsetting[0];
 194
 195                 if (!(unix_iface = calloc(1, sizeof(*unix_iface))))
 196                     return;
 197
 198                 ++unix_device->refcount;
 199                 unix_iface->refcount = 1;
 200                 unix_iface->handle = unix_device->handle;
 201                 unix_iface->parent = unix_device;
 202                 pthread_mutex_lock(&device_mutex);
 203                 list_add_tail(&device_list, &unix_iface->entry);
 204                 pthread_mutex_unlock(&device_mutex);
 205
 206                 usb_event.u.added_device.device = unix_iface;
 207                 usb_event.u.added_device.class = iface_desc->bInterfaceClass;
 208                 usb_event.u.added_device.subclass = iface_desc->bInterfaceSubClass;
 209                 usb_event.u.added_device.protocol = iface_desc->bInterfaceProtocol;
 210                 usb_event.u.added_device.interface = true;
 211                 usb_event.u.added_device.interface_index = iface_desc->bInterfaceNumber;
 212                 queue_event(&usb_event);
 213             }
 214         }
 215         libusb_free_config_descriptor(config_desc);
 216     }
 217     else
 218     {
 219         queue_event(&usb_event);
 220
 221         ERR("Failed to get configuration descriptor: %s\n", libusb_strerror(ret));
 222     }
 223 }
 224
 225 static void remove_usb_device(libusb_device *libusb_device)
 226 {
 227     struct unix_device *unix_device;
 228     struct usb_event usb_event;
 229
 230     TRACE("Removing device %p.\n", libusb_device);
 231
 232     LIST_FOR_EACH_ENTRY(unix_device, &device_list, struct unix_device, entry)
 233     {
 234         if (libusb_get_device(unix_device->handle) == libusb_device)
 235         {
 236             usb_event.type = USB_EVENT_REMOVE_DEVICE;
 237             usb_event.u.removed_device = unix_device;
 238             queue_event(&usb_event);
 239         }
 240     }
 241 }
 242
 243 static int LIBUSB_CALL hotplug_cb(libusb_context *context, libusb_device *device,
 244         libusb_hotplug_event event, void *user_data)
 245 {
 246     if (event == LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED)
 247         add_usb_device(device);
 248     else
 249         remove_usb_device(device);
 250
 251     return 0;
 252 }
 253
 254 static NTSTATUS usb_main_loop(void *args)
 255 {
 256     const struct usb_main_loop_params *params = args;
 257     int ret;
 258
 259     while (!thread_shutdown)
 260     {
 261         if (get_event(params->event)) return STATUS_PENDING;
 262
 263         if ((ret = libusb_handle_events(NULL)))
 264             ERR("Error handling events: %s\n", libusb_strerror(ret));
 265     }
 266
 267     libusb_exit(NULL);
 268     free(usb_events);
 269     usb_events = NULL;
 270     usb_event_count = usb_events_capacity = 0;
 271     thread_shutdown = false;
 272
 273     TRACE("USB main loop exiting.\n");
 274     return STATUS_SUCCESS;
 275 }
 276
 277 static NTSTATUS usb_init(void *args)
 278 {
 279     int ret;
 280
 281     if ((ret = libusb_init(NULL)))
 282     {
 283         ERR("Failed to initialize libusb: %s\n", libusb_strerror(ret));
 284         return STATUS_UNSUCCESSFUL;
 285     }
 286
 287     if ((ret = libusb_hotplug_register_callback(NULL,
 288             LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED | LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT,
 289             LIBUSB_HOTPLUG_ENUMERATE, LIBUSB_HOTPLUG_MATCH_ANY, LIBUSB_HOTPLUG_MATCH_ANY,
 290             LIBUSB_HOTPLUG_MATCH_ANY, hotplug_cb, NULL, &hotplug_cb_handle)))
 291     {
 292         ERR("Failed to register callback: %s\n", libusb_strerror(ret));
 293         libusb_exit(NULL);
 294         return STATUS_UNSUCCESSFUL;
 295     }
 296
 297     return STATUS_SUCCESS;
 298 }
 299
 300 static NTSTATUS usb_exit(void *args)
 301 {
 302     libusb_hotplug_deregister_callback(NULL, hotplug_cb_handle);
 303     thread_shutdown = true;
 304     libusb_interrupt_event_handler(NULL);
 305
 306     return STATUS_SUCCESS;
 307 }
 308
 309 static NTSTATUS usbd_status_from_libusb(enum libusb_transfer_status status)
 310 {
 311     switch (status)
 312     {
 313         case LIBUSB_TRANSFER_CANCELLED:
 314             return USBD_STATUS_CANCELED;
 315         case LIBUSB_TRANSFER_COMPLETED:
 316             return USBD_STATUS_SUCCESS;
 317         case LIBUSB_TRANSFER_NO_DEVICE:
 318             return USBD_STATUS_DEVICE_GONE;
 319         case LIBUSB_TRANSFER_STALL:
 320             return USBD_STATUS_ENDPOINT_HALTED;
 321         case LIBUSB_TRANSFER_TIMED_OUT:
 322             return USBD_STATUS_TIMEOUT;
 323         default:
 324             FIXME("Unhandled status %#x.\n", status);
 325         case LIBUSB_TRANSFER_ERROR:
 326             return USBD_STATUS_REQUEST_FAILED;
 327     }
 328 }
 329
 330 struct transfer_ctx
 331 {
 332     IRP *irp;
 333     void *transfer_buffer;
 334 };
 335
 336 static void LIBUSB_CALL transfer_cb(struct libusb_transfer *transfer)
 337 {
 338     struct transfer_ctx *transfer_ctx = transfer->user_data;
 339     IRP *irp = transfer_ctx->irp;
 340     URB *urb = IoGetCurrentIrpStackLocation(irp)->Parameters.Others.Argument1;
 341     unsigned char *transfer_buffer = transfer_ctx->transfer_buffer;
 342     struct usb_event event;
 343
 344     TRACE("Completing IRP %p, status %#x.\n", irp, transfer->status);
 345
 346     free(transfer_ctx);
 347     urb->UrbHeader.Status = usbd_status_from_libusb(transfer->status);
 348
 349     if (transfer->status == LIBUSB_TRANSFER_COMPLETED)
 350     {
 351         switch (urb->UrbHeader.Function)
 352         {
 353             case URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER:
 354                 urb->UrbBulkOrInterruptTransfer.TransferBufferLength = transfer->actual_length;
 355                 break;
 356
 357             case URB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICE:
 358             {
 359                 struct _URB_CONTROL_DESCRIPTOR_REQUEST *req = &urb->UrbControlDescriptorRequest;
 360                 req->TransferBufferLength = transfer->actual_length;
 361                 memcpy(transfer_buffer, libusb_control_transfer_get_data(transfer), transfer->actual_length);
 362                 break;
 363             }
 364
 365             case URB_FUNCTION_VENDOR_INTERFACE:
 366             {
 367                 struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST *req = &urb->UrbControlVendorClassRequest;
 368                 req->TransferBufferLength = transfer->actual_length;
 369                 if (req->TransferFlags & USBD_TRANSFER_DIRECTION_IN)
 370                     memcpy(transfer_buffer, libusb_control_transfer_get_data(transfer), transfer->actual_length);
 371                 break;
 372             }
 373
 374             default:
 375                 ERR("Unexpected function %#x.\n", urb->UrbHeader.Function);
 376         }
 377     }
 378
 379     event.type = USB_EVENT_TRANSFER_COMPLETE;
 380     event.u.completed_irp = irp;
 381     queue_event(&event);
 382 }
 383
 384 struct pipe
 385 {
 386     unsigned char endpoint;
 387     unsigned char type;
 388 };
 389
 390 static HANDLE make_pipe_handle(unsigned char endpoint, USBD_PIPE_TYPE type)
 391 {
 392     union
 393     {
 394         struct pipe pipe;
 395         HANDLE handle;
 396     } u;
 397
 398     u.pipe.endpoint = endpoint;
 399     u.pipe.type = type;
 400     return u.handle;
 401 }
 402
 403 static struct pipe get_pipe(HANDLE handle)
 404 {
 405     union
 406     {
 407         struct pipe pipe;
 408         HANDLE handle;
 409     } u;
 410
 411     u.handle = handle;
 412     return u.pipe;
 413 }
 414
 415 static NTSTATUS usb_submit_urb(void *args)
 416 {
 417     const struct usb_submit_urb_params *params = args;
 418     IRP *irp = params->irp;
 419
 420     URB *urb = IoGetCurrentIrpStackLocation(irp)->Parameters.Others.Argument1;
 421     libusb_device_handle *handle = params->device->handle;
 422     struct libusb_transfer *transfer;
 423     int ret;
 424
 425     TRACE("type %#x.\n", urb->UrbHeader.Function);
 426
 427     switch (urb->UrbHeader.Function)
 428     {
 429         case URB_FUNCTION_SYNC_RESET_PIPE_AND_CLEAR_STALL:
 430         {
 431             struct _URB_PIPE_REQUEST *req = &urb->UrbPipeRequest;
 432             struct pipe pipe = get_pipe(req->PipeHandle);
 433
 434             if ((ret = libusb_clear_halt(handle, pipe.endpoint)) < 0)
 435                 ERR("Failed to clear halt: %s\n", libusb_strerror(ret));
 436
 437             return STATUS_SUCCESS;
 438         }
 439
 440         case URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER:
 441         {
 442             struct _URB_BULK_OR_INTERRUPT_TRANSFER *req = &urb->UrbBulkOrInterruptTransfer;
 443             struct pipe pipe = get_pipe(req->PipeHandle);
 444             struct transfer_ctx *transfer_ctx;
 445
 446             if (!(transfer_ctx = calloc(1, sizeof(*transfer_ctx))))
 447                 return STATUS_NO_MEMORY;
 448             transfer_ctx->irp = irp;
 449             transfer_ctx->transfer_buffer = params->transfer_buffer;
 450
 451             if (!(transfer = libusb_alloc_transfer(0)))
 452             {
 453                 free(transfer_ctx);
 454                 return STATUS_NO_MEMORY;
 455             }
 456             irp->Tail.Overlay.DriverContext[0] = transfer;
 457
 458             if (pipe.type == UsbdPipeTypeBulk)
 459             {
 460                 libusb_fill_bulk_transfer(transfer, handle, pipe.endpoint,
 461                         params->transfer_buffer, req->TransferBufferLength, transfer_cb, transfer_ctx, 0);
 462             }
 463             else if (pipe.type == UsbdPipeTypeInterrupt)
 464             {
 465                 libusb_fill_interrupt_transfer(transfer, handle, pipe.endpoint,
 466                         params->transfer_buffer, req->TransferBufferLength, transfer_cb, transfer_ctx, 0);
 467             }
 468             else
 469             {
 470                 WARN("Invalid pipe type %#x.\n", pipe.type);
 471                 free(transfer_ctx);
 472                 libusb_free_transfer(transfer);
 473                 return USBD_STATUS_INVALID_PIPE_HANDLE;
 474             }
 475
 476             transfer->flags = LIBUSB_TRANSFER_FREE_TRANSFER;
 477             ret = libusb_submit_transfer(transfer);
 478             if (ret < 0)
 479                 ERR("Failed to submit bulk transfer: %s\n", libusb_strerror(ret));
 480
 481             return STATUS_PENDING;
 482         }
 483
 484         case URB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICE:
 485         {
 486             struct _URB_CONTROL_DESCRIPTOR_REQUEST *req = &urb->UrbControlDescriptorRequest;
 487             struct transfer_ctx *transfer_ctx;
 488             unsigned char *buffer;
 489
 490             if (!(transfer_ctx = calloc(1, sizeof(*transfer_ctx))))
 491                 return STATUS_NO_MEMORY;
 492             transfer_ctx->irp = irp;
 493             transfer_ctx->transfer_buffer = params->transfer_buffer;
 494
 495             if (!(transfer = libusb_alloc_transfer(0)))
 496             {
 497                 free(transfer_ctx);
 498                 return STATUS_NO_MEMORY;
 499             }
 500             irp->Tail.Overlay.DriverContext[0] = transfer;
 501
 502             if (!(buffer = malloc(sizeof(struct libusb_control_setup) + req->TransferBufferLength)))
 503             {
 504                 free(transfer_ctx);
 505                 libusb_free_transfer(transfer);
 506                 return STATUS_NO_MEMORY;
 507             }
 508
 509             libusb_fill_control_setup(buffer,
 510                     LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_STANDARD | LIBUSB_RECIPIENT_DEVICE,
 511                     LIBUSB_REQUEST_GET_DESCRIPTOR, (req->DescriptorType << 8) | req->Index,
 512                     req->LanguageId, req->TransferBufferLength);
 513             libusb_fill_control_transfer(transfer, handle, buffer, transfer_cb, transfer_ctx, 0);
 514             transfer->flags = LIBUSB_TRANSFER_FREE_BUFFER | LIBUSB_TRANSFER_FREE_TRANSFER;
 515             ret = libusb_submit_transfer(transfer);
 516             if (ret < 0)
 517                 ERR("Failed to submit GET_DESCRIPTOR transfer: %s\n", libusb_strerror(ret));
 518
 519             return STATUS_PENDING;
 520         }
 521
 522         case URB_FUNCTION_SELECT_CONFIGURATION:
 523         {
 524             struct _URB_SELECT_CONFIGURATION *req = &urb->UrbSelectConfiguration;
 525             ULONG i;
 526
 527             /* FIXME: In theory, we'd call libusb_set_configuration() here, but
 528              * the CASIO FX-9750GII (which has only one configuration) goes into
 529              * an error state if it receives a SET_CONFIGURATION request. Maybe
 530              * we should skip setting that if and only if the configuration is
 531              * already active? */
 532
 533             for (i = 0; i < req->Interface.NumberOfPipes; ++i)
 534             {
 535                 USBD_PIPE_INFORMATION *pipe = &req->Interface.Pipes[i];
 536                 pipe->PipeHandle = make_pipe_handle(pipe->EndpointAddress, pipe->PipeType);
 537             }
 538
 539             return STATUS_SUCCESS;
 540         }
 541
 542         case URB_FUNCTION_VENDOR_INTERFACE:
 543         {
 544             struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST *req = &urb->UrbControlVendorClassRequest;
 545             uint8_t req_type = LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_INTERFACE;
 546             struct transfer_ctx *transfer_ctx;
 547             unsigned char *buffer;
 548
 549             if (!(transfer_ctx = calloc(1, sizeof(*transfer_ctx))))
 550                 return STATUS_NO_MEMORY;
 551             transfer_ctx->irp = irp;
 552             transfer_ctx->transfer_buffer = params->transfer_buffer;
 553
 554             if (req->TransferFlags & USBD_TRANSFER_DIRECTION_IN)
 555                 req_type |= LIBUSB_ENDPOINT_IN;
 556             if (req->TransferFlags & ~USBD_TRANSFER_DIRECTION_IN)
 557                 FIXME("Unhandled flags %#x.\n", (int)req->TransferFlags);
 558
 559             if (!(transfer = libusb_alloc_transfer(0)))
 560             {
 561                 free(transfer_ctx);
 562                 return STATUS_NO_MEMORY;
 563             }
 564             irp->Tail.Overlay.DriverContext[0] = transfer;
 565
 566             if (!(buffer = malloc(sizeof(struct libusb_control_setup) + req->TransferBufferLength)))
 567             {
 568                 free(transfer_ctx);
 569                 libusb_free_transfer(transfer);
 570                 return STATUS_NO_MEMORY;
 571             }
 572
 573             libusb_fill_control_setup(buffer, req_type, req->Request,
 574                     req->Value, req->Index, req->TransferBufferLength);
 575             if (!(req->TransferFlags & USBD_TRANSFER_DIRECTION_IN))
 576                 memcpy(buffer + LIBUSB_CONTROL_SETUP_SIZE, params->transfer_buffer, req->TransferBufferLength);
 577             libusb_fill_control_transfer(transfer, handle, buffer, transfer_cb, transfer_ctx, 0);
 578             transfer->flags = LIBUSB_TRANSFER_FREE_BUFFER | LIBUSB_TRANSFER_FREE_TRANSFER;
 579             ret = libusb_submit_transfer(transfer);
 580             if (ret < 0)
 581                 ERR("Failed to submit vendor-specific interface transfer: %s\n", libusb_strerror(ret));
 582
 583             return STATUS_PENDING;
 584         }
 585
 586         default:
 587             FIXME("Unhandled function %#x.\n", urb->UrbHeader.Function);
 588     }
 589
 590     return STATUS_NOT_IMPLEMENTED;
 591 }
 592
 593 static NTSTATUS usb_cancel_transfer(void *args)
 594 {
 595     const struct usb_cancel_transfer_params *params = args;
 596     int ret;
 597
 598     if ((ret = libusb_cancel_transfer(params->transfer)) < 0)
 599         ERR("Failed to cancel transfer: %s\n", libusb_strerror(ret));
 600
 601     return STATUS_SUCCESS;
 602 }
 603
 604 static void decref_device(struct unix_device *device)
 605 {
 606     pthread_mutex_lock(&device_mutex);
 607
 608     if (--device->refcount)
 609     {
 610         pthread_mutex_unlock(&device_mutex);
 611         return;
 612     }
 613
 614     list_remove(&device->entry);
 615
 616     pthread_mutex_unlock(&device_mutex);
 617
 618     if (device->parent)
 619         decref_device(device->parent);
 620     else
 621         libusb_close(device->handle);
 622     free(device);
 623 }
 624
 625 static NTSTATUS usb_destroy_device(void *args)
 626 {
 627     const struct usb_destroy_device_params *params = args;
 628     struct unix_device *device = params->device;
 629
 630     decref_device(device);
 631
 632     return STATUS_SUCCESS;
 633 }
 634
 635 const unixlib_entry_t __wine_unix_call_funcs[] =
 636 {
 637 #define X(name) [unix_ ## name] = name
 638     X(usb_main_loop),
 639     X(usb_init),
 640     X(usb_exit),
 641     X(usb_submit_urb),
 642     X(usb_cancel_transfer),
 643     X(usb_destroy_device),
 644 };