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)))
454 return STATUS_NO_MEMORY
;
456 irp
->Tail
.Overlay
.DriverContext
[0] = transfer
;
458 if (pipe
.type
== UsbdPipeTypeBulk
)
460 libusb_fill_bulk_transfer(transfer
, handle
, pipe
.endpoint
,
461 params
->transfer_buffer
, req
->TransferBufferLength
, transfer_cb
, transfer_ctx
, 0);
463 else if (pipe
.type
== UsbdPipeTypeInterrupt
)
465 libusb_fill_interrupt_transfer(transfer
, handle
, pipe
.endpoint
,
466 params
->transfer_buffer
, req
->TransferBufferLength
, transfer_cb
, transfer_ctx
, 0);
470 WARN("Invalid pipe type %#x.\n", pipe
.type
);
472 libusb_free_transfer(transfer
);
473 return USBD_STATUS_INVALID_PIPE_HANDLE
;
476 transfer
->flags
= LIBUSB_TRANSFER_FREE_TRANSFER
;
477 ret
= libusb_submit_transfer(transfer
);
479 ERR("Failed to submit bulk transfer: %s\n", libusb_strerror(ret
));
481 return STATUS_PENDING
;
484 case URB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICE
:
486 struct _URB_CONTROL_DESCRIPTOR_REQUEST
*req
= &urb
->UrbControlDescriptorRequest
;
487 struct transfer_ctx
*transfer_ctx
;
488 unsigned char *buffer
;
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
;
495 if (!(transfer
= libusb_alloc_transfer(0)))
498 return STATUS_NO_MEMORY
;
500 irp
->Tail
.Overlay
.DriverContext
[0] = transfer
;
502 if (!(buffer
= malloc(sizeof(struct libusb_control_setup
) + req
->TransferBufferLength
)))
505 libusb_free_transfer(transfer
);
506 return STATUS_NO_MEMORY
;
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
);
517 ERR("Failed to submit GET_DESCRIPTOR transfer: %s\n", libusb_strerror(ret
));
519 return STATUS_PENDING
;
522 case URB_FUNCTION_SELECT_CONFIGURATION
:
524 struct _URB_SELECT_CONFIGURATION
*req
= &urb
->UrbSelectConfiguration
;
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
533 for (i
= 0; i
< req
->Interface
.NumberOfPipes
; ++i
)
535 USBD_PIPE_INFORMATION
*pipe
= &req
->Interface
.Pipes
[i
];
536 pipe
->PipeHandle
= make_pipe_handle(pipe
->EndpointAddress
, pipe
->PipeType
);
539 return STATUS_SUCCESS
;
542 case URB_FUNCTION_VENDOR_INTERFACE
:
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
;
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
;
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
);
559 if (!(transfer
= libusb_alloc_transfer(0)))
562 return STATUS_NO_MEMORY
;
564 irp
->Tail
.Overlay
.DriverContext
[0] = transfer
;
566 if (!(buffer
= malloc(sizeof(struct libusb_control_setup
) + req
->TransferBufferLength
)))
569 libusb_free_transfer(transfer
);
570 return STATUS_NO_MEMORY
;
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
);
581 ERR("Failed to submit vendor-specific interface transfer: %s\n", libusb_strerror(ret
));
583 return STATUS_PENDING
;
587 FIXME("Unhandled function %#x.\n", urb
->UrbHeader
.Function
);
590 return STATUS_NOT_IMPLEMENTED
;
593 static NTSTATUS
usb_cancel_transfer(void *args
)
595 const struct usb_cancel_transfer_params
*params
= args
;
598 if ((ret
= libusb_cancel_transfer(params
->transfer
)) < 0)
599 ERR("Failed to cancel transfer: %s\n", libusb_strerror(ret
));
601 return STATUS_SUCCESS
;
604 static void decref_device(struct unix_device
*device
)
606 pthread_mutex_lock(&device_mutex
);
608 if (--device
->refcount
)
610 pthread_mutex_unlock(&device_mutex
);
614 list_remove(&device
->entry
);
616 pthread_mutex_unlock(&device_mutex
);
619 decref_device(device
->parent
);
621 libusb_close(device
->handle
);
625 static NTSTATUS
usb_destroy_device(void *args
)
627 const struct usb_destroy_device_params
*params
= args
;
628 struct unix_device
*device
= params
->device
;
630 decref_device(device
);
632 return STATUS_SUCCESS
;
635 const unixlib_entry_t __wine_unix_call_funcs
[] =
637 #define X(name) [unix_ ## name] = name
642 X(usb_cancel_transfer
),
643 X(usb_destroy_device
),