4 * Copyright 2020 Zebediah Figura
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.
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.
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
31 #define WIN32_NO_STATUS
36 #include "wine/debug.h"
37 #include "wine/list.h"
41 WINE_DEFAULT_DEBUG_CHANNEL(wineusb
);
47 libusb_device_handle
*handle
;
48 struct unix_device
*parent
;
49 unsigned int refcount
;
52 static libusb_hotplug_callback_handle hotplug_cb_handle
;
54 static volatile bool thread_shutdown
;
56 static struct usb_event
*usb_events
;
57 static size_t usb_event_count
, usb_events_capacity
;
59 static pthread_mutex_t device_mutex
= PTHREAD_MUTEX_INITIALIZER
;
61 static struct list device_list
= LIST_INIT(device_list
);
63 static bool array_reserve(void **elements
, size_t *capacity
, size_t count
, size_t size
)
65 unsigned int new_capacity
, max_capacity
;
68 if (count
<= *capacity
)
71 max_capacity
= ~(size_t)0 / size
;
72 if (count
> max_capacity
)
75 new_capacity
= max(4, *capacity
);
76 while (new_capacity
< count
&& new_capacity
<= max_capacity
/ 2)
78 if (new_capacity
< count
)
79 new_capacity
= max_capacity
;
81 if (!(new_elements
= realloc(*elements
, new_capacity
* size
)))
84 *elements
= new_elements
;
85 *capacity
= new_capacity
;
90 static void queue_event(const struct usb_event
*event
)
92 if (array_reserve((void **)&usb_events
, &usb_events_capacity
, usb_event_count
+ 1, sizeof(*usb_events
)))
93 usb_events
[usb_event_count
++] = *event
;
95 ERR("Failed to queue event.\n");
98 static bool get_event(struct usb_event
*event
)
100 if (!usb_event_count
) return false;
102 *event
= usb_events
[0];
103 if (--usb_event_count
)
104 memmove(usb_events
, usb_events
+ 1, usb_event_count
* sizeof(*usb_events
));
109 static void add_usb_device(libusb_device
*libusb_device
)
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
;
117 libusb_get_device_descriptor(libusb_device
, &device_desc
);
119 TRACE("Adding new device %p, vendor %04x, product %04x.\n", libusb_device
,
120 device_desc
.idVendor
, device_desc
.idProduct
);
122 if (!(unix_device
= calloc(1, sizeof(*unix_device
))))
125 if ((ret
= libusb_open(libusb_device
, &unix_device
->handle
)))
127 WARN("Failed to open device: %s\n", libusb_strerror(ret
));
131 unix_device
->refcount
= 1;
133 pthread_mutex_lock(&device_mutex
);
134 list_add_tail(&device_list
, &unix_device
->entry
);
135 pthread_mutex_unlock(&device_mutex
);
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;
151 if (!(ret
= libusb_get_active_config_descriptor(libusb_device
, &config_desc
)))
153 const struct libusb_interface
*interface
;
154 const struct libusb_interface_descriptor
*iface_desc
;
156 if (config_desc
->bNumInterfaces
== 1)
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];
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
;
169 queue_event(&usb_event
);
171 /* Create new devices for interfaces of composite devices.
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.
178 * FIXME: usbccgp does not create separate interfaces in some cases,
179 * e.g. when there is an interface association descriptor available.
181 if (config_desc
->bNumInterfaces
> 1)
185 for (i
= 0; i
< config_desc
->bNumInterfaces
; ++i
)
187 struct unix_device
*unix_iface
;
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];
195 if (!(unix_iface
= calloc(1, sizeof(*unix_iface
))))
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
);
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
);
215 libusb_free_config_descriptor(config_desc
);
219 queue_event(&usb_event
);
221 ERR("Failed to get configuration descriptor: %s\n", libusb_strerror(ret
));
225 static void remove_usb_device(libusb_device
*libusb_device
)
227 struct unix_device
*unix_device
;
228 struct usb_event usb_event
;
230 TRACE("Removing device %p.\n", libusb_device
);
232 LIST_FOR_EACH_ENTRY(unix_device
, &device_list
, struct unix_device
, entry
)
234 if (libusb_get_device(unix_device
->handle
) == libusb_device
)
236 usb_event
.type
= USB_EVENT_REMOVE_DEVICE
;
237 usb_event
.u
.removed_device
= unix_device
;
238 queue_event(&usb_event
);
243 static int LIBUSB_CALL
hotplug_cb(libusb_context
*context
, libusb_device
*device
,
244 libusb_hotplug_event event
, void *user_data
)
246 if (event
== LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED
)
247 add_usb_device(device
);
249 remove_usb_device(device
);
254 static NTSTATUS
usb_main_loop(void *args
)
256 const struct usb_main_loop_params
*params
= args
;
259 while (!thread_shutdown
)
261 if (get_event(params
->event
)) return STATUS_PENDING
;
263 if ((ret
= libusb_handle_events(NULL
)))
264 ERR("Error handling events: %s\n", libusb_strerror(ret
));
270 usb_event_count
= usb_events_capacity
= 0;
271 thread_shutdown
= false;
273 TRACE("USB main loop exiting.\n");
274 return STATUS_SUCCESS
;
277 static NTSTATUS
usb_init(void *args
)
281 if ((ret
= libusb_init(NULL
)))
283 ERR("Failed to initialize libusb: %s\n", libusb_strerror(ret
));
284 return STATUS_UNSUCCESSFUL
;
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
)))
292 ERR("Failed to register callback: %s\n", libusb_strerror(ret
));
294 return STATUS_UNSUCCESSFUL
;
297 return STATUS_SUCCESS
;
300 static NTSTATUS
usb_exit(void *args
)
302 libusb_hotplug_deregister_callback(NULL
, hotplug_cb_handle
);
303 thread_shutdown
= true;
304 libusb_interrupt_event_handler(NULL
);
306 return STATUS_SUCCESS
;
309 static NTSTATUS
usbd_status_from_libusb(enum libusb_transfer_status status
)
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
;
324 FIXME("Unhandled status %#x.\n", status
);
325 case LIBUSB_TRANSFER_ERROR
:
326 return USBD_STATUS_REQUEST_FAILED
;
333 void *transfer_buffer
;
336 static void LIBUSB_CALL
transfer_cb(struct libusb_transfer
*transfer
)
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
;
344 TRACE("Completing IRP %p, status %#x.\n", irp
, transfer
->status
);
347 urb
->UrbHeader
.Status
= usbd_status_from_libusb(transfer
->status
);
349 if (transfer
->status
== LIBUSB_TRANSFER_COMPLETED
)
351 switch (urb
->UrbHeader
.Function
)
353 case URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER
:
354 urb
->UrbBulkOrInterruptTransfer
.TransferBufferLength
= transfer
->actual_length
;
357 case URB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICE
:
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
);
365 case URB_FUNCTION_VENDOR_INTERFACE
:
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
);
375 ERR("Unexpected function %#x.\n", urb
->UrbHeader
.Function
);
379 event
.type
= USB_EVENT_TRANSFER_COMPLETE
;
380 event
.u
.completed_irp
= irp
;
386 unsigned char endpoint
;
390 static HANDLE
make_pipe_handle(unsigned char endpoint
, USBD_PIPE_TYPE type
)
398 u
.pipe
.endpoint
= endpoint
;
403 static struct pipe
get_pipe(HANDLE handle
)
415 static NTSTATUS
usb_submit_urb(void *args
)
417 const struct usb_submit_urb_params
*params
= args
;
418 IRP
*irp
= params
->irp
;
420 URB
*urb
= IoGetCurrentIrpStackLocation(irp
)->Parameters
.Others
.Argument1
;
421 libusb_device_handle
*handle
= params
->device
->handle
;
422 struct libusb_transfer
*transfer
;
425 TRACE("type %#x.\n", urb
->UrbHeader
.Function
);
427 switch (urb
->UrbHeader
.Function
)
429 case URB_FUNCTION_SYNC_RESET_PIPE_AND_CLEAR_STALL
:
431 struct _URB_PIPE_REQUEST
*req
= &urb
->UrbPipeRequest
;
432 struct pipe pipe
= get_pipe(req
->PipeHandle
);
434 if ((ret
= libusb_clear_halt(handle
, pipe
.endpoint
)) < 0)
435 ERR("Failed to clear halt: %s\n", libusb_strerror(ret
));
437 return STATUS_SUCCESS
;
440 case URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER
:
442 struct _URB_BULK_OR_INTERRUPT_TRANSFER
*req
= &urb
->UrbBulkOrInterruptTransfer
;
443 struct pipe pipe
= get_pipe(req
->PipeHandle
);
444 struct transfer_ctx
*transfer_ctx
;
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
;
451 if (!(transfer
= libusb_alloc_transfer(0)))
452 return STATUS_NO_MEMORY
;
453 irp
->Tail
.Overlay
.DriverContext
[0] = transfer
;
455 if (pipe
.type
== UsbdPipeTypeBulk
)
457 libusb_fill_bulk_transfer(transfer
, handle
, pipe
.endpoint
,
458 params
->transfer_buffer
, req
->TransferBufferLength
, transfer_cb
, transfer_ctx
, 0);
460 else if (pipe
.type
== UsbdPipeTypeInterrupt
)
462 libusb_fill_interrupt_transfer(transfer
, handle
, pipe
.endpoint
,
463 params
->transfer_buffer
, req
->TransferBufferLength
, transfer_cb
, transfer_ctx
, 0);
467 WARN("Invalid pipe type %#x.\n", pipe
.type
);
468 libusb_free_transfer(transfer
);
469 return USBD_STATUS_INVALID_PIPE_HANDLE
;
472 transfer
->flags
= LIBUSB_TRANSFER_FREE_TRANSFER
;
473 ret
= libusb_submit_transfer(transfer
);
475 ERR("Failed to submit bulk transfer: %s\n", libusb_strerror(ret
));
477 return STATUS_PENDING
;
480 case URB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICE
:
482 struct _URB_CONTROL_DESCRIPTOR_REQUEST
*req
= &urb
->UrbControlDescriptorRequest
;
483 struct transfer_ctx
*transfer_ctx
;
484 unsigned char *buffer
;
486 if (!(transfer_ctx
= calloc(1, sizeof(*transfer_ctx
))))
487 return STATUS_NO_MEMORY
;
488 transfer_ctx
->irp
= irp
;
489 transfer_ctx
->transfer_buffer
= params
->transfer_buffer
;
491 if (!(transfer
= libusb_alloc_transfer(0)))
492 return STATUS_NO_MEMORY
;
493 irp
->Tail
.Overlay
.DriverContext
[0] = transfer
;
495 if (!(buffer
= malloc(sizeof(struct libusb_control_setup
) + req
->TransferBufferLength
)))
497 libusb_free_transfer(transfer
);
498 return STATUS_NO_MEMORY
;
501 libusb_fill_control_setup(buffer
,
502 LIBUSB_ENDPOINT_IN
| LIBUSB_REQUEST_TYPE_STANDARD
| LIBUSB_RECIPIENT_DEVICE
,
503 LIBUSB_REQUEST_GET_DESCRIPTOR
, (req
->DescriptorType
<< 8) | req
->Index
,
504 req
->LanguageId
, req
->TransferBufferLength
);
505 libusb_fill_control_transfer(transfer
, handle
, buffer
, transfer_cb
, transfer_ctx
, 0);
506 transfer
->flags
= LIBUSB_TRANSFER_FREE_BUFFER
| LIBUSB_TRANSFER_FREE_TRANSFER
;
507 ret
= libusb_submit_transfer(transfer
);
509 ERR("Failed to submit GET_DESCRIPTOR transfer: %s\n", libusb_strerror(ret
));
511 return STATUS_PENDING
;
514 case URB_FUNCTION_SELECT_CONFIGURATION
:
516 struct _URB_SELECT_CONFIGURATION
*req
= &urb
->UrbSelectConfiguration
;
519 /* FIXME: In theory, we'd call libusb_set_configuration() here, but
520 * the CASIO FX-9750GII (which has only one configuration) goes into
521 * an error state if it receives a SET_CONFIGURATION request. Maybe
522 * we should skip setting that if and only if the configuration is
525 for (i
= 0; i
< req
->Interface
.NumberOfPipes
; ++i
)
527 USBD_PIPE_INFORMATION
*pipe
= &req
->Interface
.Pipes
[i
];
528 pipe
->PipeHandle
= make_pipe_handle(pipe
->EndpointAddress
, pipe
->PipeType
);
531 return STATUS_SUCCESS
;
534 case URB_FUNCTION_VENDOR_INTERFACE
:
536 struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST
*req
= &urb
->UrbControlVendorClassRequest
;
537 uint8_t req_type
= LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_INTERFACE
;
538 struct transfer_ctx
*transfer_ctx
;
539 unsigned char *buffer
;
541 if (!(transfer_ctx
= calloc(1, sizeof(*transfer_ctx
))))
542 return STATUS_NO_MEMORY
;
543 transfer_ctx
->irp
= irp
;
544 transfer_ctx
->transfer_buffer
= params
->transfer_buffer
;
546 if (req
->TransferFlags
& USBD_TRANSFER_DIRECTION_IN
)
547 req_type
|= LIBUSB_ENDPOINT_IN
;
548 if (req
->TransferFlags
& ~USBD_TRANSFER_DIRECTION_IN
)
549 FIXME("Unhandled flags %#x.\n", (int)req
->TransferFlags
);
551 if (!(transfer
= libusb_alloc_transfer(0)))
552 return STATUS_NO_MEMORY
;
553 irp
->Tail
.Overlay
.DriverContext
[0] = transfer
;
555 if (!(buffer
= malloc(sizeof(struct libusb_control_setup
) + req
->TransferBufferLength
)))
557 libusb_free_transfer(transfer
);
558 return STATUS_NO_MEMORY
;
561 libusb_fill_control_setup(buffer
, req_type
, req
->Request
,
562 req
->Value
, req
->Index
, req
->TransferBufferLength
);
563 if (!(req
->TransferFlags
& USBD_TRANSFER_DIRECTION_IN
))
564 memcpy(buffer
+ LIBUSB_CONTROL_SETUP_SIZE
, params
->transfer_buffer
, req
->TransferBufferLength
);
565 libusb_fill_control_transfer(transfer
, handle
, buffer
, transfer_cb
, transfer_ctx
, 0);
566 transfer
->flags
= LIBUSB_TRANSFER_FREE_BUFFER
| LIBUSB_TRANSFER_FREE_TRANSFER
;
567 ret
= libusb_submit_transfer(transfer
);
569 ERR("Failed to submit vendor-specific interface transfer: %s\n", libusb_strerror(ret
));
571 return STATUS_PENDING
;
575 FIXME("Unhandled function %#x.\n", urb
->UrbHeader
.Function
);
578 return STATUS_NOT_IMPLEMENTED
;
581 static NTSTATUS
usb_cancel_transfer(void *args
)
583 const struct usb_cancel_transfer_params
*params
= args
;
586 if ((ret
= libusb_cancel_transfer(params
->transfer
)) < 0)
587 ERR("Failed to cancel transfer: %s\n", libusb_strerror(ret
));
589 return STATUS_SUCCESS
;
592 static void decref_device(struct unix_device
*device
)
594 pthread_mutex_lock(&device_mutex
);
596 if (--device
->refcount
)
598 pthread_mutex_unlock(&device_mutex
);
602 list_remove(&device
->entry
);
604 pthread_mutex_unlock(&device_mutex
);
607 decref_device(device
->parent
);
609 libusb_close(device
->handle
);
613 static NTSTATUS
usb_destroy_device(void *args
)
615 const struct usb_destroy_device_params
*params
= args
;
616 struct unix_device
*device
= params
->device
;
618 decref_device(device
);
620 return STATUS_SUCCESS
;
623 const unixlib_entry_t __wine_unix_call_funcs
[] =
625 #define X(name) [unix_ ## name] = name
630 X(usb_cancel_transfer
),
631 X(usb_destroy_device
),