summaryrefslogtreecommitdiffstats
path: root/include/libusb-1.0/os/windows_usb.c
diff options
context:
space:
mode:
authorGravatar Martin Szulecki2013-09-26 10:41:13 +0200
committerGravatar Martin Szulecki2013-09-26 10:41:13 +0200
commit07391edbf2ca1feaf4357259fd9e477ec53e6d81 (patch)
tree09bc0ab7de21b994dcb039a3e652ccfe173c310d /include/libusb-1.0/os/windows_usb.c
parentafb8735176869db20219c35a341e89158651bffe (diff)
downloadlibirecovery-07391edbf2ca1feaf4357259fd9e477ec53e6d81.tar.gz
libirecovery-07391edbf2ca1feaf4357259fd9e477ec53e6d81.tar.bz2
Remove obsolete "in-tree" copy of libusb-1.0
Diffstat (limited to 'include/libusb-1.0/os/windows_usb.c')
-rw-r--r--include/libusb-1.0/os/windows_usb.c4185
1 files changed, 0 insertions, 4185 deletions
diff --git a/include/libusb-1.0/os/windows_usb.c b/include/libusb-1.0/os/windows_usb.c
deleted file mode 100644
index e37932a..0000000
--- a/include/libusb-1.0/os/windows_usb.c
+++ /dev/null
@@ -1,4185 +0,0 @@
1/*
2 * windows backend for libusb 1.0
3 * Copyright (c) 2009-2010 Pete Batard <pbatard@gmail.com>
4 * With contributions from Michael Plante, Orin Eman et al.
5 * Parts of this code adapted from libusb-win32-v1 by Stephan Meyer
6 * HID Reports IOCTLs inspired from HIDAPI by Alan Ott, Signal 11 Software
7 * Major code testing contribution by Xiaofan Chen
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 */
23
24// COMPILATION OPTIONS:
25// - Should libusb automatically claim (and release) the interfaces it requires?
26#define AUTO_CLAIM
27// - Forces instant overlapped completion on timeouts: can prevents extensive
28// wait in poll, after a timeout, but might affect subsequent API calls.
29// ***USE AT YOUR OWN RISKS***
30//#define FORCE_INSTANT_TIMEOUTS
31
32#include <config.h>
33#include <windows.h>
34#include <setupapi.h>
35#include <ctype.h>
36#include <errno.h>
37#include <fcntl.h>
38#include <process.h>
39#include <stdio.h>
40#include <inttypes.h>
41#include <objbase.h> // for string to GUID conv. requires libole32.a
42#include <winioctl.h>
43
44#include <libusbi.h>
45#include "poll_windows.h"
46#include "windows_usb.h"
47
48// The following prevents "banned API" errors when using the MS's WDK OACR/Prefast
49#if defined(_PREFAST_)
50#pragma warning(disable:28719)
51#endif
52
53// The 2 macros below are used in conjunction with safe loops.
54#define LOOP_CHECK(fcall) { r=fcall; if (r != LIBUSB_SUCCESS) continue; }
55#define LOOP_BREAK(err) { r=err; continue; }
56
57extern void usbi_fd_notification(struct libusb_context *ctx);
58
59// Helper prototypes
60static int windows_get_active_config_descriptor(struct libusb_device *dev, unsigned char *buffer, size_t len, int *host_endian);
61static int windows_clock_gettime(int clk_id, struct timespec *tp);
62unsigned __stdcall windows_clock_gettime_threaded(void* param);
63// WinUSB API prototypes
64static int winusb_init(struct libusb_context *ctx);
65static int winusb_exit(void);
66static int winusb_open(struct libusb_device_handle *dev_handle);
67static void winusb_close(struct libusb_device_handle *dev_handle);
68static int winusb_claim_interface(struct libusb_device_handle *dev_handle, int iface);
69static int winusb_release_interface(struct libusb_device_handle *dev_handle, int iface);
70static int winusb_submit_control_transfer(struct usbi_transfer *itransfer);
71static int winusb_set_interface_altsetting(struct libusb_device_handle *dev_handle, int iface, int altsetting);
72static int winusb_submit_bulk_transfer(struct usbi_transfer *itransfer);
73static int winusb_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint);
74static int winusb_abort_transfers(struct usbi_transfer *itransfer);
75static int winusb_abort_control(struct usbi_transfer *itransfer);
76static int winusb_reset_device(struct libusb_device_handle *dev_handle);
77static int winusb_copy_transfer_data(struct usbi_transfer *itransfer, uint32_t io_size);
78// HID API prototypes
79static int hid_init(struct libusb_context *ctx);
80static int hid_exit(void);
81static int hid_open(struct libusb_device_handle *dev_handle);
82static void hid_close(struct libusb_device_handle *dev_handle);
83static int hid_claim_interface(struct libusb_device_handle *dev_handle, int iface);
84static int hid_release_interface(struct libusb_device_handle *dev_handle, int iface);
85static int hid_set_interface_altsetting(struct libusb_device_handle *dev_handle, int iface, int altsetting);
86static int hid_submit_control_transfer(struct usbi_transfer *itransfer);
87static int hid_submit_bulk_transfer(struct usbi_transfer *itransfer);
88static int hid_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint);
89static int hid_abort_transfers(struct usbi_transfer *itransfer);
90static int hid_reset_device(struct libusb_device_handle *dev_handle);
91static int hid_copy_transfer_data(struct usbi_transfer *itransfer, uint32_t io_size);
92// Composite API prototypes
93static int composite_init(struct libusb_context *ctx);
94static int composite_exit(void);
95static int composite_open(struct libusb_device_handle *dev_handle);
96static void composite_close(struct libusb_device_handle *dev_handle);
97static int composite_claim_interface(struct libusb_device_handle *dev_handle, int iface);
98static int composite_set_interface_altsetting(struct libusb_device_handle *dev_handle, int iface, int altsetting);
99static int composite_release_interface(struct libusb_device_handle *dev_handle, int iface);
100static int composite_submit_control_transfer(struct usbi_transfer *itransfer);
101static int composite_submit_bulk_transfer(struct usbi_transfer *itransfer);
102static int composite_submit_iso_transfer(struct usbi_transfer *itransfer);
103static int composite_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint);
104static int composite_abort_transfers(struct usbi_transfer *itransfer);
105static int composite_abort_control(struct usbi_transfer *itransfer);
106static int composite_reset_device(struct libusb_device_handle *dev_handle);
107static int composite_copy_transfer_data(struct usbi_transfer *itransfer, uint32_t io_size);
108
109
110// Global variables
111struct windows_hcd_priv* hcd_root = NULL;
112uint64_t hires_frequency, hires_ticks_to_ps;
113const uint64_t epoch_time = UINT64_C(116444736000000000); // 1970.01.01 00:00:000 in MS Filetime
114enum windows_version windows_version = WINDOWS_UNSUPPORTED;
115// Concurrency
116static int concurrent_usage = -1;
117#if defined(AUTO_CLAIM)
118usbi_mutex_t autoclaim_lock;
119#endif
120// Timer thread
121// NB: index 0 is for monotonic and 1 is for the thread exit event
122HANDLE timer_thread = NULL;
123HANDLE timer_mutex = NULL;
124struct timespec timer_tp;
125volatile LONG request_count[2] = {0, 1}; // last one must be > 0
126HANDLE timer_request[2] = { NULL, NULL };
127HANDLE timer_response = NULL;
128// API globals
129bool api_winusb_available = false;
130#define CHECK_WINUSB_AVAILABLE do { if (!api_winusb_available) return LIBUSB_ERROR_ACCESS; } while (0)
131bool api_hid_available = false;
132#define CHECK_HID_AVAILABLE do { if (!api_hid_available) return LIBUSB_ERROR_ACCESS; } while (0)
133
134
135/*
136 * Converts a WCHAR string to UTF8 (allocate returned string)
137 * Returns NULL on error
138 */
139static char* wchar_to_utf8(LPCWSTR wstr)
140{
141 int size;
142 char* str;
143
144 // Find out the size we need to allocate for our converted string
145 size = wchar_to_utf8_ms(wstr, NULL, 0);
146 if (size <= 1) // An empty string would be size 1
147 return NULL;
148
149 if ((str = malloc(size)) == NULL)
150 return NULL;
151
152 if (wchar_to_utf8_ms(wstr, str, size) != size) {
153 safe_free(str);
154 return NULL;
155 }
156
157 return str;
158}
159
160static inline BOOLEAN guid_eq(const GUID *guid1, const GUID *guid2) {
161 if ((guid1 != NULL) && (guid2 != NULL)) {
162 return (memcmp(guid1, guid2, sizeof(GUID)) == 0);
163 }
164 return false;
165}
166
167#if 0
168static char* guid_to_string(const GUID guid)
169{
170 static char guid_string[MAX_GUID_STRING_LENGTH];
171
172 sprintf(guid_string, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
173 (unsigned int)guid.Data1, guid.Data2, guid.Data3,
174 guid.Data4[0], guid.Data4[1], guid.Data4[2], guid.Data4[3],
175 guid.Data4[4], guid.Data4[5], guid.Data4[6], guid.Data4[7]);
176 return guid_string;
177}
178#endif
179
180/*
181 * Converts a windows error to human readable string
182 * uses retval as errorcode, or, if 0, use GetLastError()
183 */
184static char *windows_error_str(uint32_t retval)
185{
186static char err_string[ERR_BUFFER_SIZE];
187
188 DWORD size;
189 size_t i;
190 uint32_t error_code, format_error;
191
192 error_code = retval?retval:GetLastError();
193
194 safe_sprintf(err_string, ERR_BUFFER_SIZE, "[%d] ", error_code);
195
196 size = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, error_code,
197 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &err_string[safe_strlen(err_string)],
198 ERR_BUFFER_SIZE - (DWORD)safe_strlen(err_string), NULL);
199 if (size == 0) {
200 format_error = GetLastError();
201 if (format_error)
202 safe_sprintf(err_string, ERR_BUFFER_SIZE,
203 "Windows error code %u (FormatMessage error code %u)", error_code, format_error);
204 else
205 safe_sprintf(err_string, ERR_BUFFER_SIZE, "Unknown error code %u", error_code);
206 } else {
207 // Remove CR/LF terminators
208 for (i=safe_strlen(err_string)-1; ((err_string[i]==0x0A) || (err_string[i]==0x0D)); i--) {
209 err_string[i] = 0;
210 }
211 }
212 return err_string;
213}
214
215/*
216 * Sanitize Microsoft's paths: convert to uppercase, add prefix and fix backslashes.
217 * Return an allocated sanitized string or NULL on error.
218 */
219static char* sanitize_path(const char* path)
220{
221 const char root_prefix[] = "\\\\.\\";
222 size_t j, size, root_size;
223 char* ret_path = NULL;
224 size_t add_root = 0;
225
226 if (path == NULL)
227 return NULL;
228
229 size = safe_strlen(path)+1;
230 root_size = sizeof(root_prefix)-1;
231
232 // Microsoft indiscriminatly uses '\\?\', '\\.\', '##?#" or "##.#" for root prefixes.
233 if (!((size > 3) && (((path[0] == '\\') && (path[1] == '\\') && (path[3] == '\\')) ||
234 ((path[0] == '#') && (path[1] == '#') && (path[3] == '#'))))) {
235 add_root = root_size;
236 size += add_root;
237 }
238
239 if ((ret_path = (char*)calloc(size, 1)) == NULL)
240 return NULL;
241
242 safe_strcpy(&ret_path[add_root], size-add_root, path);
243
244 // Ensure consistancy with root prefix
245 for (j=0; j<root_size; j++)
246 ret_path[j] = root_prefix[j];
247
248 // Same goes for '\' and '#' after the root prefix. Ensure '#' is used
249 for(j=root_size; j<size; j++) {
250 ret_path[j] = (char)toupper((int)ret_path[j]); // Fix case too
251 if (ret_path[j] == '\\')
252 ret_path[j] = '#';
253 }
254
255 return ret_path;
256}
257
258/*
259 * Cfgmgr32 API functions
260 */
261static int Cfgmgr32_init(void)
262{
263 DLL_LOAD(Cfgmgr32.dll, CM_Get_Parent, TRUE);
264 DLL_LOAD(Cfgmgr32.dll, CM_Get_Child, TRUE);
265 DLL_LOAD(Cfgmgr32.dll, CM_Get_Sibling, TRUE);
266 DLL_LOAD(Cfgmgr32.dll, CM_Get_Device_IDA, TRUE);
267 DLL_LOAD(Cfgmgr32.dll, CM_Get_Device_IDW, TRUE);
268
269 return LIBUSB_SUCCESS;
270}
271
272/*
273 * enumerate interfaces for a specific GUID
274 *
275 * Parameters:
276 * dev_info: a pointer to a dev_info list
277 * dev_info_data: a pointer to an SP_DEVINFO_DATA to be filled (or NULL if not needed)
278 * guid: the GUID for which to retrieve interface details
279 * index: zero based index of the interface in the device info list
280 *
281 * Note: it is the responsibility of the caller to free the DEVICE_INTERFACE_DETAIL_DATA
282 * structure returned and call this function repeatedly using the same guid (with an
283 * incremented index starting at zero) until all interfaces have been returned.
284 */
285SP_DEVICE_INTERFACE_DETAIL_DATA *get_interface_details(struct libusb_context *ctx,
286 HDEVINFO *dev_info, SP_DEVINFO_DATA *dev_info_data, GUID guid, unsigned index)
287{
288 SP_DEVICE_INTERFACE_DATA dev_interface_data;
289 SP_DEVICE_INTERFACE_DETAIL_DATA *dev_interface_details = NULL;
290 DWORD size;
291
292 if (index <= 0) {
293 *dev_info = SetupDiGetClassDevs(&guid, NULL, NULL, DIGCF_PRESENT|DIGCF_DEVICEINTERFACE);
294 }
295 if (*dev_info == INVALID_HANDLE_VALUE) {
296 return NULL;
297 }
298
299 if (dev_info_data != NULL) {
300 dev_info_data->cbSize = sizeof(SP_DEVINFO_DATA);
301 if (!SetupDiEnumDeviceInfo(*dev_info, index, dev_info_data)) {
302 if (GetLastError() != ERROR_NO_MORE_ITEMS) {
303 usbi_err(ctx, "Could not obtain device info data for index %u: %s",
304 index, windows_error_str(0));
305 }
306 SetupDiDestroyDeviceInfoList(*dev_info);
307 *dev_info = INVALID_HANDLE_VALUE;
308 return NULL;
309 }
310 }
311
312 dev_interface_data.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
313 if (!SetupDiEnumDeviceInterfaces(*dev_info, NULL, &guid, index, &dev_interface_data)) {
314 if (GetLastError() != ERROR_NO_MORE_ITEMS) {
315 usbi_err(ctx, "Could not obtain interface data for index %u: %s",
316 index, windows_error_str(0));
317 }
318 SetupDiDestroyDeviceInfoList(*dev_info);
319 *dev_info = INVALID_HANDLE_VALUE;
320 return NULL;
321 }
322
323 // Read interface data (dummy + actual) to access the device path
324 if (!SetupDiGetDeviceInterfaceDetail(*dev_info, &dev_interface_data, NULL, 0, &size, NULL)) {
325 // The dummy call should fail with ERROR_INSUFFICIENT_BUFFER
326 if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
327 usbi_err(ctx, "could not access interface data (dummy) for index %u: %s",
328 index, windows_error_str(0));
329 goto err_exit;
330 }
331 }
332 else {
333 usbi_err(ctx, "program assertion failed - http://msdn.microsoft.com/en-us/library/ms792901.aspx is wrong.");
334 goto err_exit;
335 }
336
337 if ((dev_interface_details = malloc(size)) == NULL) {
338 usbi_err(ctx, "could not allocate interface data for index %u.", index);
339 goto err_exit;
340 }
341
342 dev_interface_details->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
343 if (!SetupDiGetDeviceInterfaceDetail(*dev_info, &dev_interface_data,
344 dev_interface_details, size, &size, NULL)) {
345 usbi_err(ctx, "could not access interface data (actual) for index %u: %s",
346 index, windows_error_str(0));
347 }
348
349 return dev_interface_details;
350
351err_exit:
352 SetupDiDestroyDeviceInfoList(*dev_info);
353 *dev_info = INVALID_HANDLE_VALUE;
354 return NULL;
355}
356
357/*
358 * Populate the endpoints addresses of the device_priv interface helper structs
359 */
360static int windows_assign_endpoints(struct libusb_device *dev, int iface, int altsetting)
361{
362 int i, r;
363 struct windows_device_priv *priv = __device_priv(dev);
364 struct libusb_config_descriptor *conf_desc;
365 const struct libusb_interface_descriptor *if_desc;
366
367 r = libusb_get_config_descriptor(dev, 0, &conf_desc);
368 if (r != LIBUSB_SUCCESS) {
369 usbi_warn(NULL, "could not read config descriptor: error %d", r);
370 return r;
371 }
372
373 if_desc = &conf_desc->interface[iface].altsetting[altsetting];
374 safe_free(priv->usb_interface[iface].endpoint);
375
376 if (if_desc->bNumEndpoints == 0) {
377 usbi_dbg("no endpoints found for interface %d", iface);
378 return LIBUSB_SUCCESS;
379 }
380
381 priv->usb_interface[iface].endpoint = malloc(if_desc->bNumEndpoints);
382 if (priv->usb_interface[iface].endpoint == NULL) {
383 return LIBUSB_ERROR_NO_MEM;
384 }
385
386 priv->usb_interface[iface].nb_endpoints = if_desc->bNumEndpoints;
387 for (i=0; i<if_desc->bNumEndpoints; i++) {
388 priv->usb_interface[iface].endpoint[i] = if_desc->endpoint[i].bEndpointAddress;
389 usbi_dbg("(re)assigned endpoint %02X to interface %d", priv->usb_interface[iface].endpoint[i], iface);
390 }
391 libusb_free_config_descriptor(conf_desc);
392
393 return LIBUSB_SUCCESS;
394}
395
396// Lookup for a match in the list of API driver names
397bool is_api_driver(char* driver, uint8_t api)
398{
399 uint8_t i;
400 const char sep_str[2] = {LIST_SEPARATOR, 0};
401 char *tok, *tmp_str;
402 size_t len = safe_strlen(driver);
403
404 if (len == 0) return false;
405 tmp_str = calloc(len+1, 1);
406 if (tmp_str == NULL) return false;
407 memcpy(tmp_str, driver, len+1);
408 tok = strtok(tmp_str, sep_str);
409 while (tok != NULL) {
410 for (i=0; i<usb_api_backend[api].nb_driver_names; i++) {
411 if (safe_strcmp(tok, usb_api_backend[api].driver_name_list[i]) == 0) {
412 free(tmp_str);
413 return true;
414 }
415 }
416 tok = strtok(NULL, sep_str);
417 }
418 free (tmp_str);
419 return false;
420}
421
422/*
423 * auto-claiming and auto-release helper functions
424 */
425#if defined(AUTO_CLAIM)
426static int auto_claim(struct libusb_transfer *transfer, int *interface_number, int api_type)
427{
428 struct libusb_context *ctx = DEVICE_CTX(transfer->dev_handle->dev);
429 struct windows_device_handle_priv *handle_priv = __device_handle_priv(
430 transfer->dev_handle);
431 struct windows_device_priv *priv = __device_priv(transfer->dev_handle->dev);
432 int current_interface = *interface_number;
433 int r = LIBUSB_SUCCESS;
434
435 switch(api_type) {
436 case USB_API_WINUSB:
437 case USB_API_HID:
438 break;
439 default:
440 return LIBUSB_ERROR_INVALID_PARAM;
441 }
442
443 usbi_mutex_lock(&autoclaim_lock);
444 if (current_interface < 0) // No serviceable interface was found
445 {
446 for (current_interface=0; current_interface<USB_MAXINTERFACES; current_interface++) {
447 // Must claim an interface of the same API type
448 if ( (priv->usb_interface[current_interface].apib == &usb_api_backend[api_type])
449 && (libusb_claim_interface(transfer->dev_handle, current_interface) == LIBUSB_SUCCESS) ) {
450 usbi_dbg("auto-claimed interface %d for control request", current_interface);
451 if (handle_priv->autoclaim_count[current_interface] != 0) {
452 usbi_warn(ctx, "program assertion failed - autoclaim_count was nonzero");
453 }
454 handle_priv->autoclaim_count[current_interface]++;
455 break;
456 }
457 }
458 if (current_interface == USB_MAXINTERFACES) {
459 usbi_err(ctx, "could not auto-claim any interface");
460 r = LIBUSB_ERROR_NOT_FOUND;
461 }
462 } else {
463 // If we have a valid interface that was autoclaimed, we must increment
464 // its autoclaim count so that we can prevent an early release.
465 if (handle_priv->autoclaim_count[current_interface] != 0) {
466 handle_priv->autoclaim_count[current_interface]++;
467 }
468 }
469 usbi_mutex_unlock(&autoclaim_lock);
470
471 *interface_number = current_interface;
472 return r;
473
474}
475
476static void auto_release(struct usbi_transfer *itransfer)
477{
478 struct windows_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
479 struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
480 libusb_device_handle *dev_handle = transfer->dev_handle;
481 struct windows_device_handle_priv* handle_priv = __device_handle_priv(dev_handle);
482 int r;
483
484 usbi_mutex_lock(&autoclaim_lock);
485 if (handle_priv->autoclaim_count[transfer_priv->interface_number] > 0) {
486 handle_priv->autoclaim_count[transfer_priv->interface_number]--;
487 if (handle_priv->autoclaim_count[transfer_priv->interface_number] == 0) {
488 r = libusb_release_interface(dev_handle, transfer_priv->interface_number);
489 if (r == LIBUSB_SUCCESS) {
490 usbi_dbg("auto-released interface %d", transfer_priv->interface_number);
491 } else {
492 usbi_dbg("failed to auto-release interface %d (%s)",
493 transfer_priv->interface_number, libusb_strerror(r));
494 }
495 }
496 }
497 usbi_mutex_unlock(&autoclaim_lock);
498}
499#endif
500
501
502/*
503 * init: libusb backend init function
504 *
505 * This function enumerates the HCDs (Host Controller Drivers) and populates our private HCD list
506 * In our implementation, we equate Windows' "HCD" to LibUSB's "bus". Note that bus is zero indexed.
507 * HCDs are not expected to change after init (might not hold true for hot pluggable USB PCI card?)
508 */
509static int windows_init(struct libusb_context *ctx)
510{
511 HDEVINFO dev_info;
512 SP_DEVICE_INTERFACE_DETAIL_DATA *dev_interface_details = NULL;
513 GUID guid;
514 libusb_bus_t bus;
515 int i, r = LIBUSB_ERROR_OTHER;
516 OSVERSIONINFO os_version;
517 HANDLE semaphore;
518 struct windows_hcd_priv** _hcd_cur;
519 TCHAR sem_name[11+1+8]; // strlen(libusb_init)+'\0'+(32-bit hex PID)
520
521 sprintf(sem_name, "libusb_init%08X", (unsigned int)GetCurrentProcessId()&0xFFFFFFFF);
522 semaphore = CreateSemaphore(NULL, 1, 1, sem_name);
523 if (semaphore == NULL) {
524 usbi_err(ctx, "could not create semaphore: %s", windows_error_str(0));
525 return LIBUSB_ERROR_NO_MEM;
526 }
527
528 // A successful wait brings our semaphore count to 0 (unsignaled)
529 // => any concurent wait stalls until the semaphore's release
530 if (WaitForSingleObject(semaphore, INFINITE) != WAIT_OBJECT_0) {
531 usbi_err(ctx, "failure to access semaphore: %s", windows_error_str(0));
532 CloseHandle(semaphore);
533 return LIBUSB_ERROR_NO_MEM;
534 }
535
536 // NB: concurrent usage supposes that init calls are equally balanced with
537 // exit calls. If init is called more than exit, we will not exit properly
538 if ( ++concurrent_usage == 0 ) { // First init?
539 _hcd_cur = &hcd_root;
540
541 // Detect OS version
542 memset(&os_version, 0, sizeof(OSVERSIONINFO));
543 os_version.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
544 windows_version = WINDOWS_UNSUPPORTED;
545 if ((GetVersionEx(&os_version) != 0) && (os_version.dwPlatformId == VER_PLATFORM_WIN32_NT)) {
546 if ((os_version.dwMajorVersion == 5) && (os_version.dwMinorVersion == 1)) {
547 windows_version = WINDOWS_XP;
548 } else if ((os_version.dwMajorVersion == 5) && (os_version.dwMinorVersion == 2)) {
549 windows_version = WINDOWS_2003; // also includes XP 64
550 } else if (os_version.dwMajorVersion >= 6) {
551 windows_version = WINDOWS_VISTA_AND_LATER;
552 }
553 }
554 if (windows_version == WINDOWS_UNSUPPORTED) {
555 usbi_err(ctx, "This version of Windows is NOT supported");
556 r = LIBUSB_ERROR_NOT_SUPPORTED;
557 goto init_exit;
558 }
559
560#if defined(AUTO_CLAIM)
561 // We need a lock for proper auto-release
562 usbi_mutex_init(&autoclaim_lock, NULL);
563#endif
564
565 // Initialize pollable file descriptors
566 init_polling();
567
568 // Load missing CFGMGR32.DLL imports
569 if (Cfgmgr32_init() != LIBUSB_SUCCESS) {
570 usbi_err(ctx, "could not resolve Cfgmgr32.dll functions");
571 return LIBUSB_ERROR_NOT_FOUND;
572 }
573
574 // Initialize the low level APIs (we don't care about errors at this stage)
575 for (i=0; i<USB_API_MAX; i++) {
576 usb_api_backend[i].init(ctx);
577 }
578
579 // Because QueryPerformanceCounter might report different values when
580 // running on different cores, we create a separate thread for the timer
581 // calls, which we glue to the first core always to prevent timing discrepancies.
582 r = LIBUSB_ERROR_NO_MEM;
583 for (i = 0; i < 2; i++) {
584 timer_request[i] = CreateEvent(NULL, TRUE, FALSE, NULL);
585 if (timer_request[i] == NULL) {
586 usbi_err(ctx, "could not create timer request event %d - aborting", i);
587 goto init_exit;
588 }
589 }
590 timer_response = CreateSemaphore(NULL, 0, MAX_TIMER_SEMAPHORES, NULL);
591 if (timer_response == NULL) {
592 usbi_err(ctx, "could not create timer response semaphore - aborting");
593 goto init_exit;
594 }
595 timer_mutex = CreateMutex(NULL, FALSE, NULL);
596 if (timer_mutex == NULL) {
597 usbi_err(ctx, "could not create timer mutex - aborting");
598 goto init_exit;
599 }
600 timer_thread = (HANDLE)_beginthreadex(NULL, 0, windows_clock_gettime_threaded, NULL, 0, NULL);
601 if (timer_thread == NULL) {
602 usbi_err(ctx, "Unable to create timer thread - aborting");
603 goto init_exit;
604 }
605 SetThreadAffinityMask(timer_thread, 0);
606
607 guid = GUID_DEVINTERFACE_USB_HOST_CONTROLLER;
608
609 r = LIBUSB_SUCCESS;
610 for (bus = 0; ; bus++)
611 {
612 // safe loop: free up any (unprotected) dynamic resource
613 // NB: this is always executed before breaking the loop
614 safe_free(dev_interface_details);
615 safe_free(*_hcd_cur);
616
617 dev_interface_details = get_interface_details(ctx, &dev_info, NULL, guid, bus);
618 // safe loop: end of loop condition
619 if ((dev_interface_details == NULL) || (r != LIBUSB_SUCCESS))
620 break;
621
622 // Will need to change storage and size of libusb_bus_t if this ever occurs
623 if (bus == LIBUSB_BUS_MAX) {
624 usbi_warn(ctx, "program assertion failed - found more than %d buses, skipping the rest.", LIBUSB_BUS_MAX);
625 continue;
626 }
627
628 // Allocate and init a new priv structure to hold our data
629 if ((*_hcd_cur = malloc(sizeof(struct windows_hcd_priv))) == NULL) {
630 usbi_err(ctx, "could not allocate private structure for bus %u. aborting.", bus);
631 LOOP_BREAK(LIBUSB_ERROR_NO_MEM);
632 }
633 windows_hcd_priv_init(*_hcd_cur);
634 (*_hcd_cur)->path = sanitize_path(dev_interface_details->DevicePath);
635
636 _hcd_cur = &((*_hcd_cur)->next);
637 }
638 // TODO (2nd official release): thread for hotplug (see darwin source)
639 }
640
641 if (hcd_root == NULL)
642 r = LIBUSB_ERROR_NO_DEVICE;
643 else
644 r = LIBUSB_SUCCESS;
645
646init_exit: // Holds semaphore here.
647 if(!concurrent_usage && r != LIBUSB_SUCCESS) { // First init failed?
648 if (timer_thread) {
649 SetEvent(timer_request[1]); // actually the signal to quit the thread.
650 if (WAIT_OBJECT_0 != WaitForSingleObject(timer_thread, INFINITE)) {
651 usbi_warn(ctx, "could not wait for timer thread to quit");
652 TerminateThread(timer_thread, 1); // shouldn't happen, but we're destroying
653 // all objects it might have held anyway.
654 }
655 CloseHandle(timer_thread);
656 timer_thread = NULL;
657 }
658 for (i = 0; i < 2; i++) {
659 if (timer_request[i]) {
660 CloseHandle(timer_request[i]);
661 timer_request[i] = NULL;
662 }
663 }
664 if (timer_response) {
665 CloseHandle(timer_response);
666 timer_response = NULL;
667 }
668 if (timer_mutex) {
669 CloseHandle(timer_mutex);
670 timer_mutex = NULL;
671 }
672 }
673
674 if (r != LIBUSB_SUCCESS)
675 --concurrent_usage; // Not expected to call libusb_exit if we failed.
676
677 ReleaseSemaphore(semaphore, 1, NULL); // increase count back to 1
678 CloseHandle(semaphore);
679 return r;
680}
681
682/*
683 * Initialize device structure, including active config
684 */
685static int initialize_device(struct libusb_device *dev, libusb_bus_t busnum,
686 libusb_devaddr_t devaddr, char *path, int connection_index, uint8_t active_config,
687 struct libusb_device *parent_dev)
688{
689 struct windows_device_priv *priv = __device_priv(dev);
690
691 windows_device_priv_init(priv);
692
693 dev->bus_number = busnum;
694 dev->device_address = devaddr;
695 priv->path = path;
696 priv->connection_index = connection_index;
697 priv->parent_dev = parent_dev;
698
699 priv->active_config = active_config;
700
701 if (priv->active_config != 0) {
702 usbi_dbg("active config: %d", priv->active_config);
703 } else {
704 // USB devices that don't have a config value are usually missing a driver
705 // TODO (after first official release): use this for automated driver installation
706 // NB: SetupDiGetDeviceRegistryProperty w/ SPDRP_INSTALL_STATE would tell us
707 // if the driver is properly installed, but driverless devices don't seem to
708 // be enumerable by SetupDi...
709 usbi_dbg("* This device has no driver => libusb will not be able to access it *");
710 }
711
712 return LIBUSB_SUCCESS;
713}
714
715/*
716 * HCD (root) hubs need to have their device descriptor manually populated
717 *
718 * Note that we follow the Linux convention and use the "Linux Foundation root hub"
719 * vendor ID as well as the product ID to indicate the hub speed
720 */
721static int force_hcd_device_descriptor(struct libusb_device *dev, HANDLE handle)
722{
723 DWORD size;
724 USB_HUB_CAPABILITIES hub_caps;
725 USB_HUB_CAPABILITIES_EX hub_caps_ex;
726 struct windows_device_priv *priv = __device_priv(dev);
727 struct libusb_context *ctx = DEVICE_CTX(dev);
728
729 priv->dev_descriptor.bLength = sizeof(USB_DEVICE_DESCRIPTOR);
730 priv->dev_descriptor.bDescriptorType = USB_DEVICE_DESCRIPTOR_TYPE;
731 dev->num_configurations = priv->dev_descriptor.bNumConfigurations = 1;
732
733 // The following is used to set the VIS:PID of root HUBs similarly to what
734 // Linux does: 1d6b:0001 is for 1x root hubs, 1d6b:0002 for 2x
735 priv->dev_descriptor.idVendor = 0x1d6b; // Linux Foundation root hub
736 if (windows_version >= WINDOWS_VISTA_AND_LATER) {
737 size = sizeof(USB_HUB_CAPABILITIES_EX);
738 if (DeviceIoControl(handle, IOCTL_USB_GET_HUB_CAPABILITIES_EX, &hub_caps_ex,
739 size, &hub_caps_ex, size, &size, NULL)) {
740 // Sanity check. HCD hub should always be root
741 if (!hub_caps_ex.CapabilityFlags.HubIsRoot) {
742 usbi_warn(ctx, "program assertion failed - HCD hub is not reported as root hub.");
743 }
744 priv->dev_descriptor.idProduct = hub_caps_ex.CapabilityFlags.HubIsHighSpeedCapable?2:1;
745 }
746 } else {
747 size = sizeof(USB_HUB_CAPABILITIES);
748 if (!DeviceIoControl(handle, IOCTL_USB_GET_HUB_CAPABILITIES, &hub_caps,
749 size, &hub_caps, size, &size, NULL)) {
750 usbi_warn(ctx, "could not read hub capabilities (std) for hub %s: %s",
751 priv->path, windows_error_str(0));
752 priv->dev_descriptor.idProduct = 1; // Indicate 1x speed
753 } else {
754 priv->dev_descriptor.idProduct = hub_caps.HubIs2xCapable?2:1;
755 }
756 }
757
758 return LIBUSB_SUCCESS;
759}
760
761/*
762 * fetch and cache all the config descriptors through I/O
763 */
764static int cache_config_descriptors(struct libusb_device *dev, HANDLE hub_handle)
765{
766 DWORD size, ret_size;
767 struct libusb_context *ctx = DEVICE_CTX(dev);
768 struct windows_device_priv *priv = __device_priv(dev);
769 int r;
770 uint8_t i;
771
772 USB_CONFIGURATION_DESCRIPTOR_SHORT cd_buf_short; // dummy request
773 PUSB_DESCRIPTOR_REQUEST cd_buf_actual = NULL; // actual request
774 PUSB_CONFIGURATION_DESCRIPTOR cd_data = NULL;
775
776 if (dev->num_configurations == 0)
777 return LIBUSB_ERROR_INVALID_PARAM;
778
779 priv->config_descriptor = malloc(dev->num_configurations * sizeof(PUSB_CONFIGURATION_DESCRIPTOR));
780 if (priv->config_descriptor == NULL)
781 return LIBUSB_ERROR_NO_MEM;
782 for (i=0; i<dev->num_configurations; i++)
783 priv->config_descriptor[i] = NULL;
784
785 for (i=0, r=LIBUSB_SUCCESS; ; i++)
786 {
787 // safe loop: release all dynamic resources
788 safe_free(cd_buf_actual);
789
790 // safe loop: end of loop condition
791 if ((i >= dev->num_configurations) || (r != LIBUSB_SUCCESS))
792 break;
793
794 size = sizeof(USB_CONFIGURATION_DESCRIPTOR_SHORT);
795 memset(&cd_buf_short, 0, size);
796
797 cd_buf_short.req.ConnectionIndex = priv->connection_index;
798 cd_buf_short.req.SetupPacket.bmRequest = LIBUSB_ENDPOINT_IN;
799 cd_buf_short.req.SetupPacket.bRequest = USB_REQUEST_GET_DESCRIPTOR;
800 cd_buf_short.req.SetupPacket.wValue = (USB_CONFIGURATION_DESCRIPTOR_TYPE << 8) | i;
801 cd_buf_short.req.SetupPacket.wIndex = i;
802 cd_buf_short.req.SetupPacket.wLength = (USHORT)(size - sizeof(USB_DESCRIPTOR_REQUEST));
803
804 // Dummy call to get the required data size
805 if (!DeviceIoControl(hub_handle, IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION, &cd_buf_short, size,
806 &cd_buf_short, size, &ret_size, NULL)) {
807 usbi_err(ctx, "could not access configuration descriptor (dummy): %s", windows_error_str(0));
808 LOOP_BREAK(LIBUSB_ERROR_IO);
809 }
810
811 if ((ret_size != size) || (cd_buf_short.data.wTotalLength < sizeof(USB_CONFIGURATION_DESCRIPTOR))) {
812 usbi_err(ctx, "unexpected configuration descriptor size (dummy).");
813 LOOP_BREAK(LIBUSB_ERROR_IO);
814 }
815
816 size = sizeof(USB_DESCRIPTOR_REQUEST) + cd_buf_short.data.wTotalLength;
817 if ((cd_buf_actual = (PUSB_DESCRIPTOR_REQUEST)malloc(size)) == NULL) {
818 usbi_err(ctx, "could not allocate configuration descriptor buffer. aborting.");
819 LOOP_BREAK(LIBUSB_ERROR_NO_MEM);
820 }
821 memset(cd_buf_actual, 0, size);
822
823 // Actual call
824 cd_buf_actual->ConnectionIndex = priv->connection_index;
825 cd_buf_actual->SetupPacket.bmRequest = LIBUSB_ENDPOINT_IN;
826 cd_buf_actual->SetupPacket.bRequest = USB_REQUEST_GET_DESCRIPTOR;
827 cd_buf_actual->SetupPacket.wValue = (USB_CONFIGURATION_DESCRIPTOR_TYPE << 8) | i;
828 cd_buf_actual->SetupPacket.wIndex = i;
829 cd_buf_actual->SetupPacket.wLength = (USHORT)(size - sizeof(USB_DESCRIPTOR_REQUEST));
830
831 if (!DeviceIoControl(hub_handle, IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION, cd_buf_actual, size,
832 cd_buf_actual, size, &ret_size, NULL)) {
833 usbi_err(ctx, "could not access configuration descriptor (actual): %s", windows_error_str(0));
834 LOOP_BREAK(LIBUSB_ERROR_IO);
835 }
836
837 cd_data = (PUSB_CONFIGURATION_DESCRIPTOR)((UCHAR*)cd_buf_actual+sizeof(USB_DESCRIPTOR_REQUEST));
838
839 if ((size != ret_size) || (cd_data->wTotalLength != cd_buf_short.data.wTotalLength)) {
840 usbi_err(ctx, "unexpected configuration descriptor size (actual).");
841 LOOP_BREAK(LIBUSB_ERROR_IO);
842 }
843
844 if (cd_data->bDescriptorType != USB_CONFIGURATION_DESCRIPTOR_TYPE) {
845 usbi_err(ctx, "not a configuration descriptor");
846 LOOP_BREAK(LIBUSB_ERROR_IO);
847 }
848
849 usbi_dbg("cached config descriptor #%d (%d bytes)", i+1, cd_data->wTotalLength);
850
851 // Sanity check. Ensures that indexes for our list of config desc is in the right order
852 if (i != (cd_data->bConfigurationValue-1)) {
853 usbi_warn(ctx, "program assertion failed - config descriptors are being read out of order");
854 continue;
855 }
856
857 // Cache the descriptor
858 priv->config_descriptor[i] = malloc(cd_data->wTotalLength);
859 if (priv->config_descriptor[i] == NULL)
860 return LIBUSB_ERROR_NO_MEM;
861
862 memcpy(priv->config_descriptor[i], cd_data, cd_data->wTotalLength);
863 }
864 return LIBUSB_SUCCESS;
865}
866
867/*
868 * Recursively enumerates and finds all hubs & devices
869 */
870static int usb_enumerate_hub(struct libusb_context *ctx, struct discovered_devs **_discdevs,
871 HANDLE hub_handle, libusb_bus_t busnum, struct libusb_device *parent_dev, uint8_t nb_ports)
872{
873 struct discovered_devs *discdevs = *_discdevs;
874 struct libusb_device *dev = NULL;
875 DWORD size, size_initial, size_fixed, getname_ioctl;
876 HANDLE handle = INVALID_HANDLE_VALUE;
877 USB_HUB_NAME_FIXED s_hubname;
878 USB_NODE_CONNECTION_INFORMATION conn_info;
879 USB_NODE_INFORMATION hub_node;
880 bool is_hcd, need_unref = false;
881 int i, r;
882 LPCWSTR wstr;
883 char *tmp_str = NULL, *path_str = NULL;
884 unsigned long session_id;
885 libusb_devaddr_t devaddr = 0;
886 struct windows_device_priv *priv, *parent_priv;
887
888 // obviously, root (HCD) hubs have no parent
889 is_hcd = (parent_dev == NULL);
890 if (is_hcd)
891 {
892 if (nb_ports != 1) {
893 usbi_warn(ctx, "program assertion failed - invalid number of ports for HCD.");
894 return LIBUSB_ERROR_INVALID_PARAM;
895 }
896 parent_priv = NULL;
897 size_initial = sizeof(USB_ROOT_HUB_NAME);
898 size_fixed = sizeof(USB_ROOT_HUB_NAME_FIXED);
899 getname_ioctl = IOCTL_USB_GET_ROOT_HUB_NAME;
900 }
901 else
902 {
903 parent_priv = __device_priv(parent_dev);
904 size_initial = sizeof(USB_NODE_CONNECTION_NAME);
905 size_fixed = sizeof(USB_NODE_CONNECTION_NAME_FIXED);
906 getname_ioctl = IOCTL_USB_GET_NODE_CONNECTION_NAME;
907 }
908
909 // Loop through all the ports on this hub
910 for (i = 1, r = LIBUSB_SUCCESS; ; i++)
911 {
912 // safe loop: release all dynamic resources
913 if (need_unref) {
914 safe_unref_device(dev);
915 need_unref = false;
916 }
917 safe_free(tmp_str);
918 safe_free(path_str);
919 safe_closehandle(handle);
920
921 // safe loop: end of loop condition
922 if ((i > nb_ports) || (r != LIBUSB_SUCCESS))
923 break;
924
925 memset(&conn_info, 0, sizeof(conn_info));
926 // For non HCDs, check if the node on this port is a hub or a regular device
927 if (!is_hcd) {
928 size = sizeof(USB_NODE_CONNECTION_INFORMATION);
929 conn_info.ConnectionIndex = i;
930 if (!DeviceIoControl(hub_handle, IOCTL_USB_GET_NODE_CONNECTION_INFORMATION, &conn_info, size,
931 &conn_info, size, &size, NULL)) {
932 usbi_warn(ctx, "could not get node connection information: %s", windows_error_str(0));
933 continue;
934 }
935
936 if (conn_info.ConnectionStatus == NoDeviceConnected) {
937 continue;
938 }
939
940 if (conn_info.DeviceAddress == LIBUSB_DEVADDR_MAX) {
941 usbi_warn(ctx, "program assertion failed - device address is %d "
942 "(conflicts with root hub), ignoring device", LIBUSB_DEVADDR_MAX);
943 continue;
944 }
945
946 s_hubname.u.node.ConnectionIndex = i; // Only used for non HCDs (s_hubname is an union)
947 }
948 else
949 {
950 // HCDs have only 1 node, and it's always a hub
951 conn_info.DeviceAddress = LIBUSB_DEVADDR_MAX; // using 0 can conflict with driverless devices
952 conn_info.DeviceIsHub = true;
953 conn_info.CurrentConfigurationValue = 1;
954 }
955
956 // If this node is a hub (HCD or not), open it
957 if (conn_info.DeviceIsHub) {
958 size = size_initial;
959 if (!DeviceIoControl(hub_handle, getname_ioctl, &s_hubname, size,
960 &s_hubname, size, &size, NULL)) {
961 usbi_warn(ctx, "could not get hub path (dummy): %s", windows_error_str(0));
962 continue;
963 }
964
965 size = is_hcd?s_hubname.u.root.ActualLength:s_hubname.u.node.ActualLength;
966 if (size > size_fixed) {
967 usbi_warn(ctx, "program assertion failed - hub path is too long");
968 continue;
969 }
970
971 if (!is_hcd) {
972 // previous call trashes some of the data
973 s_hubname.u.node.ConnectionIndex = i;
974 }
975 if (!DeviceIoControl(hub_handle, getname_ioctl, &s_hubname, size,
976 &s_hubname, size, &size, NULL)) {
977 usbi_warn(ctx, "could not get hub path (actual): %s", windows_error_str(0));
978 continue;
979 }
980
981 // Add prefix
982 wstr = is_hcd?s_hubname.u.root.RootHubName:s_hubname.u.node.NodeName;
983 tmp_str = wchar_to_utf8(wstr);
984 if (tmp_str == NULL) {
985 usbi_err(ctx, "could not convert hub path string.");
986 LOOP_BREAK(LIBUSB_ERROR_NO_MEM);
987 }
988
989 path_str = sanitize_path(tmp_str);
990 if (path_str == NULL) {
991 usbi_err(ctx, "could not sanitize hub path string.");
992 LOOP_BREAK(LIBUSB_ERROR_NO_MEM);
993 }
994
995 // Open Hub
996 handle = CreateFileA(path_str, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
997 FILE_FLAG_OVERLAPPED, NULL);
998 if(handle == INVALID_HANDLE_VALUE) {
999 usbi_warn(ctx, "could not open hub %s: %s", path_str, windows_error_str(0));
1000 continue;
1001 }
1002 }
1003
1004 // Generate a session ID
1005 // Will need to change the session_id computation if this assertion fails
1006 if (conn_info.DeviceAddress > LIBUSB_DEVADDR_MAX) {
1007 usbi_warn(ctx, "program assertion failed - device address is greater than %d, ignoring device",
1008 LIBUSB_DEVADDR_MAX);
1009 continue;
1010 } else {
1011 devaddr = (uint8_t)conn_info.DeviceAddress;
1012 }
1013 // Same trick as linux for session_id, with same caveat
1014 session_id = busnum << (sizeof(libusb_devaddr_t)*8) | devaddr;
1015 usbi_dbg("busnum %d devaddr %d session_id %ld", busnum, devaddr, session_id);
1016
1017 // Allocate device if needed
1018 dev = usbi_get_device_by_session_id(ctx, session_id);
1019 if (dev) {
1020 usbi_dbg("using existing device for session %ld", session_id);
1021 priv = __device_priv(dev);
1022 // Because we are rebuilding the list, there's no guarantee
1023 // the parent device pointer is still the same.
1024 // Other device data should still be reusable
1025 priv->parent_dev = parent_dev;
1026 } else {
1027 usbi_dbg("allocating new device for session %ld", session_id);
1028 if ((dev = usbi_alloc_device(ctx, session_id)) == NULL) {
1029 LOOP_BREAK(LIBUSB_ERROR_NO_MEM);
1030 }
1031 need_unref = true;
1032
1033 LOOP_CHECK(initialize_device(dev, busnum, devaddr, path_str, i,
1034 conn_info.CurrentConfigurationValue, parent_dev));
1035 priv = __device_priv(dev);
1036
1037 path_str = NULL; // protect our path from being freed
1038
1039 // Setup the cached descriptors. Note that only non HCDs can fetch descriptors
1040 if (!is_hcd) {
1041 // The device descriptor has been read with conn_info
1042 memcpy(&priv->dev_descriptor, &(conn_info.DeviceDescriptor), sizeof(USB_DEVICE_DESCRIPTOR));
1043 dev->num_configurations = priv->dev_descriptor.bNumConfigurations;
1044 // If we can't read the config descriptors, just set the number of confs to zero
1045 if (cache_config_descriptors(dev, hub_handle) != LIBUSB_SUCCESS) {
1046 dev->num_configurations = 0;
1047 priv->dev_descriptor.bNumConfigurations = 0;
1048 }
1049 } else {
1050 LOOP_CHECK(force_hcd_device_descriptor(dev, handle));
1051 }
1052 LOOP_CHECK(usbi_sanitize_device(dev));
1053 }
1054
1055 discdevs = discovered_devs_append(*_discdevs, dev);
1056 if (!discdevs) {
1057 LOOP_BREAK(LIBUSB_ERROR_NO_MEM);
1058 }
1059
1060 *_discdevs = discdevs;
1061
1062 // Finally, if device is a hub, recurse
1063 if (conn_info.DeviceIsHub) {
1064 // Find number of ports for this hub
1065 size = sizeof(USB_NODE_INFORMATION);
1066 if (!DeviceIoControl(handle, IOCTL_USB_GET_NODE_INFORMATION, &hub_node, size,
1067 &hub_node, size, &size, NULL)) {
1068 usbi_warn(ctx, "could not retreive information for hub %s: %s",
1069 priv->path, windows_error_str(0));
1070 continue;
1071 }
1072
1073 if (hub_node.NodeType != UsbHub) {
1074 usbi_warn(ctx, "unexpected hub type (%d) for hub %s", hub_node.NodeType, priv->path);
1075 continue;
1076 }
1077
1078 usbi_dbg("%d ports Hub: %s", hub_node.u.HubInformation.HubDescriptor.bNumberOfPorts, priv->path);
1079
1080 usb_enumerate_hub(ctx, _discdevs, handle, busnum, dev,
1081 hub_node.u.HubInformation.HubDescriptor.bNumberOfPorts);
1082 }
1083 }
1084
1085 return r;
1086}
1087
1088/*
1089 * Composite device interfaces are not enumerated using GUID_DEVINTERFACE_USB_DEVICE,
1090 * but instead require a different lookup mechanism
1091 */
1092static int set_composite_device(struct libusb_context *ctx, DEVINST devinst, struct windows_device_priv *priv)
1093{
1094// indexes for additional interface GUIDs, not available from "USB"
1095// SetupDiGetClassDevs enumeration should go here. Typically, these are
1096// device interfaces that begin with something else than "\\?\usb\"
1097enum libusb_hid_report_type {
1098 HID_DEVICE_INTERFACE_GUID_INDEX = 0,
1099 MAX_DEVICE_INTERFACE_GUID_INDEX = 1
1100};
1101
1102 DEVINST child_devinst, parent_devinst;
1103 unsigned i, j, max_guids, nb_paths, interface_number;
1104 uint8_t api;
1105 bool found;
1106 DWORD type, size;
1107 CONFIGRET r;
1108 HDEVINFO dev_info;
1109 SP_DEVINFO_DATA dev_info_data;
1110 SP_DEVICE_INTERFACE_DETAIL_DATA *dev_interface_details = NULL;
1111 HKEY key;
1112 WCHAR guid_string_w[MAX_GUID_STRING_LENGTH];
1113 GUID guid, class_guid;
1114 GUID guid_table[MAX_USB_DEVICES];
1115 char* sanitized_path[MAX_USB_DEVICES];
1116 char* hid_path[MAX_USB_DEVICES]; // An extra path is needed for HID
1117 uint8_t api_type[MAX_USB_DEVICES];
1118 char* sanitized_short = NULL;
1119 char path[MAX_PATH_LENGTH];
1120 char driver[MAX_KEY_LENGTH];
1121
1122 dev_info = SetupDiGetClassDevs(NULL, "USB", NULL, DIGCF_PRESENT|DIGCF_ALLCLASSES);
1123 if (dev_info == INVALID_HANDLE_VALUE) {
1124 return LIBUSB_ERROR_NOT_FOUND;
1125 }
1126
1127 // Manually add the HID GUID as it cannot be read with DeviceInterfaceGUIDs reg key)
1128 // NB the value returned by HidD_GetHidGuid, which is for interface class is different
1129 // from GUID_HID, which is the device class GUID
1130 HidD_GetHidGuid(&guid_table[HID_DEVICE_INTERFACE_GUID_INDEX]);
1131 // NB: for other interface guids, SetupDiClassGuidsFromName can be used
1132 max_guids = MAX_DEVICE_INTERFACE_GUID_INDEX;
1133
1134 // First, retrieve all the device interface GUIDs
1135 for (i = 0; ; i++)
1136 {
1137 dev_info_data.cbSize = sizeof(dev_info_data);
1138 if (!SetupDiEnumDeviceInfo(dev_info, i, &dev_info_data)) {
1139 break;
1140 }
1141
1142 key = SetupDiOpenDevRegKey(dev_info, &dev_info_data, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_READ);
1143 if (key == INVALID_HANDLE_VALUE) {
1144 usbi_dbg("could not open registry key");
1145 continue;
1146 }
1147
1148 size = sizeof(guid_string_w);
1149 r = RegQueryValueExW(key, L"DeviceInterfaceGUIDs", NULL, &type,
1150 (BYTE*)guid_string_w, &size);
1151 RegCloseKey(key);
1152 if (r != ERROR_SUCCESS) {
1153 continue;
1154 }
1155 CLSIDFromString(guid_string_w, &guid);
1156
1157 // identical device interface GUIDs are not supposed to happen, but are a real possibility
1158 // => check and ignore duplicates
1159 found = false;
1160 for (j=0; j<max_guids; j++) {
1161 if (memcmp(&guid_table[j], &guid, sizeof(GUID)) == 0) {
1162 found = true;
1163 break;
1164 }
1165 }
1166 if (!found) {
1167 guid_table[max_guids++] = guid;
1168 if (max_guids > MAX_USB_DEVICES) {
1169 usbi_warn(ctx, "more than %d devices - ignoring the rest", MAX_USB_DEVICES);
1170 break;
1171 }
1172 }
1173 }
1174 SetupDiDestroyDeviceInfoList(dev_info);
1175
1176 // Now let's find the device interface paths for all these devices
1177 nb_paths = 0;
1178 for (j=0; j<max_guids; j++)
1179 {
1180 guid = guid_table[j];
1181
1182 for (i = 0; ; i++)
1183 {
1184 safe_free(dev_interface_details);
1185 dev_interface_details = get_interface_details(ctx, &dev_info, &dev_info_data, guid, i);
1186 if (dev_interface_details == NULL)
1187 break;
1188
1189 // HID devices (and possibly other classes) have an extra indirection
1190 // for an USB path we can recognize
1191 if (j == HID_DEVICE_INTERFACE_GUID_INDEX) {
1192 if (CM_Get_Parent(&parent_devinst, dev_info_data.DevInst, 0) != CR_SUCCESS) {
1193 usbi_warn(ctx, "could not retrieve HID parent info data for device %s, skipping: %s",
1194 dev_interface_details->DevicePath, windows_error_str(0));
1195 continue;
1196 }
1197
1198 if (CM_Get_Device_ID(parent_devinst, path, MAX_PATH_LENGTH, 0) != CR_SUCCESS) {
1199 usbi_warn(ctx, "could not retrieve HID parent's path for device %s, skipping: %s",
1200 dev_interface_details->DevicePath, windows_error_str(0));
1201 continue;
1202 }
1203 }
1204
1205 // In case we can't read the driver string through SPDRP_SERVICE (which is
1206 // the case for HID), we need the ClassGUID for comparison.
1207 if(!SetupDiGetDeviceRegistryPropertyW(dev_info, &dev_info_data, SPDRP_CLASSGUID,
1208 NULL, (BYTE*)guid_string_w, sizeof(guid_string_w), &size)) {
1209 usbi_warn(ctx, "could not read class GUID for device %s, skipping: %s",
1210 dev_interface_details->DevicePath, windows_error_str(0));
1211 continue;
1212 }
1213 CLSIDFromString(guid_string_w, &class_guid);
1214
1215 // Attempt to read the driver string
1216 if(!SetupDiGetDeviceRegistryProperty(dev_info, &dev_info_data, SPDRP_SERVICE,
1217 NULL, (BYTE*)driver, MAX_KEY_LENGTH, &size)) {
1218 driver[0] = 0;
1219 }
1220
1221 for (api=USB_API_WINUSB; api<USB_API_MAX; api++) {
1222 if ( (is_api_driver(driver, api))
1223 || (guid_eq(&class_guid, usb_api_backend[api].class_guid)) ) {
1224 api_type[nb_paths] = api;
1225 if (j == HID_DEVICE_INTERFACE_GUID_INDEX) {
1226 hid_path[nb_paths] = sanitize_path(path);
1227 } else {
1228 hid_path[nb_paths] = NULL;
1229 }
1230 sanitized_path[nb_paths++] = sanitize_path(dev_interface_details->DevicePath);
1231 if (nb_paths > MAX_USB_DEVICES) {
1232 usbi_warn(ctx, "more than %d devices - ignoring the rest", MAX_USB_DEVICES);
1233 break;
1234 }
1235 }
1236 }
1237 }
1238 }
1239
1240 // Finally, match the interface paths with the interfaces. We do that
1241 // by looking at the children of the composite device
1242 // NB: if the interfaces are not found in their expected position,
1243 // claim_interface will issue a warning
1244 found = false;
1245 memset(&child_devinst, 0, sizeof(DEVINST)); // prevents /W4 warning
1246 for (i = 0; i<USB_MAXINTERFACES; i++)
1247 {
1248 if (i == 0) {
1249 r = CM_Get_Child(&child_devinst, devinst, 0);
1250 } else {
1251 r = CM_Get_Sibling(&child_devinst, child_devinst, 0);
1252 }
1253 if (r == CR_NO_SUCH_DEVNODE) { // end of the siblings
1254 break;
1255 } else if (r != CR_SUCCESS) {
1256 usbi_dbg("unable to find interface sibling #%d, error = %X", i, r);
1257 break;
1258 }
1259
1260 r = CM_Get_Device_ID(child_devinst, path, MAX_PATH_LENGTH, 0);
1261 if (r != CR_SUCCESS) {
1262 usbi_err(ctx, "could not retrieve simple path for interface %d: CR error %d",
1263 i, r);
1264 continue;
1265 }
1266 sanitized_short = sanitize_path(path);
1267 if (sanitized_short == NULL) {
1268 usbi_err(ctx, "could not sanitize path for interface %d", i);
1269 continue;
1270 }
1271
1272 // Because MI_## are not necessarily in sequential order (some composite HID
1273 // devices will have only MI_00 & MI_03 for instance), we retrieve the actual
1274 // interface number from the path's MI value
1275 interface_number = i;
1276 for (j=0; sanitized_short[j] != 0; ) {
1277 if ( (sanitized_short[j++] == 'M') && (sanitized_short[j++] == 'I')
1278 && (sanitized_short[j++] == '_') ) {
1279 interface_number = (sanitized_short[j++] - '0')*10;
1280 interface_number += sanitized_short[j] - '0';
1281 break;
1282 }
1283 }
1284 if (sanitized_short[j] == 0) {
1285 usbi_warn(ctx, "failure to read interface number for %s. Using default value %d",
1286 sanitized_short, interface_number);
1287 }
1288
1289 for (j=0; j<nb_paths; j++) {
1290 if ( (safe_strncmp(sanitized_path[j], sanitized_short, safe_strlen(sanitized_short)) == 0)
1291 || (safe_strcmp(hid_path[j], sanitized_short) == 0 ) ) {
1292 // HID devices can have multiple collections (COL##) for each MI_## interface
1293 if (priv->usb_interface[interface_number].path != NULL) {
1294 usbi_dbg("interface_path[%d] already set - ignoring HID collection: %s",
1295 interface_number, sanitized_path[j]);
1296 if (api_type[j] != USB_API_HID) {
1297 usbi_warn(ctx, "program assertion failed - not an HID collection");
1298 }
1299 } else {
1300 priv->usb_interface[interface_number].path = sanitized_path[j];
1301 priv->usb_interface[interface_number].apib = &usb_api_backend[api_type[j]];
1302 if ((api_type[j] == USB_API_HID) && (priv->hid == NULL)) {
1303 priv->hid = calloc(1, sizeof(struct hid_device_priv));
1304 }
1305 priv->composite_api_flags |= 1<<api_type[j];
1306 sanitized_path[j] = NULL;
1307 }
1308 }
1309 }
1310 safe_free(sanitized_short);
1311
1312 if (priv->usb_interface[interface_number].path == NULL) {
1313 usbi_warn(ctx, "interface_path[%d]: unhandled API - interface will be disabled",
1314 interface_number);
1315 continue;
1316 }
1317 usbi_dbg("interface_path[%d]: %s", interface_number, priv->usb_interface[interface_number].path);
1318 found = true;
1319 }
1320
1321 for (j=0; j<nb_paths; j++) {
1322 safe_free(sanitized_path[j]);
1323 safe_free(hid_path[j]);
1324 }
1325
1326 if (found == 0) {
1327 usbi_warn(ctx, "composite device: no interfaces were found");
1328 return LIBUSB_ERROR_NOT_FOUND;
1329 }
1330
1331 return LIBUSB_SUCCESS;
1332}
1333
1334/*
1335 * Likewise, HID device interfaces's path (\\.\HID\...) are not enumerated through the
1336 * generic USB devices GUID, but are actually children of one such device
1337 */
1338static int set_hid_device(struct libusb_context *ctx, struct windows_device_priv *priv)
1339 {
1340 char path[MAX_PATH_LENGTH];
1341 char *sanitized_path = NULL;
1342 HDEVINFO dev_info;
1343 SP_DEVICE_INTERFACE_DETAIL_DATA *dev_interface_details = NULL;
1344 SP_DEVINFO_DATA dev_info_data;
1345 DEVINST parent_devinst;
1346 GUID guid;
1347 int r = LIBUSB_SUCCESS;
1348 unsigned i, interface_number;
1349
1350 interface_number = 0;
1351 HidD_GetHidGuid(&guid);
1352 for (i = 0; ; i++)
1353 {
1354 // safe loop: free up any (unprotected) dynamic resource
1355 safe_free(dev_interface_details);
1356 safe_free(sanitized_path);
1357
1358 dev_interface_details = get_interface_details(ctx, &dev_info, &dev_info_data, guid, i);
1359 // safe loop: end of loop condition
1360 if ( (dev_interface_details == NULL)
1361 || (r != LIBUSB_SUCCESS) )
1362 break;
1363
1364 // Retrieve parent's path using PnP Configuration Manager (CM)
1365 if (CM_Get_Parent(&parent_devinst, dev_info_data.DevInst, 0) != CR_SUCCESS) {
1366 usbi_warn(ctx, "could not retrieve parent info data for device %s, skipping: %s",
1367 dev_interface_details->DevicePath, windows_error_str(0));
1368 continue;
1369 }
1370
1371 if (CM_Get_Device_ID(parent_devinst, path, MAX_PATH_LENGTH, 0) != CR_SUCCESS) {
1372 usbi_warn(ctx, "could not retrieve parent's path for device %s, skipping: %s",
1373 dev_interface_details->DevicePath, windows_error_str(0));
1374 continue;
1375 }
1376
1377 // Fix parent's path inconsistencies before attempting to compare
1378 sanitized_path = sanitize_path(path);
1379 if (sanitized_path == NULL) {
1380 usbi_warn(ctx, "could not sanitize parent's path for device %s, skipping.",
1381 dev_interface_details->DevicePath);
1382 continue;
1383 }
1384
1385 // NB: we compare strings of different lengths below => strncmp
1386 if (safe_strncmp(priv->path, sanitized_path, safe_strlen(sanitized_path)) == 0) {
1387 priv->usb_interface[interface_number].path = sanitize_path(dev_interface_details->DevicePath);
1388 priv->usb_interface[interface_number].apib = &usb_api_backend[USB_API_HID];
1389 usbi_dbg("interface_path[%d]: %s", interface_number, priv->usb_interface[interface_number].path);
1390 interface_number++;
1391 }
1392 }
1393
1394 return LIBUSB_SUCCESS;
1395}
1396
1397/*
1398 * This function retrieves and sets the paths of all non-hub devices
1399 * NB: No I/O with device is required during this call
1400 */
1401static int set_device_paths(struct libusb_context *ctx, struct discovered_devs *discdevs)
1402{
1403 // Precedence for filter drivers vs driver is in the order of this array
1404 struct driver_lookup lookup[3] = {
1405 {"\0\0", SPDRP_SERVICE, "driver"},
1406 {"\0\0", SPDRP_UPPERFILTERS, "upper filter driver"},
1407 {"\0\0", SPDRP_LOWERFILTERS, "lower filter driver"}
1408 };
1409 struct windows_device_priv *priv;
1410 struct windows_device_priv *parent_priv;
1411 char path[MAX_PATH_LENGTH];
1412 char *sanitized_path = NULL;
1413 HDEVINFO dev_info;
1414 SP_DEVICE_INTERFACE_DETAIL_DATA *dev_interface_details = NULL;
1415 SP_DEVINFO_DATA dev_info_data;
1416 DEVINST parent_devinst;
1417 GUID guid;
1418 DWORD size, reg_type, install_state, port_nr;
1419 int r = LIBUSB_SUCCESS;
1420 unsigned i, j, k, l;
1421 uint8_t api;
1422 bool found;
1423
1424 // TODO (after first official release): MI_## automated driver installation
1425 guid = GUID_DEVINTERFACE_USB_DEVICE;
1426 for (i = 0; ; i++)
1427 {
1428 // safe loop: free up any (unprotected) dynamic resource
1429 safe_free(dev_interface_details);
1430 safe_free(sanitized_path);
1431
1432 dev_interface_details = get_interface_details(ctx, &dev_info, &dev_info_data, guid, i);
1433 // safe loop: end of loop condition
1434 if ( (dev_interface_details == NULL)
1435 || (r != LIBUSB_SUCCESS) )
1436 break;
1437
1438 // Check that the driver installation is OK
1439 if ( (!SetupDiGetDeviceRegistryProperty(dev_info, &dev_info_data, SPDRP_INSTALL_STATE,
1440 &reg_type, (BYTE*)&install_state, 4, &size))
1441 && (size != 4) ){
1442 usbi_warn(ctx, "could not detect installation state of driver for %s: %s",
1443 dev_interface_details->DevicePath, windows_error_str(0));
1444 } else if (install_state != 0) {
1445 usbi_warn(ctx, "driver for device %s is reporting an issue (code: %d) - skipping",
1446 dev_interface_details->DevicePath, install_state);
1447 continue;
1448 }
1449
1450 // The SPDRP_ADDRESS for USB devices should be the device port number on the hub
1451 if ( (!SetupDiGetDeviceRegistryProperty(dev_info, &dev_info_data, SPDRP_ADDRESS,
1452 &reg_type, (BYTE*)&port_nr, 4, &size))
1453 && (size != 4) ){
1454 usbi_warn(ctx, "could not retrieve port number for device %s, skipping: %s",
1455 dev_interface_details->DevicePath, windows_error_str(0));
1456 continue;
1457 }
1458
1459 // Retrieve parent's path using PnP Configuration Manager (CM)
1460 if (CM_Get_Parent(&parent_devinst, dev_info_data.DevInst, 0) != CR_SUCCESS) {
1461 usbi_warn(ctx, "could not retrieve parent info data for device %s, skipping: %s",
1462 dev_interface_details->DevicePath, windows_error_str(0));
1463 continue;
1464 }
1465
1466 if (CM_Get_Device_ID(parent_devinst, path, MAX_PATH_LENGTH, 0) != CR_SUCCESS) {
1467 usbi_warn(ctx, "could not retrieve parent's path for device %s, skipping: %s",
1468 dev_interface_details->DevicePath, windows_error_str(0));
1469 continue;
1470 }
1471
1472 // Fix parent's path inconsistencies before attempting to compare
1473 sanitized_path = sanitize_path(path);
1474 if (sanitized_path == NULL) {
1475 usbi_warn(ctx, "could not sanitize parent's path for device %s, skipping.",
1476 dev_interface_details->DevicePath);
1477 continue;
1478 }
1479
1480 // With the parent path and port number, we should be able to locate our device
1481 // by comparing these values to the ones we got when enumerating hubs
1482 found = false;
1483 for (j=0; j<discdevs->len; j++) {
1484 priv = __device_priv(discdevs->devices[j]);
1485
1486 if (priv->parent_dev == NULL) {
1487 continue; // ignore HCDs
1488 }
1489
1490 parent_priv = __device_priv(priv->parent_dev);
1491
1492 // NB: we compare strings of different lengths below => strncmp
1493 if ( (safe_strncmp(parent_priv->path, sanitized_path, safe_strlen(sanitized_path)) == 0)
1494 && (port_nr == priv->connection_index) ) {
1495
1496 priv->path = sanitize_path(dev_interface_details->DevicePath);
1497
1498 usbi_dbg("path (%d:%d): %s", discdevs->devices[j]->bus_number,
1499 discdevs->devices[j]->device_address, priv->path);
1500
1501 // Check the service & filter names to know the API we should use
1502 for (k=0; k<3; k++) {
1503 if (SetupDiGetDeviceRegistryPropertyA(dev_info, &dev_info_data, lookup[k].reg_prop,
1504 &reg_type, (BYTE*)lookup[k].list, MAX_KEY_LENGTH, &size)) {
1505 // Turn the REG_SZ SPDRP_SERVICE into REG_MULTI_SZ
1506 if (lookup[k].reg_prop == SPDRP_SERVICE) {
1507 // our buffers are MAX_KEY_LENGTH+1 so we can overflow if needed
1508 lookup[k].list[safe_strlen(lookup[k].list)+1] = 0;
1509 }
1510 // MULTI_SZ is a pain to work with. Turn it into something much more manageable
1511 // NB: none of the driver names we check against contain LIST_SEPARATOR,
1512 // (currently ';'), so even if an unsuported one does, it's not an issue
1513 for (l=0; (lookup[k].list[l] != 0) || (lookup[k].list[l+1] != 0); l++) {
1514 if (lookup[k].list[l] == 0) {
1515 lookup[k].list[l] = LIST_SEPARATOR;
1516 }
1517 }
1518 upperize(lookup[k].list);
1519 usbi_dbg("%s(s): %s", lookup[k].designation, lookup[k].list);
1520 found = true;
1521 } else {
1522 if (GetLastError() != ERROR_INVALID_DATA) {
1523 usbi_dbg("could not access %s: %s", lookup[k].designation, windows_error_str(0));
1524 }
1525 lookup[k].list[0] = 0;
1526 }
1527 }
1528
1529 for (api=0; api<USB_API_MAX; api++) {
1530 for (k=0; k<3; k++) {
1531 if (is_api_driver(lookup[k].list, api)) {
1532 usbi_dbg("matched %s name against %s", lookup[k].designation, usb_api_backend[api].designation);
1533 break;
1534 }
1535 }
1536 if (k >= 3) continue;
1537 priv->apib = &usb_api_backend[api];
1538 switch(api) {
1539 case USB_API_COMPOSITE:
1540 set_composite_device(ctx, dev_info_data.DevInst, priv);
1541 break;
1542 case USB_API_HID:
1543 safe_free(priv->hid);
1544 priv->hid = calloc(1, sizeof(struct hid_device_priv));
1545 if (priv->hid == NULL) {
1546 usbi_err(ctx, "could not allocate HID data for %s, skipping",
1547 dev_interface_details->DevicePath);
1548 priv->apib = &usb_api_backend[USB_API_UNSUPPORTED];
1549 safe_free(priv->path);
1550 } else {
1551 set_hid_device(ctx, priv);
1552 }
1553 break;
1554 default:
1555 // For other devices, the first interface is the same as the device
1556 priv->usb_interface[0].path = malloc(safe_strlen(priv->path)+1);
1557 if (priv->usb_interface[0].path != NULL) {
1558 safe_strcpy(priv->usb_interface[0].path, safe_strlen(priv->path)+1, priv->path);
1559 }
1560 // The following is needed if we want to API calls to work for both simple
1561 // and composite devices, as
1562 for(k=0; k<USB_MAXINTERFACES; k++) {
1563 priv->usb_interface[k].apib = &usb_api_backend[api];
1564 }
1565 break;
1566 }
1567 }
1568 break;
1569 }
1570 }
1571 if (!found) {
1572 usbi_warn(ctx, "could not match %s with a libusb device.", dev_interface_details->DevicePath);
1573 continue;
1574 }
1575 }
1576
1577 return LIBUSB_SUCCESS;
1578}
1579
1580/*
1581 * get_device_list: libusb backend device enumeration function
1582 */
1583static int windows_get_device_list(struct libusb_context *ctx, struct discovered_devs **_discdevs)
1584{
1585 struct windows_hcd_priv* hcd;
1586 HANDLE handle = INVALID_HANDLE_VALUE;
1587 int r = LIBUSB_SUCCESS;
1588 libusb_bus_t bus;
1589
1590 // Use the index of the HCD in the chained list as bus #
1591 for (hcd = hcd_root, bus = 0; ; hcd = hcd->next, bus++)
1592 {
1593 safe_closehandle(handle);
1594
1595 if ( (hcd == NULL) || (r != LIBUSB_SUCCESS) )
1596 break;
1597
1598 if (bus == LIBUSB_BUS_MAX) {
1599 usbi_warn(ctx, "program assertion failed - got more than %d buses, skipping the rest.", LIBUSB_BUS_MAX);
1600 continue;
1601 }
1602
1603 handle = CreateFileA(hcd->path, GENERIC_WRITE, FILE_SHARE_WRITE,
1604 NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
1605 if (handle == INVALID_HANDLE_VALUE) {
1606 usbi_warn(ctx, "could not open bus %u, skipping: %s", bus, windows_error_str(0));
1607 continue;
1608 }
1609
1610 LOOP_CHECK(usb_enumerate_hub(ctx, _discdevs, handle, bus, NULL, 1));
1611 }
1612
1613 // Set the interface path for non-hubs
1614 r = set_device_paths(ctx, *_discdevs);
1615
1616 return r;
1617}
1618
1619/*
1620 * exit: libusb backend deinitialization function
1621 */
1622static void windows_exit(void)
1623{
1624 struct windows_hcd_priv* hcd_tmp;
1625 int i;
1626 HANDLE semaphore;
1627 TCHAR sem_name[11+1+8]; // strlen(libusb_init)+'\0'+(32-bit hex PID)
1628
1629 sprintf(sem_name, "libusb_init%08X", (unsigned int)GetCurrentProcessId()&0xFFFFFFFF);
1630 semaphore = CreateSemaphore(NULL, 1, 1, sem_name);
1631 if (semaphore == NULL) {
1632 return;
1633 }
1634
1635 // A successful wait brings our semaphore count to 0 (unsignaled)
1636 // => any concurent wait stalls until the semaphore release
1637 if (WaitForSingleObject(semaphore, INFINITE) != WAIT_OBJECT_0) {
1638 CloseHandle(semaphore);
1639 return;
1640 }
1641
1642 // Only works if exits and inits are balanced exactly
1643 if (--concurrent_usage < 0) { // Last exit
1644 while (hcd_root != NULL)
1645 {
1646 hcd_tmp = hcd_root; // Keep a copy for free
1647 hcd_root = hcd_root->next;
1648 windows_hcd_priv_release(hcd_tmp);
1649 safe_free(hcd_tmp);
1650 }
1651
1652 for (i=0; i<USB_API_MAX; i++) {
1653 usb_api_backend[i].exit();
1654 }
1655 exit_polling();
1656
1657 if (timer_thread) {
1658 SetEvent(timer_request[1]); // actually the signal to quit the thread.
1659 if (WAIT_OBJECT_0 != WaitForSingleObject(timer_thread, INFINITE)) {
1660 usbi_dbg("could not wait for timer thread to quit");
1661 TerminateThread(timer_thread, 1);
1662 }
1663 CloseHandle(timer_thread);
1664 timer_thread = NULL;
1665 }
1666 for (i = 0; i < 2; i++) {
1667 if (timer_request[i]) {
1668 CloseHandle(timer_request[i]);
1669 timer_request[i] = NULL;
1670 }
1671 }
1672 if (timer_response) {
1673 CloseHandle(timer_response);
1674 timer_response = NULL;
1675 }
1676 if (timer_mutex) {
1677 CloseHandle(timer_mutex);
1678 timer_mutex = NULL;
1679 }
1680 }
1681
1682 ReleaseSemaphore(semaphore, 1, NULL); // increase count back to 1
1683 CloseHandle(semaphore);
1684}
1685
1686static int windows_get_device_descriptor(struct libusb_device *dev, unsigned char *buffer, int *host_endian)
1687{
1688 struct windows_device_priv *priv = __device_priv(dev);
1689
1690 memcpy(buffer, &(priv->dev_descriptor), DEVICE_DESC_LENGTH);
1691 *host_endian = 0;
1692
1693 return LIBUSB_SUCCESS;
1694}
1695
1696static int windows_get_config_descriptor(struct libusb_device *dev, uint8_t config_index, unsigned char *buffer, size_t len, int *host_endian)
1697{
1698 struct windows_device_priv *priv = __device_priv(dev);
1699 PUSB_CONFIGURATION_DESCRIPTOR config_header;
1700 size_t size;
1701
1702 // config index is zero based
1703 if (config_index >= dev->num_configurations)
1704 return LIBUSB_ERROR_INVALID_PARAM;
1705
1706 if ((priv->config_descriptor == NULL) || (priv->config_descriptor[config_index] == NULL))
1707 return LIBUSB_ERROR_NOT_FOUND;
1708
1709 config_header = (PUSB_CONFIGURATION_DESCRIPTOR)priv->config_descriptor[config_index];
1710
1711 size = min(config_header->wTotalLength, len);
1712 memcpy(buffer, priv->config_descriptor[config_index], size);
1713
1714 return LIBUSB_SUCCESS;
1715}
1716
1717/*
1718 * return the cached copy of the active config descriptor
1719 */
1720static int windows_get_active_config_descriptor(struct libusb_device *dev, unsigned char *buffer, size_t len, int *host_endian)
1721{
1722 struct windows_device_priv *priv = __device_priv(dev);
1723
1724 if (priv->active_config == 0)
1725 return LIBUSB_ERROR_NOT_FOUND;
1726
1727 // config index is zero based
1728 return windows_get_config_descriptor(dev, (uint8_t)(priv->active_config-1), buffer, len, host_endian);
1729}
1730
1731static int windows_open(struct libusb_device_handle *dev_handle)
1732{
1733 struct windows_device_priv *priv = __device_priv(dev_handle->dev);
1734 struct libusb_context *ctx = DEVICE_CTX(dev_handle->dev);
1735
1736 if (priv->apib == NULL) {
1737 usbi_err(ctx, "program assertion failed - device is not initialized");
1738 return LIBUSB_ERROR_NO_DEVICE;
1739 }
1740
1741 return priv->apib->open(dev_handle);
1742}
1743
1744static void windows_close(struct libusb_device_handle *dev_handle)
1745{
1746 struct windows_device_priv *priv = __device_priv(dev_handle->dev);
1747
1748 priv->apib->close(dev_handle);
1749}
1750
1751static int windows_get_configuration(struct libusb_device_handle *dev_handle, int *config)
1752{
1753 struct windows_device_priv *priv = __device_priv(dev_handle->dev);
1754
1755 if (priv->active_config == 0) {
1756 *config = 0;
1757 return LIBUSB_ERROR_NOT_FOUND;
1758 }
1759
1760 *config = priv->active_config;
1761 return LIBUSB_SUCCESS;
1762}
1763
1764/*
1765 * from http://msdn.microsoft.com/en-us/library/ms793522.aspx: "The port driver
1766 * does not currently expose a service that allows higher-level drivers to set
1767 * the configuration."
1768 */
1769static int windows_set_configuration(struct libusb_device_handle *dev_handle, int config)
1770{
1771 struct windows_device_priv *priv = __device_priv(dev_handle->dev);
1772 int r = LIBUSB_SUCCESS;
1773
1774 if (config >= USB_MAXCONFIG)
1775 return LIBUSB_ERROR_INVALID_PARAM;
1776
1777 r = libusb_control_transfer(dev_handle, LIBUSB_ENDPOINT_OUT |
1778 LIBUSB_REQUEST_TYPE_STANDARD | LIBUSB_RECIPIENT_DEVICE,
1779 LIBUSB_REQUEST_SET_CONFIGURATION, (uint16_t)config,
1780 0, NULL, 0, 1000);
1781
1782 if (r == LIBUSB_SUCCESS) {
1783 priv->active_config = (uint8_t)config;
1784 }
1785 return r;
1786}
1787
1788static int windows_claim_interface(struct libusb_device_handle *dev_handle, int iface)
1789{
1790 int r = LIBUSB_SUCCESS;
1791 struct windows_device_priv *priv = __device_priv(dev_handle->dev);
1792
1793 if (iface >= USB_MAXINTERFACES)
1794 return LIBUSB_ERROR_INVALID_PARAM;
1795
1796 safe_free(priv->usb_interface[iface].endpoint);
1797 priv->usb_interface[iface].nb_endpoints= 0;
1798
1799 r = priv->apib->claim_interface(dev_handle, iface);
1800
1801 if (r == LIBUSB_SUCCESS) {
1802 r = windows_assign_endpoints(dev_handle->dev, iface, 0);
1803 }
1804
1805 return r;
1806}
1807
1808static int windows_set_interface_altsetting(struct libusb_device_handle *dev_handle, int iface, int altsetting)
1809{
1810 int r = LIBUSB_SUCCESS;
1811 struct windows_device_priv *priv = __device_priv(dev_handle->dev);
1812
1813 safe_free(priv->usb_interface[iface].endpoint);
1814 priv->usb_interface[iface].nb_endpoints= 0;
1815
1816 r = priv->apib->set_interface_altsetting(dev_handle, iface, altsetting);
1817
1818 if (r == LIBUSB_SUCCESS) {
1819 r = windows_assign_endpoints(dev_handle->dev, iface, altsetting);
1820 }
1821
1822 return r;
1823}
1824
1825static int windows_release_interface(struct libusb_device_handle *dev_handle, int iface)
1826{
1827 struct windows_device_priv *priv = __device_priv(dev_handle->dev);
1828
1829 windows_set_interface_altsetting(dev_handle, iface, 0);
1830 return priv->apib->release_interface(dev_handle, iface);
1831}
1832
1833static int windows_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint)
1834{
1835 struct windows_device_priv *priv = __device_priv(dev_handle->dev);
1836 return priv->apib->clear_halt(dev_handle, endpoint);
1837}
1838
1839static int windows_reset_device(struct libusb_device_handle *dev_handle)
1840{
1841 struct windows_device_priv *priv = __device_priv(dev_handle->dev);
1842 return priv->apib->reset_device(dev_handle);
1843}
1844
1845// The 3 functions below are unlikely to ever get supported on Windows
1846static int windows_kernel_driver_active(struct libusb_device_handle *dev_handle, int iface)
1847{
1848 return LIBUSB_ERROR_NOT_SUPPORTED;
1849}
1850
1851static int windows_attach_kernel_driver(struct libusb_device_handle *dev_handle, int iface)
1852{
1853 return LIBUSB_ERROR_NOT_SUPPORTED;
1854}
1855
1856static int windows_detach_kernel_driver(struct libusb_device_handle *dev_handle, int iface)
1857{
1858 return LIBUSB_ERROR_NOT_SUPPORTED;
1859}
1860
1861static void windows_destroy_device(struct libusb_device *dev)
1862{
1863 struct windows_device_priv *priv = __device_priv(dev);
1864 windows_device_priv_release(priv, dev->num_configurations);
1865}
1866
1867static void windows_clear_transfer_priv(struct usbi_transfer *itransfer)
1868{
1869 struct windows_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
1870
1871 usbi_free_fd(transfer_priv->pollable_fd.fd);
1872 safe_free(transfer_priv->hid_buffer);
1873#if defined(AUTO_CLAIM)
1874 // When auto claim is in use, attempt to release the auto-claimed interface
1875 auto_release(itransfer);
1876#endif
1877}
1878
1879static int submit_bulk_transfer(struct usbi_transfer *itransfer)
1880{
1881 struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1882 struct libusb_context *ctx = DEVICE_CTX(transfer->dev_handle->dev);
1883 struct windows_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
1884 struct windows_device_priv *priv = __device_priv(transfer->dev_handle->dev);
1885 int r;
1886
1887 r = priv->apib->submit_bulk_transfer(itransfer);
1888 if (r != LIBUSB_SUCCESS) {
1889 return r;
1890 }
1891
1892 usbi_add_pollfd(ctx, transfer_priv->pollable_fd.fd,
1893 (short)((transfer->endpoint & LIBUSB_ENDPOINT_IN)?POLLIN:POLLOUT));
1894#if !defined(DYNAMIC_FDS)
1895 usbi_fd_notification(ctx);
1896#endif
1897
1898 return LIBUSB_SUCCESS;
1899}
1900
1901static int submit_iso_transfer(struct usbi_transfer *itransfer)
1902{
1903 struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1904 struct libusb_context *ctx = DEVICE_CTX(transfer->dev_handle->dev);
1905 struct windows_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
1906 struct windows_device_priv *priv = __device_priv(transfer->dev_handle->dev);
1907 int r;
1908
1909 r = priv->apib->submit_iso_transfer(itransfer);
1910 if (r != LIBUSB_SUCCESS) {
1911 return r;
1912 }
1913
1914 usbi_add_pollfd(ctx, transfer_priv->pollable_fd.fd,
1915 (short)((transfer->endpoint & LIBUSB_ENDPOINT_IN)?POLLIN:POLLOUT));
1916#if !defined(DYNAMIC_FDS)
1917 usbi_fd_notification(ctx);
1918#endif
1919
1920 return LIBUSB_SUCCESS;
1921}
1922
1923static int submit_control_transfer(struct usbi_transfer *itransfer)
1924{
1925 struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1926 struct libusb_context *ctx = DEVICE_CTX(transfer->dev_handle->dev);
1927 struct windows_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
1928 struct windows_device_priv *priv = __device_priv(transfer->dev_handle->dev);
1929 int r;
1930
1931 r = priv->apib->submit_control_transfer(itransfer);
1932 if (r != LIBUSB_SUCCESS) {
1933 return r;
1934 }
1935
1936 usbi_add_pollfd(ctx, transfer_priv->pollable_fd.fd, POLLIN);
1937#if !defined(DYNAMIC_FDS)
1938 usbi_fd_notification(ctx);
1939#endif
1940
1941 return LIBUSB_SUCCESS;
1942
1943}
1944
1945static int windows_submit_transfer(struct usbi_transfer *itransfer)
1946{
1947 struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1948
1949 switch (transfer->type) {
1950 case LIBUSB_TRANSFER_TYPE_CONTROL:
1951 return submit_control_transfer(itransfer);
1952 case LIBUSB_TRANSFER_TYPE_BULK:
1953 case LIBUSB_TRANSFER_TYPE_INTERRUPT:
1954 return submit_bulk_transfer(itransfer);
1955 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
1956 return submit_iso_transfer(itransfer);
1957 default:
1958 usbi_err(TRANSFER_CTX(transfer), "unknown endpoint type %d", transfer->type);
1959 return LIBUSB_ERROR_INVALID_PARAM;
1960 }
1961}
1962
1963static int windows_abort_control(struct usbi_transfer *itransfer)
1964{
1965 struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1966 struct windows_device_priv *priv = __device_priv(transfer->dev_handle->dev);
1967
1968 return priv->apib->abort_control(itransfer);
1969}
1970
1971static int windows_abort_transfers(struct usbi_transfer *itransfer)
1972{
1973 struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1974 struct windows_device_priv *priv = __device_priv(transfer->dev_handle->dev);
1975
1976 return priv->apib->abort_transfers(itransfer);
1977}
1978
1979static int windows_cancel_transfer(struct usbi_transfer *itransfer)
1980{
1981 struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1982#if defined(FORCE_INSTANT_TIMEOUTS)
1983 struct windows_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
1984
1985 // Forces instant overlapped completion on timeouts - use at your own risks
1986 if (itransfer->flags & USBI_TRANSFER_TIMED_OUT) {
1987 transfer_priv->pollable_fd.overlapped->Internal &= ~STATUS_PENDING;
1988 }
1989#endif
1990 switch (transfer->type) {
1991 case LIBUSB_TRANSFER_TYPE_CONTROL:
1992 return windows_abort_control(itransfer);
1993 case LIBUSB_TRANSFER_TYPE_BULK:
1994 case LIBUSB_TRANSFER_TYPE_INTERRUPT:
1995 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
1996 return windows_abort_transfers(itransfer);
1997 default:
1998 usbi_err(ITRANSFER_CTX(itransfer), "unknown endpoint type %d", transfer->type);
1999 return LIBUSB_ERROR_INVALID_PARAM;
2000 }
2001}
2002
2003static void windows_transfer_callback(struct usbi_transfer *itransfer, uint32_t io_result, uint32_t io_size)
2004{
2005 struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2006 struct windows_device_priv *priv = __device_priv(transfer->dev_handle->dev);
2007 int status;
2008
2009 usbi_dbg("handling I/O completion with errcode %d", io_result);
2010
2011 switch(io_result) {
2012 case NO_ERROR:
2013 status = priv->apib->copy_transfer_data(itransfer, io_size);
2014 break;
2015 case ERROR_GEN_FAILURE:
2016 usbi_dbg("detected endpoint stall");
2017 status = LIBUSB_TRANSFER_STALL;
2018 break;
2019 case ERROR_SEM_TIMEOUT:
2020 usbi_dbg("detected semaphore timeout");
2021 status = LIBUSB_TRANSFER_TIMED_OUT;
2022 break;
2023 case ERROR_OPERATION_ABORTED:
2024 if (itransfer->flags & USBI_TRANSFER_TIMED_OUT) {
2025 usbi_dbg("detected timeout");
2026 status = LIBUSB_TRANSFER_TIMED_OUT;
2027 } else {
2028 usbi_dbg("detected operation aborted");
2029 status = LIBUSB_TRANSFER_CANCELLED;
2030 }
2031 break;
2032 default:
2033 usbi_err(ITRANSFER_CTX(itransfer), "detected I/O error: %s", windows_error_str(0));
2034 status = LIBUSB_TRANSFER_ERROR;
2035 break;
2036 }
2037 windows_clear_transfer_priv(itransfer); // Cancel polling
2038 usbi_handle_transfer_completion(itransfer, status);
2039}
2040
2041static void windows_handle_callback (struct usbi_transfer *itransfer, uint32_t io_result, uint32_t io_size)
2042{
2043 struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2044
2045 switch (transfer->type) {
2046 case LIBUSB_TRANSFER_TYPE_CONTROL:
2047 case LIBUSB_TRANSFER_TYPE_BULK:
2048 case LIBUSB_TRANSFER_TYPE_INTERRUPT:
2049 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
2050 windows_transfer_callback (itransfer, io_result, io_size);
2051 break;
2052 default:
2053 usbi_err(ITRANSFER_CTX(itransfer), "unknown endpoint type %d", transfer->type);
2054 }
2055}
2056
2057static int windows_handle_events(struct libusb_context *ctx, struct pollfd *fds, nfds_t nfds, int num_ready)
2058{
2059 struct windows_transfer_priv* transfer_priv = NULL;
2060 nfds_t i = 0;
2061 bool found = false;
2062 struct usbi_transfer *transfer;
2063 DWORD io_size, io_result;
2064
2065 usbi_mutex_lock(&ctx->open_devs_lock);
2066 for (i = 0; i < nfds && num_ready > 0; i++) {
2067
2068 usbi_dbg("checking fd %d with revents = %04x", fds[i].fd, fds[i].revents);
2069
2070 if (!fds[i].revents) {
2071 continue;
2072 }
2073
2074 num_ready--;
2075
2076 // Because a Windows OVERLAPPED is used for poll emulation,
2077 // a pollable fd is created and stored with each transfer
2078 usbi_mutex_lock(&ctx->flying_transfers_lock);
2079 list_for_each_entry(transfer, &ctx->flying_transfers, list, struct usbi_transfer) {
2080 transfer_priv = usbi_transfer_get_os_priv(transfer);
2081 if (transfer_priv->pollable_fd.fd == fds[i].fd) {
2082 found = true;
2083 break;
2084 }
2085 }
2086 usbi_mutex_unlock(&ctx->flying_transfers_lock);
2087
2088 if (found) {
2089 // Handle async requests that completed synchronously first
2090 if (HasOverlappedIoCompletedSync(transfer_priv->pollable_fd.overlapped)) {
2091 io_result = NO_ERROR;
2092 io_size = (DWORD)transfer_priv->pollable_fd.overlapped->InternalHigh;
2093 // Regular async overlapped
2094 } else if (GetOverlappedResult(transfer_priv->pollable_fd.handle,
2095 transfer_priv->pollable_fd.overlapped, &io_size, false)) {
2096 io_result = NO_ERROR;
2097 } else {
2098 io_result = GetLastError();
2099 }
2100 usbi_remove_pollfd(ctx, transfer_priv->pollable_fd.fd);
2101 // let handle_callback free the event using the transfer wfd
2102 // If you don't use the transfer wfd, you run a risk of trying to free a
2103 // newly allocated wfd that took the place of the one from the transfer.
2104 windows_handle_callback(transfer, io_result, io_size);
2105 } else {
2106 usbi_err(ctx, "could not find a matching transfer for fd %x", fds[i]);
2107 return LIBUSB_ERROR_NOT_FOUND;
2108 }
2109 }
2110
2111 usbi_mutex_unlock(&ctx->open_devs_lock);
2112 return LIBUSB_SUCCESS;
2113}
2114
2115/*
2116 * Monotonic and real time functions
2117 */
2118unsigned __stdcall windows_clock_gettime_threaded(void* param)
2119{
2120 LARGE_INTEGER hires_counter, li_frequency;
2121 LONG nb_responses;
2122 int timer_index;
2123
2124 // Init - find out if we have access to a monotonic (hires) timer
2125 if (!QueryPerformanceFrequency(&li_frequency)) {
2126 usbi_dbg("no hires timer available on this platform");
2127 hires_frequency = 0;
2128 hires_ticks_to_ps = UINT64_C(0);
2129 } else {
2130 hires_frequency = li_frequency.QuadPart;
2131 // The hires frequency can go as high as 4 GHz, so we'll use a conversion
2132 // to picoseconds to compute the tv_nsecs part in clock_gettime
2133 hires_ticks_to_ps = UINT64_C(1000000000000) / hires_frequency;
2134 usbi_dbg("hires timer available (Frequency: %"PRIu64" Hz)", hires_frequency);
2135 }
2136
2137 // Main loop - wait for requests
2138 while (1) {
2139 timer_index = WaitForMultipleObjects(2, timer_request, FALSE, INFINITE) - WAIT_OBJECT_0;
2140 if ( (timer_index != 0) && (timer_index != 1) ) {
2141 usbi_dbg("failure to wait on requests: %s", windows_error_str(0));
2142 continue;
2143 }
2144 if (request_count[timer_index] == 0) {
2145 // Request already handled
2146 ResetEvent(timer_request[timer_index]);
2147 // There's still a possiblity that a thread sends a request between the
2148 // time we test request_count[] == 0 and we reset the event, in which case
2149 // the request would be ignored. The simple solution to that is to test
2150 // request_count again and process requests if non zero.
2151 if (request_count[timer_index] == 0)
2152 continue;
2153 }
2154 switch (timer_index) {
2155 case 0:
2156 WaitForSingleObject(timer_mutex, INFINITE);
2157 // Requests to this thread are for hires always
2158 if (QueryPerformanceCounter(&hires_counter) != 0) {
2159 timer_tp.tv_sec = (long)(hires_counter.QuadPart / hires_frequency);
2160 timer_tp.tv_nsec = (long)(((hires_counter.QuadPart % hires_frequency)/1000) * hires_ticks_to_ps);
2161 } else {
2162 // Fallback to real-time if we can't get monotonic value
2163 // Note that real-time clock does not wait on the mutex or this thread.
2164 windows_clock_gettime(USBI_CLOCK_REALTIME, &timer_tp);
2165 }
2166 ReleaseMutex(timer_mutex);
2167
2168 nb_responses = InterlockedExchange((LONG*)&request_count[0], 0);
2169 if ( (nb_responses)
2170 && (ReleaseSemaphore(timer_response, nb_responses, NULL) == 0) ) {
2171 usbi_dbg("unable to release timer semaphore %d: %s", windows_error_str(0));
2172 }
2173 continue;
2174 case 1: // time to quit
2175 usbi_dbg("timer thread quitting");
2176 return 0;
2177 }
2178 }
2179 usbi_dbg("ERROR: broken timer thread");
2180 return 1;
2181}
2182
2183static int windows_clock_gettime(int clk_id, struct timespec *tp)
2184{
2185 FILETIME filetime;
2186 ULARGE_INTEGER rtime;
2187 DWORD r;
2188 switch(clk_id) {
2189 case USBI_CLOCK_MONOTONIC:
2190 if (hires_frequency != 0) {
2191 while (1) {
2192 InterlockedIncrement((LONG*)&request_count[0]);
2193 SetEvent(timer_request[0]);
2194 r = WaitForSingleObject(timer_response, TIMER_REQUEST_RETRY_MS);
2195 switch(r) {
2196 case WAIT_OBJECT_0:
2197 WaitForSingleObject(timer_mutex, INFINITE);
2198 *tp = timer_tp;
2199 ReleaseMutex(timer_mutex);
2200 return LIBUSB_SUCCESS;
2201 case WAIT_TIMEOUT:
2202 usbi_dbg("could not obtain a timer value within reasonable timeframe - too much load?");
2203 break; // Retry until successful
2204 default:
2205 usbi_dbg("WaitForSingleObject failed: %s", windows_error_str(0));
2206 return LIBUSB_ERROR_OTHER;
2207 }
2208 }
2209 }
2210 // Fall through and return real-time if monotonic was not detected @ timer init
2211 case USBI_CLOCK_REALTIME:
2212 // We follow http://msdn.microsoft.com/en-us/library/ms724928%28VS.85%29.aspx
2213 // with a predef epoch_time to have an epoch that starts at 1970.01.01 00:00
2214 // Note however that our resolution is bounded by the Windows system time
2215 // functions and is at best of the order of 1 ms (or, usually, worse)
2216 GetSystemTimeAsFileTime(&filetime);
2217 rtime.LowPart = filetime.dwLowDateTime;
2218 rtime.HighPart = filetime.dwHighDateTime;
2219 rtime.QuadPart -= epoch_time;
2220 tp->tv_sec = (long)(rtime.QuadPart / 10000000);
2221 tp->tv_nsec = (long)((rtime.QuadPart % 10000000)*100);
2222 return LIBUSB_SUCCESS;
2223 default:
2224 return LIBUSB_ERROR_INVALID_PARAM;
2225 }
2226}
2227
2228
2229// NB: MSVC6 does not support named initializers.
2230const struct usbi_os_backend windows_backend = {
2231 "Windows",
2232 windows_init,
2233 windows_exit,
2234
2235 windows_get_device_list,
2236 windows_open,
2237 windows_close,
2238
2239 windows_get_device_descriptor,
2240 windows_get_active_config_descriptor,
2241 windows_get_config_descriptor,
2242
2243 windows_get_configuration,
2244 windows_set_configuration,
2245 windows_claim_interface,
2246 windows_release_interface,
2247
2248 windows_set_interface_altsetting,
2249 windows_clear_halt,
2250 windows_reset_device,
2251
2252 windows_kernel_driver_active,
2253 windows_detach_kernel_driver,
2254 windows_attach_kernel_driver,
2255
2256 windows_destroy_device,
2257
2258 windows_submit_transfer,
2259 windows_cancel_transfer,
2260 windows_clear_transfer_priv,
2261
2262 windows_handle_events,
2263
2264 windows_clock_gettime,
2265#if defined(USBI_TIMERFD_AVAILABLE)
2266 NULL,
2267#endif
2268 sizeof(struct windows_device_priv),
2269 sizeof(struct windows_device_handle_priv),
2270 sizeof(struct windows_transfer_priv),
2271 0,
2272};
2273
2274
2275/*
2276 * USB API backends
2277 */
2278static int unsupported_init(struct libusb_context *ctx) {
2279 return LIBUSB_SUCCESS;
2280}
2281static int unsupported_exit(void) {
2282 return LIBUSB_SUCCESS;
2283}
2284static int unsupported_open(struct libusb_device_handle *dev_handle) {
2285 PRINT_UNSUPPORTED_API(open);
2286}
2287static void unsupported_close(struct libusb_device_handle *dev_handle) {
2288 usbi_dbg("unsupported API call for 'close'");
2289}
2290static int unsupported_claim_interface(struct libusb_device_handle *dev_handle, int iface) {
2291 PRINT_UNSUPPORTED_API(claim_interface);
2292}
2293static int unsupported_set_interface_altsetting(struct libusb_device_handle *dev_handle, int iface, int altsetting) {
2294 PRINT_UNSUPPORTED_API(set_interface_altsetting);
2295}
2296static int unsupported_release_interface(struct libusb_device_handle *dev_handle, int iface) {
2297 PRINT_UNSUPPORTED_API(release_interface);
2298}
2299static int unsupported_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint) {
2300 PRINT_UNSUPPORTED_API(clear_halt);
2301}
2302static int unsupported_reset_device(struct libusb_device_handle *dev_handle) {
2303 PRINT_UNSUPPORTED_API(reset_device);
2304}
2305static int unsupported_submit_bulk_transfer(struct usbi_transfer *itransfer) {
2306 PRINT_UNSUPPORTED_API(submit_bulk_transfer);
2307}
2308static int unsupported_submit_iso_transfer(struct usbi_transfer *itransfer) {
2309 PRINT_UNSUPPORTED_API(submit_iso_transfer);
2310}
2311static int unsupported_submit_control_transfer(struct usbi_transfer *itransfer) {
2312 PRINT_UNSUPPORTED_API(submit_control_transfer);
2313}
2314static int unsupported_abort_control(struct usbi_transfer *itransfer) {
2315 PRINT_UNSUPPORTED_API(abort_control);
2316}
2317static int unsupported_abort_transfers(struct usbi_transfer *itransfer) {
2318 PRINT_UNSUPPORTED_API(abort_transfers);
2319}
2320static int unsupported_copy_transfer_data(struct usbi_transfer *itransfer, uint32_t io_size) {
2321 PRINT_UNSUPPORTED_API(copy_transfer_data);
2322}
2323
2324// These names must be uppercase
2325const char* composite_driver_names[] = {"USBCCGP"};
2326const char* winusb_driver_names[] = {"WINUSB"};
2327const char* hid_driver_names[] = {"HIDUSB", "MOUHID", "KBDHID"};
2328const struct windows_usb_api_backend usb_api_backend[USB_API_MAX] = {
2329 {
2330 USB_API_UNSUPPORTED,
2331 "Unsupported API",
2332 &CLASS_GUID_UNSUPPORTED,
2333 NULL,
2334 0,
2335 unsupported_init,
2336 unsupported_exit,
2337 unsupported_open,
2338 unsupported_close,
2339 unsupported_claim_interface,
2340 unsupported_set_interface_altsetting,
2341 unsupported_release_interface,
2342 unsupported_clear_halt,
2343 unsupported_reset_device,
2344 unsupported_submit_bulk_transfer,
2345 unsupported_submit_iso_transfer,
2346 unsupported_submit_control_transfer,
2347 unsupported_abort_control,
2348 unsupported_abort_transfers,
2349 unsupported_copy_transfer_data,
2350 }, {
2351 USB_API_COMPOSITE,
2352 "Composite API",
2353 &CLASS_GUID_COMPOSITE,
2354 composite_driver_names,
2355 sizeof(composite_driver_names)/sizeof(composite_driver_names[0]),
2356 composite_init,
2357 composite_exit,
2358 composite_open,
2359 composite_close,
2360 composite_claim_interface,
2361 composite_set_interface_altsetting,
2362 composite_release_interface,
2363 composite_clear_halt,
2364 composite_reset_device,
2365 composite_submit_bulk_transfer,
2366 composite_submit_iso_transfer,
2367 composite_submit_control_transfer,
2368 composite_abort_control,
2369 composite_abort_transfers,
2370 composite_copy_transfer_data,
2371 }, {
2372 USB_API_WINUSB,
2373 "WinUSB API",
2374 &CLASS_GUID_LIBUSB_WINUSB,
2375 winusb_driver_names,
2376 sizeof(winusb_driver_names)/sizeof(winusb_driver_names[0]),
2377 winusb_init,
2378 winusb_exit,
2379 winusb_open,
2380 winusb_close,
2381 winusb_claim_interface,
2382 winusb_set_interface_altsetting,
2383 winusb_release_interface,
2384 winusb_clear_halt,
2385 winusb_reset_device,
2386 winusb_submit_bulk_transfer,
2387 unsupported_submit_iso_transfer,
2388 winusb_submit_control_transfer,
2389 winusb_abort_control,
2390 winusb_abort_transfers,
2391 winusb_copy_transfer_data,
2392 }, {
2393 USB_API_HID,
2394 "HID API",
2395 &CLASS_GUID_HID,
2396 hid_driver_names,
2397 sizeof(hid_driver_names)/sizeof(hid_driver_names[0]),
2398 hid_init,
2399 hid_exit,
2400 hid_open,
2401 hid_close,
2402 hid_claim_interface,
2403 hid_set_interface_altsetting,
2404 hid_release_interface,
2405 hid_clear_halt,
2406 hid_reset_device,
2407 hid_submit_bulk_transfer,
2408 unsupported_submit_iso_transfer,
2409 hid_submit_control_transfer,
2410 hid_abort_transfers,
2411 hid_abort_transfers,
2412 hid_copy_transfer_data,
2413 },
2414};
2415
2416
2417/*
2418 * WinUSB API functions
2419 */
2420static int winusb_init(struct libusb_context *ctx)
2421{
2422 DLL_LOAD(winusb.dll, WinUsb_Initialize, TRUE);
2423 DLL_LOAD(winusb.dll, WinUsb_Free, TRUE);
2424 DLL_LOAD(winusb.dll, WinUsb_GetAssociatedInterface, TRUE);
2425 DLL_LOAD(winusb.dll, WinUsb_GetDescriptor, TRUE);
2426 DLL_LOAD(winusb.dll, WinUsb_QueryInterfaceSettings, TRUE);
2427 DLL_LOAD(winusb.dll, WinUsb_QueryDeviceInformation, TRUE);
2428 DLL_LOAD(winusb.dll, WinUsb_SetCurrentAlternateSetting, TRUE);
2429 DLL_LOAD(winusb.dll, WinUsb_GetCurrentAlternateSetting, TRUE);
2430 DLL_LOAD(winusb.dll, WinUsb_QueryPipe, TRUE);
2431 DLL_LOAD(winusb.dll, WinUsb_SetPipePolicy, TRUE);
2432 DLL_LOAD(winusb.dll, WinUsb_GetPipePolicy, TRUE);
2433 DLL_LOAD(winusb.dll, WinUsb_ReadPipe, TRUE);
2434 DLL_LOAD(winusb.dll, WinUsb_WritePipe, TRUE);
2435 DLL_LOAD(winusb.dll, WinUsb_ControlTransfer, TRUE);
2436 DLL_LOAD(winusb.dll, WinUsb_ResetPipe, TRUE);
2437 DLL_LOAD(winusb.dll, WinUsb_AbortPipe, TRUE);
2438 DLL_LOAD(winusb.dll, WinUsb_FlushPipe, TRUE);
2439
2440 api_winusb_available = true;
2441 return LIBUSB_SUCCESS;
2442}
2443
2444static int winusb_exit(void)
2445{
2446 return LIBUSB_SUCCESS;
2447}
2448
2449// NB: open and close must ensure that they only handle interface of
2450// the right API type, as these functions can be called wholesale from
2451// composite_open(), with interfaces belonging to different APIs
2452static int winusb_open(struct libusb_device_handle *dev_handle)
2453{
2454 struct libusb_context *ctx = DEVICE_CTX(dev_handle->dev);
2455 struct windows_device_priv *priv = __device_priv(dev_handle->dev);
2456 struct windows_device_handle_priv *handle_priv = __device_handle_priv(dev_handle);
2457
2458 HANDLE file_handle;
2459 int i;
2460
2461 CHECK_WINUSB_AVAILABLE;
2462
2463 // WinUSB requires a seperate handle for each interface
2464 for (i = 0; i < USB_MAXINTERFACES; i++) {
2465 if ( (priv->usb_interface[i].path != NULL)
2466 && (priv->usb_interface[i].apib->id == USB_API_WINUSB) ) {
2467 file_handle = CreateFileA(priv->usb_interface[i].path, GENERIC_WRITE | GENERIC_READ, FILE_SHARE_WRITE | FILE_SHARE_READ,
2468 NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);
2469 if (file_handle == INVALID_HANDLE_VALUE) {
2470 usbi_err(ctx, "could not open device %s (interface %d): %s", priv->usb_interface[i].path, i, windows_error_str(0));
2471 switch(GetLastError()) {
2472 case ERROR_FILE_NOT_FOUND: // The device was disconnected
2473 return LIBUSB_ERROR_NO_DEVICE;
2474 case ERROR_ACCESS_DENIED:
2475 return LIBUSB_ERROR_ACCESS;
2476 default:
2477 return LIBUSB_ERROR_IO;
2478 }
2479 }
2480 handle_priv->interface_handle[i].dev_handle = file_handle;
2481 }
2482 }
2483
2484 return LIBUSB_SUCCESS;
2485}
2486
2487static void winusb_close(struct libusb_device_handle *dev_handle)
2488{
2489 struct windows_device_handle_priv *handle_priv = __device_handle_priv(dev_handle);
2490 struct windows_device_priv *priv = __device_priv(dev_handle->dev);
2491 HANDLE file_handle;
2492 int i;
2493
2494 if (!api_winusb_available)
2495 return;
2496
2497 for (i = 0; i < USB_MAXINTERFACES; i++) {
2498 if (priv->usb_interface[i].apib->id == USB_API_WINUSB) {
2499 file_handle = handle_priv->interface_handle[i].dev_handle;
2500 if ( (file_handle != 0) && (file_handle != INVALID_HANDLE_VALUE)) {
2501 CloseHandle(file_handle);
2502 }
2503 }
2504 }
2505}
2506
2507static int winusb_claim_interface(struct libusb_device_handle *dev_handle, int iface)
2508{
2509 struct libusb_context *ctx = DEVICE_CTX(dev_handle->dev);
2510 struct windows_device_handle_priv *handle_priv = __device_handle_priv(dev_handle);
2511 struct windows_device_priv *priv = __device_priv(dev_handle->dev);
2512 bool is_composite = (priv->apib->id == USB_API_COMPOSITE);
2513 HANDLE file_handle, winusb_handle;
2514 USB_INTERFACE_DESCRIPTOR if_desc;
2515 UCHAR policy;
2516 uint8_t endpoint_address;
2517 int i;
2518
2519 CHECK_WINUSB_AVAILABLE;
2520
2521 // interfaces for composite devices are always independent, therefore
2522 // "alt" interfaces are only found on non-composite
2523 if ((!is_composite) && (iface != 0)) {
2524 winusb_handle = handle_priv->interface_handle[0].api_handle;
2525 // It is a requirement on Windows that to claim an interface >= 1
2526 // on a non-composite WinUSB device, you must first have claimed interface 0
2527 if ((winusb_handle == 0) || (winusb_handle == INVALID_HANDLE_VALUE)) {
2528#if defined(AUTO_CLAIM)
2529 file_handle = handle_priv->interface_handle[0].dev_handle;
2530 if (WinUsb_Initialize(file_handle, &winusb_handle)) {
2531 handle_priv->interface_handle[0].api_handle = winusb_handle;
2532 usbi_warn(ctx, "auto-claimed interface 0 (required to claim %d with WinUSB)", iface);
2533 } else {
2534 usbi_warn(ctx, "failed to auto-claim interface 0 (required to claim %d with WinUSB)", iface);
2535 return LIBUSB_ERROR_ACCESS;
2536 }
2537#else
2538 usbi_warn(ctx, "you must claim interface 0 before you can claim %d with WinUSB", iface);
2539 return LIBUSB_ERROR_ACCESS;
2540#endif
2541 }
2542 if (!WinUsb_GetAssociatedInterface(winusb_handle, (UCHAR)(iface-1),
2543 &handle_priv->interface_handle[iface].api_handle)) {
2544 handle_priv->interface_handle[iface].api_handle = INVALID_HANDLE_VALUE;
2545 switch(GetLastError()) {
2546 case ERROR_NO_MORE_ITEMS: // invalid iface
2547 return LIBUSB_ERROR_NOT_FOUND;
2548 case ERROR_BAD_COMMAND: // The device was disconnected
2549 return LIBUSB_ERROR_NO_DEVICE;
2550 case ERROR_ALREADY_EXISTS: // already claimed
2551 return LIBUSB_ERROR_BUSY;
2552 default:
2553 usbi_err(ctx, "could not claim interface %d: %s", iface, windows_error_str(0));
2554 return LIBUSB_ERROR_ACCESS;
2555 }
2556 }
2557 } else {
2558 // composite device (independent interfaces) or interface 0
2559 winusb_handle = handle_priv->interface_handle[iface].api_handle;
2560 file_handle = handle_priv->interface_handle[iface].dev_handle;
2561 if ((file_handle == 0) || (file_handle == INVALID_HANDLE_VALUE)) {
2562 return LIBUSB_ERROR_NOT_FOUND;
2563 }
2564
2565 if (!WinUsb_Initialize(file_handle, &winusb_handle)) {
2566 usbi_err(ctx, "could not access interface %d: %s", iface, windows_error_str(0));
2567 handle_priv->interface_handle[iface].api_handle = INVALID_HANDLE_VALUE;
2568
2569 switch(GetLastError()) {
2570 case ERROR_BAD_COMMAND: // The device was disconnected
2571 return LIBUSB_ERROR_NO_DEVICE;
2572 default:
2573 usbi_err(ctx, "could not claim interface %d: %s", iface, windows_error_str(0));
2574 return LIBUSB_ERROR_ACCESS;
2575 }
2576 }
2577 handle_priv->interface_handle[iface].api_handle = winusb_handle;
2578 }
2579 if (!WinUsb_QueryInterfaceSettings(winusb_handle, 0, &if_desc)) {
2580 usbi_err(ctx, "could not query interface settings for interface %d: %s", iface, windows_error_str(0));
2581 } else if (if_desc.bInterfaceNumber != iface) {
2582 usbi_warn(ctx, "program assertion failed - WinUSB interface %d found at position %d",
2583 if_desc.bInterfaceNumber, iface);
2584 }
2585
2586 usbi_dbg("claimed interface %d", iface);
2587 handle_priv->active_interface = iface;
2588
2589 // With handle and enpoints set (in parent), we can setup the default
2590 // pipe properties (copied from libusb-win32-v1)
2591 // see http://download.microsoft.com/download/D/1/D/D1DD7745-426B-4CC3-A269-ABBBE427C0EF/DVC-T705_DDC08.pptx
2592 for (i=0; i<priv->usb_interface[iface].nb_endpoints; i++) {
2593 endpoint_address = priv->usb_interface[iface].endpoint[i];
2594 policy = false;
2595 if (!WinUsb_SetPipePolicy(winusb_handle, endpoint_address,
2596 SHORT_PACKET_TERMINATE, sizeof(UCHAR), &policy)) {
2597 usbi_dbg("failed to disable SHORT_PACKET_TERMINATE for endpoint %02X", endpoint_address);
2598 }
2599 if (!WinUsb_SetPipePolicy(winusb_handle, endpoint_address,
2600 IGNORE_SHORT_PACKETS, sizeof(UCHAR), &policy)) {
2601 usbi_dbg("failed to disable IGNORE_SHORT_PACKETS for endpoint %02X", endpoint_address);
2602 }
2603 if (!WinUsb_SetPipePolicy(winusb_handle, endpoint_address,
2604 ALLOW_PARTIAL_READS, sizeof(UCHAR), &policy)) {
2605 usbi_dbg("failed to disable ALLOW_PARTIAL_READS for endpoint %02X", endpoint_address);
2606 }
2607 policy = true;
2608 if (!WinUsb_SetPipePolicy(winusb_handle, endpoint_address,
2609 AUTO_CLEAR_STALL, sizeof(UCHAR), &policy)) {
2610 usbi_dbg("failed to enable AUTO_CLEAR_STALL for endpoint %02X", endpoint_address);
2611 }
2612 }
2613
2614 return LIBUSB_SUCCESS;
2615}
2616
2617static int winusb_release_interface(struct libusb_device_handle *dev_handle, int iface)
2618{
2619 struct windows_device_handle_priv *handle_priv = __device_handle_priv(dev_handle);
2620 HANDLE winusb_handle;
2621
2622 CHECK_WINUSB_AVAILABLE;
2623
2624 winusb_handle = handle_priv->interface_handle[iface].api_handle;
2625 if ((winusb_handle == 0) || (winusb_handle == INVALID_HANDLE_VALUE)) {
2626 return LIBUSB_ERROR_NOT_FOUND;
2627 }
2628
2629 WinUsb_Free(winusb_handle);
2630 handle_priv->interface_handle[iface].api_handle = INVALID_HANDLE_VALUE;
2631
2632 return LIBUSB_SUCCESS;
2633}
2634
2635/*
2636 * Return the first valid interface (of the same API type), for control transfers
2637 */
2638static int get_valid_interface(struct libusb_device_handle *dev_handle, int api_id)
2639{
2640 struct windows_device_handle_priv *handle_priv = __device_handle_priv(dev_handle);
2641 struct windows_device_priv *priv = __device_priv(dev_handle->dev);
2642 int i;
2643
2644 if ((api_id < USB_API_WINUSB) || (api_id > USB_API_HID)) {
2645 usbi_dbg("unsupported API ID");
2646 return -1;
2647 }
2648
2649 for (i=0; i<USB_MAXINTERFACES; i++) {
2650 if ( (handle_priv->interface_handle[i].dev_handle != 0)
2651 && (handle_priv->interface_handle[i].dev_handle != INVALID_HANDLE_VALUE)
2652 && (handle_priv->interface_handle[i].api_handle != 0)
2653 && (handle_priv->interface_handle[i].api_handle != INVALID_HANDLE_VALUE)
2654 && (priv->usb_interface[i].apib == &usb_api_backend[api_id]) ) {
2655 return i;
2656 }
2657 }
2658 return -1;
2659}
2660
2661/*
2662 * Lookup interface by endpoint address. -1 if not found
2663 */
2664static int interface_by_endpoint(struct windows_device_priv *priv,
2665 struct windows_device_handle_priv *handle_priv, uint8_t endpoint_address)
2666{
2667 int i, j;
2668 for (i=0; i<USB_MAXINTERFACES; i++) {
2669 if (handle_priv->interface_handle[i].api_handle == INVALID_HANDLE_VALUE)
2670 continue;
2671 if (handle_priv->interface_handle[i].api_handle == 0)
2672 continue;
2673 if (priv->usb_interface[i].endpoint == NULL)
2674 continue;
2675 for (j=0; j<priv->usb_interface[i].nb_endpoints; j++) {
2676 if (priv->usb_interface[i].endpoint[j] == endpoint_address) {
2677 return i;
2678 }
2679 }
2680 }
2681 return -1;
2682}
2683
2684static int winusb_submit_control_transfer(struct usbi_transfer *itransfer)
2685{
2686 struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2687 struct libusb_context *ctx = DEVICE_CTX(transfer->dev_handle->dev);
2688 struct windows_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
2689 struct windows_device_handle_priv *handle_priv = __device_handle_priv(
2690 transfer->dev_handle);
2691 WINUSB_SETUP_PACKET *setup = (WINUSB_SETUP_PACKET *) transfer->buffer;
2692 ULONG size;
2693 HANDLE winusb_handle;
2694 int current_interface;
2695 struct winfd wfd;
2696
2697 CHECK_WINUSB_AVAILABLE;
2698
2699 transfer_priv->pollable_fd = INVALID_WINFD;
2700 size = transfer->length - LIBUSB_CONTROL_SETUP_SIZE;
2701
2702 if (size > MAX_CTRL_BUFFER_LENGTH)
2703 return LIBUSB_ERROR_INVALID_PARAM;
2704
2705 current_interface = get_valid_interface(transfer->dev_handle, USB_API_WINUSB);
2706 if (current_interface < 0) {
2707#if defined(AUTO_CLAIM)
2708 if (auto_claim(transfer, &current_interface, USB_API_WINUSB) != LIBUSB_SUCCESS) {
2709 return LIBUSB_ERROR_NOT_FOUND;
2710 }
2711#else
2712 usbi_warn(ctx, "no interface available for control transfer");
2713 return LIBUSB_ERROR_NOT_FOUND;
2714#endif
2715 }
2716
2717 usbi_dbg("will use interface %d", current_interface);
2718 winusb_handle = handle_priv->interface_handle[current_interface].api_handle;
2719
2720 wfd = usbi_create_fd(winusb_handle, _O_RDONLY);
2721 // Always use the handle returned from usbi_create_fd (wfd.handle)
2722 if (wfd.fd < 0) {
2723 return LIBUSB_ERROR_NO_MEM;
2724 }
2725
2726 if (!WinUsb_ControlTransfer(wfd.handle, *setup, transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE, size, NULL, wfd.overlapped)) {
2727 if(GetLastError() != ERROR_IO_PENDING) {
2728 usbi_err(ctx, "WinUsb_ControlTransfer failed: %s", windows_error_str(0));
2729 usbi_free_fd(wfd.fd);
2730 return LIBUSB_ERROR_IO;
2731 }
2732 } else {
2733 wfd.overlapped->Internal = STATUS_COMPLETED_SYNCHRONOUSLY;
2734 wfd.overlapped->InternalHigh = (DWORD)size;
2735 }
2736
2737 // Use priv_transfer to store data needed for async polling
2738 transfer_priv->pollable_fd = wfd;
2739 transfer_priv->interface_number = (uint8_t)current_interface;
2740
2741 return LIBUSB_SUCCESS;
2742}
2743
2744static int winusb_set_interface_altsetting(struct libusb_device_handle *dev_handle, int iface, int altsetting)
2745{
2746 struct libusb_context *ctx = DEVICE_CTX(dev_handle->dev);
2747 struct windows_device_handle_priv *handle_priv = __device_handle_priv(dev_handle);
2748 HANDLE winusb_handle;
2749
2750 CHECK_WINUSB_AVAILABLE;
2751
2752 if (altsetting > 255) {
2753 return LIBUSB_ERROR_INVALID_PARAM;
2754 }
2755
2756 winusb_handle = handle_priv->interface_handle[iface].api_handle;
2757 if ((winusb_handle == 0) || (winusb_handle == INVALID_HANDLE_VALUE)) {
2758 usbi_err(ctx, "interface must be claimed first");
2759 return LIBUSB_ERROR_NOT_FOUND;
2760 }
2761
2762 if (!WinUsb_SetCurrentAlternateSetting(winusb_handle, (UCHAR)altsetting)) {
2763 usbi_err(ctx, "WinUsb_SetCurrentAlternateSetting failed: %s", windows_error_str(0));
2764 return LIBUSB_ERROR_IO;
2765 }
2766
2767 return LIBUSB_SUCCESS;
2768}
2769
2770static int winusb_submit_bulk_transfer(struct usbi_transfer *itransfer)
2771{
2772 struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2773 struct libusb_context *ctx = DEVICE_CTX(transfer->dev_handle->dev);
2774 struct windows_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
2775 struct windows_device_handle_priv *handle_priv = __device_handle_priv(transfer->dev_handle);
2776 struct windows_device_priv *priv = __device_priv(transfer->dev_handle->dev);
2777 HANDLE winusb_handle;
2778 bool direction_in, ret;
2779 int current_interface;
2780 struct winfd wfd;
2781
2782 CHECK_WINUSB_AVAILABLE;
2783
2784 transfer_priv->pollable_fd = INVALID_WINFD;
2785
2786 current_interface = interface_by_endpoint(priv, handle_priv, transfer->endpoint);
2787 if (current_interface < 0) {
2788 usbi_err(ctx, "unable to match endpoint to an open interface - cancelling transfer");
2789 return LIBUSB_ERROR_NOT_FOUND;
2790 }
2791
2792 usbi_dbg("matched endpoint %02X with interface %d", transfer->endpoint, current_interface);
2793
2794 winusb_handle = handle_priv->interface_handle[current_interface].api_handle;
2795 direction_in = transfer->endpoint & LIBUSB_ENDPOINT_IN;
2796
2797 wfd = usbi_create_fd(winusb_handle, direction_in?_O_RDONLY:_O_WRONLY);
2798 // Always use the handle returned from usbi_create_fd (wfd.handle)
2799 if (wfd.fd < 0) {
2800 return LIBUSB_ERROR_NO_MEM;
2801 }
2802
2803 if (direction_in) {
2804 usbi_dbg("reading %d bytes", transfer->length);
2805 ret = WinUsb_ReadPipe(wfd.handle, transfer->endpoint, transfer->buffer, transfer->length, NULL, wfd.overlapped);
2806 } else {
2807 usbi_dbg("writing %d bytes", transfer->length);
2808 ret = WinUsb_WritePipe(wfd.handle, transfer->endpoint, transfer->buffer, transfer->length, NULL, wfd.overlapped);
2809 }
2810 if (!ret) {
2811 if(GetLastError() != ERROR_IO_PENDING) {
2812 usbi_err(ctx, "WinUsb_Pipe Transfer failed: %s", windows_error_str(0));
2813 usbi_free_fd(wfd.fd);
2814 return LIBUSB_ERROR_IO;
2815 }
2816 } else {
2817 wfd.overlapped->Internal = STATUS_COMPLETED_SYNCHRONOUSLY;
2818 wfd.overlapped->InternalHigh = (DWORD)transfer->length;
2819 }
2820
2821 transfer_priv->pollable_fd = wfd;
2822 transfer_priv->interface_number = (uint8_t)current_interface;
2823
2824 return LIBUSB_SUCCESS;
2825}
2826
2827static int winusb_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint)
2828{
2829 struct libusb_context *ctx = DEVICE_CTX(dev_handle->dev);
2830 struct windows_device_handle_priv *handle_priv = __device_handle_priv(dev_handle);
2831 struct windows_device_priv *priv = __device_priv(dev_handle->dev);
2832 HANDLE winusb_handle;
2833 int current_interface;
2834
2835 CHECK_WINUSB_AVAILABLE;
2836
2837 current_interface = interface_by_endpoint(priv, handle_priv, endpoint);
2838 if (current_interface < 0) {
2839 usbi_err(ctx, "unable to match endpoint to an open interface - cannot clear");
2840 return LIBUSB_ERROR_NOT_FOUND;
2841 }
2842
2843 usbi_dbg("matched endpoint %02X with interface %d", endpoint, current_interface);
2844 winusb_handle = handle_priv->interface_handle[current_interface].api_handle;
2845
2846 if (!WinUsb_ResetPipe(winusb_handle, endpoint)) {
2847 usbi_err(ctx, "WinUsb_ResetPipe failed: %s", windows_error_str(0));
2848 return LIBUSB_ERROR_NO_DEVICE;
2849 }
2850
2851 return LIBUSB_SUCCESS;
2852}
2853
2854/*
2855 * from http://www.winvistatips.com/winusb-bugchecks-t335323.html (confirmed
2856 * through testing as well):
2857 * "You can not call WinUsb_AbortPipe on control pipe. You can possibly cancel
2858 * the control transfer using CancelIo"
2859 */
2860static int winusb_abort_control(struct usbi_transfer *itransfer)
2861{
2862 // Cancelling of the I/O is done in the parent
2863 return LIBUSB_SUCCESS;
2864}
2865
2866static int winusb_abort_transfers(struct usbi_transfer *itransfer)
2867{
2868 struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2869 struct libusb_context *ctx = DEVICE_CTX(transfer->dev_handle->dev);
2870 struct windows_device_handle_priv *handle_priv = __device_handle_priv(transfer->dev_handle);
2871 struct windows_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
2872 HANDLE winusb_handle;
2873 int current_interface;
2874
2875 CHECK_WINUSB_AVAILABLE;
2876
2877 current_interface = transfer_priv->interface_number;
2878 if ((current_interface < 0) || (current_interface >= USB_MAXINTERFACES)) {
2879 usbi_err(ctx, "program assertion failed: invalid interface_number");
2880 return LIBUSB_ERROR_NOT_FOUND;
2881 }
2882 usbi_dbg("will use interface %d", current_interface);
2883
2884 winusb_handle = handle_priv->interface_handle[current_interface].api_handle;
2885
2886 if (!WinUsb_AbortPipe(winusb_handle, transfer->endpoint)) {
2887 usbi_err(ctx, "WinUsb_AbortPipe failed: %s", windows_error_str(0));
2888 return LIBUSB_ERROR_NO_DEVICE;
2889 }
2890
2891 return LIBUSB_SUCCESS;
2892}
2893
2894/*
2895 * from the "How to Use WinUSB to Communicate with a USB Device" Microsoft white paper
2896 * (http://www.microsoft.com/whdc/connect/usb/winusb_howto.mspx):
2897 * "WinUSB does not support host-initiated reset port and cycle port operations" and
2898 * IOCTL_INTERNAL_USB_CYCLE_PORT is only available in kernel mode and the
2899 * IOCTL_USB_HUB_CYCLE_PORT ioctl was removed from Vista => the best we can do is
2900 * cycle the pipes (and even then, the control pipe can not be reset using WinUSB)
2901 */
2902// TODO (2nd official release): see if we can force eject the device and redetect it (reuse hotplug?)
2903static int winusb_reset_device(struct libusb_device_handle *dev_handle)
2904{
2905 struct libusb_context *ctx = DEVICE_CTX(dev_handle->dev);
2906 struct windows_device_handle_priv *handle_priv = __device_handle_priv(dev_handle);
2907 struct windows_device_priv *priv = __device_priv(dev_handle->dev);
2908 struct winfd wfd;
2909 HANDLE winusb_handle;
2910 int i, j;
2911
2912 CHECK_WINUSB_AVAILABLE;
2913
2914 // Reset any available pipe (except control)
2915 for (i=0; i<USB_MAXINTERFACES; i++) {
2916 winusb_handle = handle_priv->interface_handle[i].api_handle;
2917 for (wfd = handle_to_winfd(winusb_handle); wfd.fd > 0;)
2918 {
2919 // Cancel any pollable I/O
2920 usbi_remove_pollfd(ctx, wfd.fd);
2921 usbi_free_fd(wfd.fd);
2922 wfd = handle_to_winfd(winusb_handle);
2923 }
2924
2925 if ( (winusb_handle != 0) && (winusb_handle != INVALID_HANDLE_VALUE)) {
2926 for (j=0; j<priv->usb_interface[i].nb_endpoints; j++) {
2927 usbi_dbg("resetting ep %02X", priv->usb_interface[i].endpoint[j]);
2928 if (!WinUsb_AbortPipe(winusb_handle, priv->usb_interface[i].endpoint[j])) {
2929 usbi_err(ctx, "WinUsb_AbortPipe (pipe address %02X) failed: %s",
2930 priv->usb_interface[i].endpoint[j], windows_error_str(0));
2931 }
2932 // FlushPipe seems to fail on OUT pipes
2933 if ( (priv->usb_interface[i].endpoint[j] & LIBUSB_ENDPOINT_IN)
2934 && (!WinUsb_FlushPipe(winusb_handle, priv->usb_interface[i].endpoint[j])) ) {
2935 usbi_err(ctx, "WinUsb_FlushPipe (pipe address %02X) failed: %s",
2936 priv->usb_interface[i].endpoint[j], windows_error_str(0));
2937 }
2938 if (!WinUsb_ResetPipe(winusb_handle, priv->usb_interface[i].endpoint[j])) {
2939 usbi_err(ctx, "WinUsb_ResetPipe (pipe address %02X) failed: %s",
2940 priv->usb_interface[i].endpoint[j], windows_error_str(0));
2941 }
2942 }
2943 }
2944 }
2945
2946 return LIBUSB_SUCCESS;
2947}
2948
2949static int winusb_copy_transfer_data(struct usbi_transfer *itransfer, uint32_t io_size)
2950{
2951 itransfer->transferred += io_size;
2952 return LIBUSB_TRANSFER_COMPLETED;
2953}
2954
2955/*
2956 * Internal HID Support functions (from libusb-win32)
2957 * Note that functions that complete data transfer synchronously must return
2958 * LIBUSB_COMPLETED instead of LIBUSB_SUCCESS
2959 */
2960static int _hid_get_hid_descriptor(struct hid_device_priv* dev, void *data, size_t *size);
2961static int _hid_get_report_descriptor(struct hid_device_priv* dev, void *data, size_t *size);
2962
2963static int _hid_wcslen(WCHAR *str)
2964{
2965 int i = 0;
2966 while (str[i] && (str[i] != 0x409)) {
2967 i++;
2968 }
2969 return i;
2970}
2971
2972static int _hid_get_device_descriptor(struct hid_device_priv* dev, void *data, size_t *size)
2973{
2974 struct libusb_device_descriptor d;
2975
2976 d.bLength = LIBUSB_DT_DEVICE_SIZE;
2977 d.bDescriptorType = LIBUSB_DT_DEVICE;
2978 d.bcdUSB = 0x0200; /* 2.00 */
2979 d.bDeviceClass = 0;
2980 d.bDeviceSubClass = 0;
2981 d.bDeviceProtocol = 0;
2982 d.bMaxPacketSize0 = 64; /* fix this! */
2983 d.idVendor = (uint16_t)dev->vid;
2984 d.idProduct = (uint16_t)dev->pid;
2985 d.bcdDevice = 0x0100;
2986 d.iManufacturer = dev->string_index[0];
2987 d.iProduct = dev->string_index[1];
2988 d.iSerialNumber = dev->string_index[2];
2989 d.bNumConfigurations = 1;
2990
2991 if (*size > LIBUSB_DT_DEVICE_SIZE)
2992 *size = LIBUSB_DT_DEVICE_SIZE;
2993 memcpy(data, &d, *size);
2994 return LIBUSB_COMPLETED;
2995}
2996
2997static int _hid_get_config_descriptor(struct hid_device_priv* dev, void *data, size_t *size)
2998{
2999 char num_endpoints = 0;
3000 size_t config_total_len = 0;
3001 char tmp[HID_MAX_CONFIG_DESC_SIZE];
3002 struct libusb_config_descriptor *cd;
3003 struct libusb_interface_descriptor *id;
3004 struct libusb_hid_descriptor *hd;
3005 struct libusb_endpoint_descriptor *ed;
3006 size_t tmp_size;
3007
3008 if (dev->input_report_size)
3009 num_endpoints++;
3010 if (dev->output_report_size)
3011 num_endpoints++;
3012
3013 config_total_len = LIBUSB_DT_CONFIG_SIZE + LIBUSB_DT_INTERFACE_SIZE
3014 + LIBUSB_DT_HID_SIZE + num_endpoints * LIBUSB_DT_ENDPOINT_SIZE;
3015
3016
3017 cd = (struct libusb_config_descriptor *)tmp;
3018 id = (struct libusb_interface_descriptor *)(tmp + LIBUSB_DT_CONFIG_SIZE);
3019 hd = (struct libusb_hid_descriptor *)(tmp + LIBUSB_DT_CONFIG_SIZE
3020 + LIBUSB_DT_INTERFACE_SIZE);
3021 ed = (struct libusb_endpoint_descriptor *)(tmp + LIBUSB_DT_CONFIG_SIZE
3022 + LIBUSB_DT_INTERFACE_SIZE
3023 + LIBUSB_DT_HID_SIZE);
3024
3025 cd->bLength = LIBUSB_DT_CONFIG_SIZE;
3026 cd->bDescriptorType = LIBUSB_DT_CONFIG;
3027 cd->wTotalLength = (uint16_t) config_total_len;
3028 cd->bNumInterfaces = 1;
3029 cd->bConfigurationValue = 1;
3030 cd->iConfiguration = 0;
3031 cd->bmAttributes = 1 << 7; /* bus powered */
3032 cd->MaxPower = 50;
3033
3034 id->bLength = LIBUSB_DT_INTERFACE_SIZE;
3035 id->bDescriptorType = LIBUSB_DT_INTERFACE;
3036 id->bInterfaceNumber = 0;
3037 id->bAlternateSetting = 0;
3038 id->bNumEndpoints = num_endpoints;
3039 id->bInterfaceClass = 3;
3040 id->bInterfaceSubClass = 0;
3041 id->bInterfaceProtocol = 0;
3042 id->iInterface = 0;
3043
3044 tmp_size = LIBUSB_DT_HID_SIZE;
3045 _hid_get_hid_descriptor(dev, hd, &tmp_size);
3046
3047 if (dev->input_report_size) {
3048 ed->bLength = LIBUSB_DT_ENDPOINT_SIZE;
3049 ed->bDescriptorType = LIBUSB_DT_ENDPOINT;
3050 ed->bEndpointAddress = HID_IN_EP;
3051 ed->bmAttributes = 3;
3052 ed->wMaxPacketSize = dev->input_report_size - 1;
3053 ed->bInterval = 10;
3054
3055 ed++;
3056 }
3057
3058 if (dev->output_report_size) {
3059 ed->bLength = LIBUSB_DT_ENDPOINT_SIZE;
3060 ed->bDescriptorType = LIBUSB_DT_ENDPOINT;
3061 ed->bEndpointAddress = HID_OUT_EP;
3062 ed->bmAttributes = 3;
3063 ed->wMaxPacketSize = dev->output_report_size - 1;
3064 ed->bInterval = 10;
3065 }
3066
3067 if (*size > config_total_len)
3068 *size = config_total_len;
3069 memcpy(data, tmp, *size);
3070 return LIBUSB_COMPLETED;
3071}
3072
3073static int _hid_get_string_descriptor(struct hid_device_priv* dev, int index,
3074 void *data, size_t *size)
3075{
3076 void *tmp = NULL;
3077 size_t tmp_size = 0;
3078 int i;
3079
3080 /* language ID, EN-US */
3081 char string_langid[] = {
3082 0x09,
3083 0x04
3084 };
3085
3086 if ((*size < 2) || (*size > 255)) {
3087 return LIBUSB_ERROR_OVERFLOW;
3088 }
3089
3090 if (index == 0) {
3091 tmp = string_langid;
3092 tmp_size = sizeof(string_langid)+2;
3093 } else {
3094 for (i=0; i<3; i++) {
3095 if (index == (dev->string_index[i])) {
3096 tmp = dev->string[i];
3097 tmp_size = (_hid_wcslen(dev->string[i])+1) * sizeof(WCHAR);
3098 break;
3099 }
3100 }
3101 if (i == 3) { // not found
3102 return LIBUSB_ERROR_INVALID_PARAM;
3103 }
3104 }
3105
3106 if(!tmp_size) {
3107 return LIBUSB_ERROR_INVALID_PARAM;
3108 }
3109
3110 if (tmp_size < *size) {
3111 *size = tmp_size;
3112 }
3113 // 2 byte header
3114 ((uint8_t*)data)[0] = (uint8_t)*size;
3115 ((uint8_t*)data)[1] = LIBUSB_DT_STRING;
3116 memcpy((uint8_t*)data+2, tmp, *size-2);
3117 return LIBUSB_COMPLETED;
3118}
3119
3120static int _hid_get_hid_descriptor(struct hid_device_priv* dev, void *data, size_t *size)
3121{
3122 struct libusb_hid_descriptor d;
3123 uint8_t tmp[MAX_HID_DESCRIPTOR_SIZE];
3124 size_t report_len = MAX_HID_DESCRIPTOR_SIZE;
3125
3126 _hid_get_report_descriptor(dev, tmp, &report_len);
3127
3128 d.bLength = LIBUSB_DT_HID_SIZE;
3129 d.bDescriptorType = LIBUSB_DT_HID;
3130 d.bcdHID = 0x0110; /* 1.10 */
3131 d.bCountryCode = 0;
3132 d.bNumDescriptors = 1;
3133 d.bClassDescriptorType = LIBUSB_DT_REPORT;
3134 d.wClassDescriptorLength = (uint16_t)report_len;
3135
3136 if (*size > LIBUSB_DT_HID_SIZE)
3137 *size = LIBUSB_DT_HID_SIZE;
3138 memcpy(data, &d, *size);
3139 return LIBUSB_COMPLETED;
3140}
3141
3142static int _hid_get_report_descriptor(struct hid_device_priv* dev, void *data, size_t *size)
3143{
3144 uint8_t d[MAX_HID_DESCRIPTOR_SIZE];
3145 size_t i = 0;
3146
3147 /* usage page (0xFFA0 == vendor defined) */
3148 d[i++] = 0x06; d[i++] = 0xA0; d[i++] = 0xFF;
3149 /* usage (vendor defined) */
3150 d[i++] = 0x09; d[i++] = 0x01;
3151 /* start collection (application) */
3152 d[i++] = 0xA1; d[i++] = 0x01;
3153 /* input report */
3154 if (dev->input_report_size) {
3155 /* usage (vendor defined) */
3156 d[i++] = 0x09; d[i++] = 0x01;
3157 /* logical minimum (0) */
3158 d[i++] = 0x15; d[i++] = 0x00;
3159 /* logical maximum (255) */
3160 d[i++] = 0x25; d[i++] = 0xFF;
3161 /* report size (8 bits) */
3162 d[i++] = 0x75; d[i++] = 0x08;
3163 /* report count */
3164 d[i++] = 0x95; d[i++] = (uint8_t)dev->input_report_size - 1;
3165 /* input (data, variable, absolute) */
3166 d[i++] = 0x81; d[i++] = 0x00;
3167 }
3168 /* output report */
3169 if (dev->output_report_size) {
3170 /* usage (vendor defined) */
3171 d[i++] = 0x09; d[i++] = 0x02;
3172 /* logical minimum (0) */
3173 d[i++] = 0x15; d[i++] = 0x00;
3174 /* logical maximum (255) */
3175 d[i++] = 0x25; d[i++] = 0xFF;
3176 /* report size (8 bits) */
3177 d[i++] = 0x75; d[i++] = 0x08;
3178 /* report count */
3179 d[i++] = 0x95; d[i++] = (uint8_t)dev->output_report_size - 1;
3180 /* output (data, variable, absolute) */
3181 d[i++] = 0x91; d[i++] = 0x00;
3182 }
3183 /* feature report */
3184 if (dev->feature_report_size) {
3185 /* usage (vendor defined) */
3186 d[i++] = 0x09; d[i++] = 0x03;
3187 /* logical minimum (0) */
3188 d[i++] = 0x15; d[i++] = 0x00;
3189 /* logical maximum (255) */
3190 d[i++] = 0x25; d[i++] = 0xFF;
3191 /* report size (8 bits) */
3192 d[i++] = 0x75; d[i++] = 0x08;
3193 /* report count */
3194 d[i++] = 0x95; d[i++] = (uint8_t)dev->feature_report_size - 1;
3195 /* feature (data, variable, absolute) */
3196 d[i++] = 0xb2; d[i++] = 0x02; d[i++] = 0x01;
3197 }
3198
3199 /* end collection */
3200 d[i++] = 0xC0;
3201
3202 if (*size > i)
3203 *size = i;
3204 memcpy(data, d, *size);
3205 return LIBUSB_COMPLETED;
3206}
3207
3208static int _hid_get_descriptor(struct hid_device_priv* dev, HANDLE hid_handle, int recipient,
3209 int type, int index, void *data, size_t *size)
3210{
3211 switch(type) {
3212 case LIBUSB_DT_DEVICE:
3213 usbi_dbg("LIBUSB_DT_DEVICE");
3214 return _hid_get_device_descriptor(dev, data, size);
3215 case LIBUSB_DT_CONFIG:
3216 usbi_dbg("LIBUSB_DT_CONFIG");
3217 if (!index)
3218 return _hid_get_config_descriptor(dev, data, size);
3219 return LIBUSB_ERROR_INVALID_PARAM;
3220 case LIBUSB_DT_STRING:
3221 usbi_dbg("LIBUSB_DT_STRING");
3222 return _hid_get_string_descriptor(dev, index, data, size);
3223 case LIBUSB_DT_HID:
3224 usbi_dbg("LIBUSB_DT_HID");
3225 if (!index)
3226 return _hid_get_hid_descriptor(dev, data, size);
3227 return LIBUSB_ERROR_INVALID_PARAM;
3228 case LIBUSB_DT_REPORT:
3229 usbi_dbg("LIBUSB_DT_REPORT");
3230 if (!index)
3231 return _hid_get_report_descriptor(dev, data, size);
3232 return LIBUSB_ERROR_INVALID_PARAM;
3233 case LIBUSB_DT_PHYSICAL:
3234 usbi_dbg("LIBUSB_DT_PHYSICAL");
3235 if (HidD_GetPhysicalDescriptor(hid_handle, data, (ULONG)*size))
3236 return LIBUSB_COMPLETED;
3237 return LIBUSB_ERROR_OTHER;
3238 }
3239 usbi_dbg("unsupported");
3240 return LIBUSB_ERROR_INVALID_PARAM;
3241}
3242
3243static int _hid_get_report(struct hid_device_priv* dev, HANDLE hid_handle, int id, void *data,
3244 struct windows_transfer_priv *tp, size_t *size, OVERLAPPED* overlapped,
3245 int report_type)
3246{
3247 uint8_t *buf;
3248 DWORD ioctl_code, read_size, expected_size = (DWORD)*size;
3249 int r = LIBUSB_SUCCESS;
3250
3251 if (tp->hid_buffer != NULL) {
3252 usbi_dbg("program assertion failed: hid_buffer is not NULL");
3253 }
3254
3255 if ((*size == 0) || (*size > MAX_HID_REPORT_SIZE)) {
3256 usbi_dbg("invalid size (%d)", *size);
3257 return LIBUSB_ERROR_INVALID_PARAM;
3258 }
3259
3260 switch (report_type) {
3261 case HID_REPORT_TYPE_INPUT:
3262 ioctl_code = IOCTL_HID_GET_INPUT_REPORT;
3263 break;
3264 case HID_REPORT_TYPE_FEATURE:
3265 ioctl_code = IOCTL_HID_GET_FEATURE;
3266 break;
3267 default:
3268 usbi_dbg("unknown HID report type %d", report_type);
3269 return LIBUSB_ERROR_INVALID_PARAM;
3270 }
3271
3272 // When report IDs are not in use, add an extra byte for the report ID
3273 if (id==0) {
3274 expected_size++;
3275 }
3276
3277 // Add a trailing byte to detect overflows
3278 buf = (uint8_t*)calloc(expected_size+1, 1);
3279 if (buf == NULL) {
3280 return LIBUSB_ERROR_NO_MEM;
3281 }
3282 buf[0] = (uint8_t)id; // Must be set always
3283 usbi_dbg("report ID: 0x%02X", buf[0]);
3284
3285 tp->hid_expected_size = expected_size;
3286
3287 if (!DeviceIoControl(hid_handle, ioctl_code, buf, expected_size+1,
3288 buf, expected_size+1, &read_size, overlapped)) {
3289 if (GetLastError() != ERROR_IO_PENDING) {
3290 usbi_dbg("Failed to Read HID Report: %s", windows_error_str(0));
3291 safe_free(buf);
3292 return LIBUSB_ERROR_IO;
3293 }
3294 // Asynchronous wait
3295 tp->hid_buffer = buf;
3296 tp->hid_dest = data; // copy dest, as not necessarily the start of the transfer buffer
3297 return LIBUSB_SUCCESS;
3298 }
3299
3300 // Transfer completed synchronously => copy and discard extra buffer
3301 if (read_size == 0) {
3302 usbi_dbg("program assertion failed - read completed synchronously, but no data was read");
3303 *size = 0;
3304 } else {
3305 if (buf[0] != id) {
3306 usbi_warn(NULL, "mismatched report ID (data is %02X, parameter is %02X)", buf[0], id);
3307 }
3308 if ((size_t)read_size > expected_size) {
3309 r = LIBUSB_ERROR_OVERFLOW;
3310 usbi_dbg("OVERFLOW!");
3311 } else {
3312 r = LIBUSB_COMPLETED;
3313 }
3314
3315 if (id == 0) {
3316 // Discard report ID
3317 *size = MIN((size_t)read_size-1, *size);
3318 memcpy(data, buf+1, *size);
3319 } else {
3320 *size = MIN((size_t)read_size, *size);
3321 memcpy(data, buf, *size);
3322 }
3323 }
3324 safe_free(buf);
3325 return r;
3326}
3327
3328static int _hid_set_report(struct hid_device_priv* dev, HANDLE hid_handle, int id, void *data,
3329 struct windows_transfer_priv *tp, size_t *size, OVERLAPPED* overlapped,
3330 int report_type)
3331{
3332 uint8_t *buf = NULL;
3333 DWORD ioctl_code, write_size= (DWORD)*size;
3334
3335 if (tp->hid_buffer != NULL) {
3336 usbi_dbg("program assertion failed: hid_buffer is not NULL");
3337 }
3338
3339 if ((*size == 0) || (*size > MAX_HID_REPORT_SIZE)) {
3340 usbi_dbg("invalid size (%d)", *size);
3341 return LIBUSB_ERROR_INVALID_PARAM;
3342 }
3343
3344 switch (report_type) {
3345 case HID_REPORT_TYPE_OUTPUT:
3346 ioctl_code = IOCTL_HID_SET_OUTPUT_REPORT;
3347 break;
3348 case HID_REPORT_TYPE_FEATURE:
3349 ioctl_code = IOCTL_HID_SET_FEATURE;
3350 break;
3351 default:
3352 usbi_dbg("unknown HID report type %d", report_type);
3353 return LIBUSB_ERROR_INVALID_PARAM;
3354 }
3355
3356 usbi_dbg("report ID: 0x%02X", id);
3357 // When report IDs are not used (i.e. when id == 0), we must add
3358 // a null report ID. Otherwise, we just use original data buffer
3359 if (id == 0) {
3360 write_size++;
3361 }
3362 buf = malloc(write_size);
3363 if (buf == NULL) {
3364 return LIBUSB_ERROR_NO_MEM;
3365 }
3366 if (id == 0) {
3367 buf[0] = 0;
3368 memcpy(buf + 1, data, *size);
3369 } else {
3370 // This seems like a waste, but if we don't duplicate the
3371 // data, we'll get issues when freeing hid_buffer
3372 memcpy(buf, data, *size);
3373 if (buf[0] != id) {
3374 usbi_warn(NULL, "mismatched report ID (data is %02X, parameter is %02X)", buf[0], id);
3375 }
3376 }
3377
3378 if (!DeviceIoControl(hid_handle, ioctl_code, buf, write_size,
3379 buf, write_size, &write_size, overlapped)) {
3380 if (GetLastError() != ERROR_IO_PENDING) {
3381 usbi_dbg("Failed to Write HID Output Report: %s", windows_error_str(0));
3382 safe_free(buf);
3383 return LIBUSB_ERROR_IO;
3384 }
3385 tp->hid_buffer = buf;
3386 tp->hid_dest = NULL;
3387 return LIBUSB_SUCCESS;
3388 }
3389
3390 // Transfer completed synchronously
3391 if (write_size == 0) {
3392 usbi_dbg("program assertion failed - write completed synchronously, but no data was written");
3393 *size = 0;
3394 } else {
3395 *size = write_size - ((id == 0)?1:0);
3396 }
3397 safe_free(buf);
3398 return LIBUSB_COMPLETED;
3399}
3400
3401static int _hid_class_request(struct hid_device_priv* dev, HANDLE hid_handle, int request_type,
3402 int request, int value, int index, void *data, struct windows_transfer_priv *tp,
3403 size_t *size, OVERLAPPED* overlapped)
3404{
3405 int report_type = (value >> 8) & 0xFF;
3406 int report_id = value & 0xFF;
3407
3408 if ( (LIBUSB_REQ_RECIPIENT(request_type) != LIBUSB_RECIPIENT_INTERFACE)
3409 && (LIBUSB_REQ_RECIPIENT(request_type) != LIBUSB_RECIPIENT_DEVICE) )
3410 return LIBUSB_ERROR_INVALID_PARAM;
3411
3412 if (LIBUSB_REQ_OUT(request_type) && request == HID_REQ_SET_REPORT)
3413 return _hid_set_report(dev, hid_handle, report_id, data, tp, size, overlapped, report_type);
3414
3415 if (LIBUSB_REQ_IN(request_type) && request == HID_REQ_GET_REPORT)
3416 return _hid_get_report(dev, hid_handle, report_id, data, tp, size, overlapped, report_type);
3417
3418 return LIBUSB_ERROR_INVALID_PARAM;
3419}
3420
3421
3422/*
3423 * HID API functions
3424 */
3425static int hid_init(struct libusb_context *ctx)
3426{
3427 DLL_LOAD(hid.dll, HidD_GetAttributes, TRUE);
3428 DLL_LOAD(hid.dll, HidD_GetHidGuid, TRUE);
3429 DLL_LOAD(hid.dll, HidD_GetPreparsedData, TRUE);
3430 DLL_LOAD(hid.dll, HidD_FreePreparsedData, TRUE);
3431 DLL_LOAD(hid.dll, HidD_GetManufacturerString, TRUE);
3432 DLL_LOAD(hid.dll, HidD_GetProductString, TRUE);
3433 DLL_LOAD(hid.dll, HidD_GetSerialNumberString, TRUE);
3434 DLL_LOAD(hid.dll, HidP_GetCaps, TRUE);
3435 DLL_LOAD(hid.dll, HidD_SetNumInputBuffers, TRUE);
3436 DLL_LOAD(hid.dll, HidD_SetFeature, TRUE);
3437 DLL_LOAD(hid.dll, HidD_GetFeature, TRUE);
3438 DLL_LOAD(hid.dll, HidD_GetPhysicalDescriptor, TRUE);
3439 DLL_LOAD(hid.dll, HidD_GetInputReport, FALSE);
3440 DLL_LOAD(hid.dll, HidD_SetOutputReport, FALSE);
3441 DLL_LOAD(hid.dll, HidD_FlushQueue, TRUE);
3442 DLL_LOAD(hid.dll, HidP_GetValueCaps, TRUE);
3443
3444 api_hid_available = true;
3445 return LIBUSB_SUCCESS;
3446}
3447
3448static int hid_exit(void)
3449{
3450 return LIBUSB_SUCCESS;
3451}
3452
3453// NB: open and close must ensure that they only handle interface of
3454// the right API type, as these functions can be called wholesale from
3455// composite_open(), with interfaces belonging to different APIs
3456static int hid_open(struct libusb_device_handle *dev_handle)
3457{
3458 struct libusb_context *ctx = DEVICE_CTX(dev_handle->dev);
3459 struct windows_device_priv *priv = __device_priv(dev_handle->dev);
3460 struct windows_device_handle_priv *handle_priv = __device_handle_priv(dev_handle);
3461
3462 HIDD_ATTRIBUTES hid_attributes;
3463 PHIDP_PREPARSED_DATA preparsed_data = NULL;
3464 HIDP_CAPS capabilities;
3465 HIDP_VALUE_CAPS *value_caps;
3466
3467 HANDLE hid_handle = INVALID_HANDLE_VALUE;
3468 int i, j;
3469 // report IDs handling
3470 ULONG size[3];
3471 char* type[3] = {"input", "output", "feature"};
3472 int nb_ids[2]; // zero and nonzero report IDs
3473
3474 CHECK_HID_AVAILABLE;
3475 if (priv->hid == NULL) {
3476 usbi_err(ctx, "program assertion failed - private HID structure is unitialized");
3477 return LIBUSB_ERROR_NOT_FOUND;
3478 }
3479
3480 for (i = 0; i < USB_MAXINTERFACES; i++) {
3481 if ( (priv->usb_interface[i].path != NULL)
3482 && (priv->usb_interface[i].apib->id == USB_API_HID) ) {
3483 hid_handle = CreateFileA(priv->usb_interface[i].path, GENERIC_WRITE | GENERIC_READ, FILE_SHARE_WRITE | FILE_SHARE_READ,
3484 NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);
3485 /*
3486 * http://www.lvr.com/hidfaq.htm: Why do I receive "Access denied" when attempting to access my HID?
3487 * "Windows 2000 and later have exclusive read/write access to HIDs that are configured as a system
3488 * keyboards or mice. An application can obtain a handle to a system keyboard or mouse by not
3489 * requesting READ or WRITE access with CreateFile. Applications can then use HidD_SetFeature and
3490 * HidD_GetFeature (if the device supports Feature reports)."
3491 */
3492 if (hid_handle == INVALID_HANDLE_VALUE) {
3493 usbi_warn(ctx, "could not open HID device in R/W mode (keyboard or mouse?) - trying without");
3494 hid_handle = CreateFileA(priv->usb_interface[i].path, 0, FILE_SHARE_WRITE | FILE_SHARE_READ,
3495 NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);
3496 if (hid_handle == INVALID_HANDLE_VALUE) {
3497 usbi_err(ctx, "could not open device %s (interface %d): %s", priv->path, i, windows_error_str(0));
3498 switch(GetLastError()) {
3499 case ERROR_FILE_NOT_FOUND: // The device was disconnected
3500 return LIBUSB_ERROR_NO_DEVICE;
3501 case ERROR_ACCESS_DENIED:
3502 return LIBUSB_ERROR_ACCESS;
3503 default:
3504 return LIBUSB_ERROR_IO;
3505 }
3506 }
3507 priv->usb_interface[i].restricted_functionality = true;
3508 }
3509 handle_priv->interface_handle[i].api_handle = hid_handle;
3510 }
3511 }
3512
3513 hid_attributes.Size = sizeof(hid_attributes);
3514 do {
3515 if (!HidD_GetAttributes(hid_handle, &hid_attributes)) {
3516 usbi_err(ctx, "could not gain access to HID top collection (HidD_GetAttributes)");
3517 break;
3518 }
3519
3520 priv->hid->vid = hid_attributes.VendorID;
3521 priv->hid->pid = hid_attributes.ProductID;
3522
3523 // Set the maximum available input buffer size
3524 for (i=32; HidD_SetNumInputBuffers(hid_handle, i); i*=2);
3525 usbi_dbg("set maximum input buffer size to %d", i/2);
3526
3527 // Get the maximum input and output report size
3528 if (!HidD_GetPreparsedData(hid_handle, &preparsed_data) || !preparsed_data) {
3529 usbi_err(ctx, "could not read HID preparsed data (HidD_GetPreparsedData)");
3530 break;
3531 }
3532 if (HidP_GetCaps(preparsed_data, &capabilities) != HIDP_STATUS_SUCCESS) {
3533 usbi_err(ctx, "could not parse HID capabilities (HidP_GetCaps)");
3534 break;
3535 }
3536
3537 // Find out if interrupt will need report IDs
3538 size[0] = capabilities.NumberInputValueCaps;
3539 size[1] = capabilities.NumberOutputValueCaps;
3540 size[2] = capabilities.NumberFeatureValueCaps;
3541 for (j=0; j<3; j++) {
3542 usbi_dbg("%d HID %s report value(s) found", size[j], type[j]);
3543 priv->hid->uses_report_ids[j] = false;
3544 if (size[j] > 0) {
3545 value_caps = malloc(size[j] * sizeof(HIDP_VALUE_CAPS));
3546 if ( (value_caps != NULL)
3547 && (HidP_GetValueCaps(j, value_caps, &size[j], preparsed_data) == HIDP_STATUS_SUCCESS)
3548 && (size[j] >= 1) ) {
3549 nb_ids[0] = 0;
3550 nb_ids[1] = 0;
3551 for (i=0; i<(int)size[j]; i++) {
3552 usbi_dbg(" Report ID: 0x%02X", value_caps[i].ReportID);
3553 if (value_caps[i].ReportID != 0) {
3554 nb_ids[1]++;
3555 } else {
3556 nb_ids[0]++;
3557 }
3558 }
3559 if (nb_ids[1] != 0) {
3560 if (nb_ids[0] != 0) {
3561 usbi_warn(ctx, "program assertion failed: zero and nonzero report IDs used for %s",
3562 type[j]);
3563 }
3564 priv->hid->uses_report_ids[j] = true;
3565 }
3566 } else {
3567 usbi_warn(ctx, " could not process %s report IDs", type[j]);
3568 }
3569 safe_free(value_caps);
3570 }
3571 }
3572
3573 // Set the report sizes
3574 priv->hid->input_report_size = capabilities.InputReportByteLength;
3575 priv->hid->output_report_size = capabilities.OutputReportByteLength;
3576 priv->hid->feature_report_size = capabilities.FeatureReportByteLength;
3577
3578 // Fetch string descriptors
3579 priv->hid->string_index[0] = priv->dev_descriptor.iManufacturer;
3580 if (priv->hid->string_index[0] != 0) {
3581 HidD_GetManufacturerString(hid_handle, priv->hid->string[0],
3582 sizeof(priv->hid->string[0]));
3583 } else {
3584 priv->hid->string[0][0] = 0;
3585 }
3586 priv->hid->string_index[1] = priv->dev_descriptor.iProduct;
3587 if (priv->hid->string_index[1] != 0) {
3588 HidD_GetProductString(hid_handle, priv->hid->string[1],
3589 sizeof(priv->hid->string[1]));
3590 } else {
3591 priv->hid->string[1][0] = 0;
3592 }
3593 priv->hid->string_index[2] = priv->dev_descriptor.iSerialNumber;
3594 if (priv->hid->string_index[2] != 0) {
3595 HidD_GetSerialNumberString(hid_handle, priv->hid->string[2],
3596 sizeof(priv->hid->string[2]));
3597 } else {
3598 priv->hid->string[2][0] = 0;
3599 }
3600 } while(0);
3601
3602 if (preparsed_data) {
3603 HidD_FreePreparsedData(preparsed_data);
3604 }
3605
3606 return LIBUSB_SUCCESS;
3607}
3608
3609static void hid_close(struct libusb_device_handle *dev_handle)
3610{
3611 struct windows_device_priv *priv = __device_priv(dev_handle->dev);
3612 struct windows_device_handle_priv *handle_priv = __device_handle_priv(dev_handle);
3613 HANDLE file_handle;
3614 int i;
3615
3616 if (!api_hid_available)
3617 return;
3618
3619 for (i = 0; i < USB_MAXINTERFACES; i++) {
3620 if (priv->usb_interface[i].apib->id == USB_API_HID) {
3621 file_handle = handle_priv->interface_handle[i].api_handle;
3622 if ( (file_handle != 0) && (file_handle != INVALID_HANDLE_VALUE)) {
3623 CloseHandle(file_handle);
3624 }
3625 }
3626 }
3627}
3628
3629static int hid_claim_interface(struct libusb_device_handle *dev_handle, int iface)
3630{
3631 struct windows_device_handle_priv *handle_priv = __device_handle_priv(dev_handle);
3632 struct windows_device_priv *priv = __device_priv(dev_handle->dev);
3633
3634 CHECK_HID_AVAILABLE;
3635
3636 // NB: Disconnection detection is not possible in this function
3637 if (priv->usb_interface[iface].path == NULL) {
3638 return LIBUSB_ERROR_NOT_FOUND; // invalid iface
3639 }
3640
3641 // We use dev_handle as a flag for interface claimed
3642 if (handle_priv->interface_handle[iface].dev_handle == INTERFACE_CLAIMED) {
3643 return LIBUSB_ERROR_BUSY; // already claimed
3644 }
3645
3646 handle_priv->interface_handle[iface].dev_handle = INTERFACE_CLAIMED;
3647
3648 usbi_dbg("claimed interface %d", iface);
3649 handle_priv->active_interface = iface;
3650
3651 return LIBUSB_SUCCESS;
3652}
3653
3654static int hid_release_interface(struct libusb_device_handle *dev_handle, int iface)
3655{
3656 struct windows_device_handle_priv *handle_priv = __device_handle_priv(dev_handle);
3657 struct windows_device_priv *priv = __device_priv(dev_handle->dev);
3658
3659 CHECK_HID_AVAILABLE;
3660
3661 if (priv->usb_interface[iface].path == NULL) {
3662 return LIBUSB_ERROR_NOT_FOUND; // invalid iface
3663 }
3664
3665 if (handle_priv->interface_handle[iface].dev_handle != INTERFACE_CLAIMED) {
3666 return LIBUSB_ERROR_NOT_FOUND; // invalid iface
3667 }
3668
3669 handle_priv->interface_handle[iface].dev_handle = INVALID_HANDLE_VALUE;
3670
3671 return LIBUSB_SUCCESS;
3672}
3673
3674static int hid_set_interface_altsetting(struct libusb_device_handle *dev_handle, int iface, int altsetting)
3675{
3676 struct libusb_context *ctx = DEVICE_CTX(dev_handle->dev);
3677
3678 CHECK_HID_AVAILABLE;
3679
3680 if (altsetting > 255) {
3681 return LIBUSB_ERROR_INVALID_PARAM;
3682 }
3683
3684 if (altsetting != 0) {
3685 usbi_err(ctx, "set interface altsetting not supported for altsetting >0");
3686 return LIBUSB_ERROR_NOT_SUPPORTED;
3687 }
3688
3689 return LIBUSB_SUCCESS;
3690}
3691
3692static int hid_submit_control_transfer(struct usbi_transfer *itransfer)
3693{
3694 struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
3695 struct windows_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
3696 struct windows_device_handle_priv *handle_priv = __device_handle_priv(transfer->dev_handle);
3697 struct windows_device_priv *priv = __device_priv(transfer->dev_handle->dev);
3698 struct libusb_context *ctx = DEVICE_CTX(transfer->dev_handle->dev);
3699 WINUSB_SETUP_PACKET *setup = (WINUSB_SETUP_PACKET *) transfer->buffer;
3700 HANDLE hid_handle;
3701 struct winfd wfd;
3702 int current_interface, config;
3703 size_t size;
3704 int r = LIBUSB_ERROR_INVALID_PARAM;
3705
3706 CHECK_HID_AVAILABLE;
3707
3708 transfer_priv->pollable_fd = INVALID_WINFD;
3709 safe_free(transfer_priv->hid_buffer);
3710 transfer_priv->hid_dest = NULL;
3711 size = transfer->length - LIBUSB_CONTROL_SETUP_SIZE;
3712
3713 if (size > MAX_CTRL_BUFFER_LENGTH) {
3714 return LIBUSB_ERROR_INVALID_PARAM;
3715 }
3716
3717 current_interface = get_valid_interface(transfer->dev_handle, USB_API_HID);
3718 if (current_interface < 0) {
3719#if defined(AUTO_CLAIM)
3720 if (auto_claim(transfer, &current_interface, USB_API_HID) != LIBUSB_SUCCESS) {
3721 return LIBUSB_ERROR_NOT_FOUND;
3722 }
3723#else
3724 usbi_warn(ctx, "no interface available for control transfer");
3725 return LIBUSB_ERROR_NOT_FOUND;
3726#endif
3727 }
3728
3729 usbi_dbg("will use interface %d", current_interface);
3730 hid_handle = handle_priv->interface_handle[current_interface].api_handle;
3731 // Always use the handle returned from usbi_create_fd (wfd.handle)
3732 wfd = usbi_create_fd(hid_handle, _O_RDONLY);
3733 if (wfd.fd < 0) {
3734 return LIBUSB_ERROR_NO_MEM;
3735 }
3736
3737 switch(LIBUSB_REQ_TYPE(setup->request_type)) {
3738 case LIBUSB_REQUEST_TYPE_STANDARD:
3739 switch(setup->request) {
3740 case LIBUSB_REQUEST_GET_DESCRIPTOR:
3741 r = _hid_get_descriptor(priv->hid, wfd.handle, LIBUSB_REQ_RECIPIENT(setup->request_type),
3742 (setup->value >> 8) & 0xFF, setup->value & 0xFF, transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE, &size);
3743 break;
3744 case LIBUSB_REQUEST_GET_CONFIGURATION:
3745 r = windows_get_configuration(transfer->dev_handle, &config);
3746 if (r == LIBUSB_SUCCESS) {
3747 size = 1;
3748 ((uint8_t*)transfer->buffer)[LIBUSB_CONTROL_SETUP_SIZE] = (uint8_t)config;
3749 r = LIBUSB_COMPLETED;
3750 }
3751 break;
3752 case LIBUSB_REQUEST_SET_CONFIGURATION:
3753 if (setup->value == priv->active_config) {
3754 r = LIBUSB_COMPLETED;
3755 } else {
3756 usbi_warn(ctx, "cannot set configuration other than the default one");
3757 r = LIBUSB_ERROR_INVALID_PARAM;
3758 }
3759 break;
3760 case LIBUSB_REQUEST_GET_INTERFACE:
3761 size = 1;
3762 ((uint8_t*)transfer->buffer)[LIBUSB_CONTROL_SETUP_SIZE] = 0;
3763 r = LIBUSB_COMPLETED;
3764 break;
3765 case LIBUSB_REQUEST_SET_INTERFACE:
3766 r = hid_set_interface_altsetting(transfer->dev_handle, setup->index, setup->value);
3767 if (r == LIBUSB_SUCCESS) {
3768 r = LIBUSB_COMPLETED;
3769 }
3770 break;
3771 default:
3772 usbi_warn(ctx, "unsupported HID control request");
3773 r = LIBUSB_ERROR_INVALID_PARAM;
3774 break;
3775 }
3776 break;
3777 case LIBUSB_REQUEST_TYPE_CLASS:
3778 r =_hid_class_request(priv->hid, wfd.handle, setup->request_type, setup->request, setup->value,
3779 setup->index, transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE, transfer_priv,
3780 &size, wfd.overlapped);
3781 break;
3782 default:
3783 usbi_warn(ctx, "unsupported HID control request");
3784 r = LIBUSB_ERROR_INVALID_PARAM;
3785 break;
3786 }
3787
3788 if (r == LIBUSB_COMPLETED) {
3789 // Force request to be completed synchronously. Transferred size has been set by previous call
3790 wfd.overlapped->Internal = STATUS_COMPLETED_SYNCHRONOUSLY;
3791 // http://msdn.microsoft.com/en-us/library/ms684342%28VS.85%29.aspx
3792 // set InternalHigh to the number of bytes transferred
3793 wfd.overlapped->InternalHigh = (DWORD)size;
3794 r = LIBUSB_SUCCESS;
3795 }
3796
3797 if (r == LIBUSB_SUCCESS) {
3798 // Use priv_transfer to store data needed for async polling
3799 transfer_priv->pollable_fd = wfd;
3800 transfer_priv->interface_number = (uint8_t)current_interface;
3801 } else {
3802 usbi_free_fd(wfd.fd);
3803 }
3804
3805 return r;
3806}
3807
3808static int hid_submit_bulk_transfer(struct usbi_transfer *itransfer) {
3809 struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
3810 struct windows_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
3811 struct libusb_context *ctx = DEVICE_CTX(transfer->dev_handle->dev);
3812 struct windows_device_handle_priv *handle_priv = __device_handle_priv(transfer->dev_handle);
3813 struct windows_device_priv *priv = __device_priv(transfer->dev_handle->dev);
3814 struct winfd wfd;
3815 HANDLE hid_handle;
3816 bool direction_in, ret;
3817 int current_interface, length;
3818 DWORD size;
3819 int r = LIBUSB_SUCCESS;
3820
3821 CHECK_HID_AVAILABLE;
3822
3823 transfer_priv->pollable_fd = INVALID_WINFD;
3824 transfer_priv->hid_dest = NULL;
3825 safe_free(transfer_priv->hid_buffer);
3826
3827 current_interface = interface_by_endpoint(priv, handle_priv, transfer->endpoint);
3828 if (current_interface < 0) {
3829 usbi_err(ctx, "unable to match endpoint to an open interface - cancelling transfer");
3830 return LIBUSB_ERROR_NOT_FOUND;
3831 }
3832
3833 usbi_dbg("matched endpoint %02X with interface %d", transfer->endpoint, current_interface);
3834
3835 hid_handle = handle_priv->interface_handle[current_interface].api_handle;
3836 direction_in = transfer->endpoint & LIBUSB_ENDPOINT_IN;
3837
3838 wfd = usbi_create_fd(hid_handle, direction_in?_O_RDONLY:_O_WRONLY);
3839 // Always use the handle returned from usbi_create_fd (wfd.handle)
3840 if (wfd.fd < 0) {
3841 return LIBUSB_ERROR_NO_MEM;
3842 }
3843
3844 // If report IDs are not in use, an extra prefix byte must be added
3845 if ( ((direction_in) && (!priv->hid->uses_report_ids[0]))
3846 || ((!direction_in) && (!priv->hid->uses_report_ids[1])) ) {
3847 length = transfer->length+1;
3848 } else {
3849 length = transfer->length;
3850 }
3851 // Add a trailing byte to detect overflows on input
3852 transfer_priv->hid_buffer = (uint8_t*)calloc(length+1, 1);
3853 if (transfer_priv->hid_buffer == NULL) {
3854 return LIBUSB_ERROR_NO_MEM;
3855 }
3856 transfer_priv->hid_expected_size = length;
3857
3858 if (direction_in) {
3859 transfer_priv->hid_dest = transfer->buffer;
3860 usbi_dbg("reading %d bytes (report ID: 0x%02X)", length, transfer_priv->hid_buffer[0]);
3861 ret = ReadFile(wfd.handle, transfer_priv->hid_buffer, length+1, &size, wfd.overlapped);
3862 } else {
3863 if (!priv->hid->uses_report_ids[1]) {
3864 memcpy(transfer_priv->hid_buffer+1, transfer->buffer, transfer->length);
3865 } else {
3866 // We could actually do without the calloc and memcpy in this case
3867 memcpy(transfer_priv->hid_buffer, transfer->buffer, transfer->length);
3868 }
3869 usbi_dbg("writing %d bytes (report ID: 0x%02X)", length, transfer_priv->hid_buffer[0]);
3870 ret = WriteFile(wfd.handle, transfer_priv->hid_buffer, length, &size, wfd.overlapped);
3871 }
3872 if (!ret) {
3873 if (GetLastError() != ERROR_IO_PENDING) {
3874 usbi_err(ctx, "HID transfer failed: %s", windows_error_str(0));
3875 usbi_free_fd(wfd.fd);
3876 safe_free(transfer_priv->hid_buffer);
3877 return LIBUSB_ERROR_IO;
3878 }
3879 } else {
3880 // Only write operations that completed synchronously need to free up
3881 // hid_buffer. For reads, copy_transfer_data() handles that process.
3882 if (!direction_in) {
3883 safe_free(transfer_priv->hid_buffer);
3884 }
3885 if (size == 0) {
3886 usbi_err(ctx, "program assertion failed - no data was transferred");
3887 size = 1;
3888 }
3889 if (size > (size_t)length) {
3890 usbi_err(ctx, "OVERFLOW!");
3891 r = LIBUSB_ERROR_OVERFLOW;
3892 }
3893 wfd.overlapped->Internal = STATUS_COMPLETED_SYNCHRONOUSLY;
3894 wfd.overlapped->InternalHigh = size;
3895 }
3896
3897 transfer_priv->pollable_fd = wfd;
3898 transfer_priv->interface_number = (uint8_t)current_interface;
3899
3900 return r;
3901}
3902
3903static int hid_abort_transfers(struct usbi_transfer *itransfer)
3904{
3905 struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
3906 struct windows_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
3907 struct windows_device_handle_priv *handle_priv = __device_handle_priv(transfer->dev_handle);
3908 HANDLE hid_handle;
3909 int current_interface;
3910
3911 CHECK_HID_AVAILABLE;
3912
3913 current_interface = transfer_priv->interface_number;
3914 hid_handle = handle_priv->interface_handle[current_interface].api_handle;
3915 CancelIo(hid_handle);
3916
3917 return LIBUSB_SUCCESS;
3918}
3919
3920static int hid_reset_device(struct libusb_device_handle *dev_handle)
3921{
3922 struct windows_device_handle_priv *handle_priv = __device_handle_priv(dev_handle);
3923 HANDLE hid_handle;
3924 int current_interface;
3925
3926 CHECK_HID_AVAILABLE;
3927
3928 // Flushing the queues on all interfaces is the best we can achieve
3929 for (current_interface = 0; current_interface < USB_MAXINTERFACES; current_interface++) {
3930 hid_handle = handle_priv->interface_handle[current_interface].api_handle;
3931 if ((hid_handle != 0) && (hid_handle != INVALID_HANDLE_VALUE)) {
3932 HidD_FlushQueue(hid_handle);
3933 }
3934 }
3935 return LIBUSB_SUCCESS;
3936}
3937
3938static int hid_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint)
3939{
3940 struct libusb_context *ctx = DEVICE_CTX(dev_handle->dev);
3941 struct windows_device_handle_priv *handle_priv = __device_handle_priv(dev_handle);
3942 struct windows_device_priv *priv = __device_priv(dev_handle->dev);
3943 HANDLE hid_handle;
3944 int current_interface;
3945
3946 CHECK_HID_AVAILABLE;
3947
3948 current_interface = interface_by_endpoint(priv, handle_priv, endpoint);
3949 if (current_interface < 0) {
3950 usbi_err(ctx, "unable to match endpoint to an open interface - cannot clear");
3951 return LIBUSB_ERROR_NOT_FOUND;
3952 }
3953
3954 usbi_dbg("matched endpoint %02X with interface %d", endpoint, current_interface);
3955 hid_handle = handle_priv->interface_handle[current_interface].api_handle;
3956
3957 // No endpoint selection with Microsoft's implementation, so we try to flush the
3958 // whole interface. Should be OK for most case scenarios
3959 if (!HidD_FlushQueue(hid_handle)) {
3960 usbi_err(ctx, "Flushing of HID queue failed: %s", windows_error_str(0));
3961 // Device was probably disconnected
3962 return LIBUSB_ERROR_NO_DEVICE;
3963 }
3964
3965 return LIBUSB_SUCCESS;
3966}
3967
3968// This extra function is only needed for HID
3969static int hid_copy_transfer_data(struct usbi_transfer *itransfer, uint32_t io_size) {
3970 struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
3971 struct libusb_context *ctx = DEVICE_CTX(transfer->dev_handle->dev);
3972 struct windows_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
3973 int r = LIBUSB_TRANSFER_COMPLETED;
3974 uint32_t corrected_size = io_size;
3975
3976 if (transfer_priv->hid_buffer != NULL) {
3977 // If we have a valid hid_buffer, it means the transfer was async
3978 if (transfer_priv->hid_dest != NULL) { // Data readout
3979 // First, check for overflow
3980 if (corrected_size > transfer_priv->hid_expected_size) {
3981 usbi_err(ctx, "OVERFLOW!");
3982 corrected_size = (uint32_t)transfer_priv->hid_expected_size;
3983 r = LIBUSB_TRANSFER_OVERFLOW;
3984 }
3985
3986 if (transfer_priv->hid_buffer[0] == 0) {
3987 // Discard the 1 byte report ID prefix
3988 corrected_size--;
3989 memcpy(transfer_priv->hid_dest, transfer_priv->hid_buffer+1, corrected_size);
3990 } else {
3991 memcpy(transfer_priv->hid_dest, transfer_priv->hid_buffer, corrected_size);
3992 }
3993 transfer_priv->hid_dest = NULL;
3994 }
3995 // For write, we just need to free the hid buffer
3996 safe_free(transfer_priv->hid_buffer);
3997 }
3998 itransfer->transferred += corrected_size;
3999 return r;
4000}
4001
4002
4003/*
4004 * Composite API functions
4005 */
4006static int composite_init(struct libusb_context *ctx)
4007{
4008 return LIBUSB_SUCCESS;
4009}
4010
4011static int composite_exit(void)
4012{
4013 return LIBUSB_SUCCESS;
4014}
4015
4016static int composite_open(struct libusb_device_handle *dev_handle)
4017{
4018 struct windows_device_priv *priv = __device_priv(dev_handle->dev);
4019 unsigned api;
4020 int r;
4021 uint8_t flag = 1<<USB_API_WINUSB;
4022
4023 for (api=USB_API_WINUSB; api<USB_API_MAX; api++) {
4024 if (priv->composite_api_flags & flag) {
4025 r = usb_api_backend[api].open(dev_handle);
4026 if (r != LIBUSB_SUCCESS) {
4027 return r;
4028 }
4029 }
4030 flag <<= 1;
4031 }
4032 return LIBUSB_SUCCESS;
4033}
4034
4035static void composite_close(struct libusb_device_handle *dev_handle)
4036{
4037 struct windows_device_priv *priv = __device_priv(dev_handle->dev);
4038 unsigned api;
4039 uint8_t flag = 1<<USB_API_WINUSB;
4040
4041 for (api=USB_API_WINUSB; api<USB_API_MAX; api++) {
4042 if (priv->composite_api_flags & flag) {
4043 usb_api_backend[api].close(dev_handle);
4044 }
4045 flag <<= 1;
4046 }
4047}
4048
4049static int composite_claim_interface(struct libusb_device_handle *dev_handle, int iface)
4050{
4051 struct windows_device_priv *priv = __device_priv(dev_handle->dev);
4052 return priv->usb_interface[iface].apib->claim_interface(dev_handle, iface);
4053}
4054
4055static int composite_set_interface_altsetting(struct libusb_device_handle *dev_handle, int iface, int altsetting)
4056{
4057 struct windows_device_priv *priv = __device_priv(dev_handle->dev);
4058 return priv->usb_interface[iface].apib->set_interface_altsetting(dev_handle, iface, altsetting);
4059}
4060
4061static int composite_release_interface(struct libusb_device_handle *dev_handle, int iface)
4062{
4063 struct windows_device_priv *priv = __device_priv(dev_handle->dev);
4064 return priv->usb_interface[iface].apib->release_interface(dev_handle, iface);
4065}
4066
4067static int composite_submit_control_transfer(struct usbi_transfer *itransfer)
4068{
4069 struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
4070 struct libusb_context *ctx = DEVICE_CTX(transfer->dev_handle->dev);
4071 struct windows_device_priv *priv = __device_priv(transfer->dev_handle->dev);
4072 int i, pass;
4073
4074 // Interface shouldn't matter for control, but it does in practice, with Windows'
4075 // restrictions with regards to accessing HID keyboards and mice. Try a 2 pass approach
4076 for (pass = 0; pass < 2; pass++) {
4077 for (i=0; i<USB_MAXINTERFACES; i++) {
4078 if (priv->usb_interface[i].path != NULL) {
4079 if ((pass == 0) && (priv->usb_interface[i].restricted_functionality)) {
4080 usbi_dbg("trying to skip restricted interface #%d (HID keyboard or mouse?)", i);
4081 continue;
4082 }
4083 usbi_dbg("using interface %d", i);
4084 return priv->usb_interface[i].apib->submit_control_transfer(itransfer);
4085 }
4086 }
4087 }
4088
4089 usbi_err(ctx, "no libusb supported interfaces to complete request");
4090 return LIBUSB_ERROR_NOT_FOUND;
4091}
4092
4093static int composite_submit_bulk_transfer(struct usbi_transfer *itransfer) {
4094 struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
4095 struct libusb_context *ctx = DEVICE_CTX(transfer->dev_handle->dev);
4096 struct windows_device_handle_priv *handle_priv = __device_handle_priv(transfer->dev_handle);
4097 struct windows_device_priv *priv = __device_priv(transfer->dev_handle->dev);
4098 int current_interface;
4099
4100 current_interface = interface_by_endpoint(priv, handle_priv, transfer->endpoint);
4101 if (current_interface < 0) {
4102 usbi_err(ctx, "unable to match endpoint to an open interface - cancelling transfer");
4103 return LIBUSB_ERROR_NOT_FOUND;
4104 }
4105
4106 return priv->usb_interface[current_interface].apib->submit_bulk_transfer(itransfer);
4107}
4108
4109static int composite_submit_iso_transfer(struct usbi_transfer *itransfer) {
4110 struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
4111 struct libusb_context *ctx = DEVICE_CTX(transfer->dev_handle->dev);
4112 struct windows_device_handle_priv *handle_priv = __device_handle_priv(transfer->dev_handle);
4113 struct windows_device_priv *priv = __device_priv(transfer->dev_handle->dev);
4114 int current_interface;
4115
4116 current_interface = interface_by_endpoint(priv, handle_priv, transfer->endpoint);
4117 if (current_interface < 0) {
4118 usbi_err(ctx, "unable to match endpoint to an open interface - cancelling transfer");
4119 return LIBUSB_ERROR_NOT_FOUND;
4120 }
4121
4122 return priv->usb_interface[current_interface].apib->submit_iso_transfer(itransfer);
4123}
4124
4125static int composite_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint)
4126{
4127 struct libusb_context *ctx = DEVICE_CTX(dev_handle->dev);
4128 struct windows_device_handle_priv *handle_priv = __device_handle_priv(dev_handle);
4129 struct windows_device_priv *priv = __device_priv(dev_handle->dev);
4130 int current_interface;
4131
4132 current_interface = interface_by_endpoint(priv, handle_priv, endpoint);
4133 if (current_interface < 0) {
4134 usbi_err(ctx, "unable to match endpoint to an open interface - cannot clear");
4135 return LIBUSB_ERROR_NOT_FOUND;
4136 }
4137
4138 return priv->usb_interface[current_interface].apib->clear_halt(dev_handle, endpoint);
4139}
4140
4141static int composite_abort_control(struct usbi_transfer *itransfer)
4142{
4143 struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
4144 struct windows_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
4145 struct windows_device_priv *priv = __device_priv(transfer->dev_handle->dev);
4146
4147 return priv->usb_interface[transfer_priv->interface_number].apib->abort_control(itransfer);
4148}
4149
4150static int composite_abort_transfers(struct usbi_transfer *itransfer)
4151{
4152 struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
4153 struct windows_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
4154 struct windows_device_priv *priv = __device_priv(transfer->dev_handle->dev);
4155
4156 return priv->usb_interface[transfer_priv->interface_number].apib->abort_transfers(itransfer);
4157}
4158
4159static int composite_reset_device(struct libusb_device_handle *dev_handle)
4160{
4161 struct windows_device_priv *priv = __device_priv(dev_handle->dev);
4162 unsigned api;
4163 int r;
4164 uint8_t flag = 1<<USB_API_WINUSB;
4165
4166 for (api=USB_API_WINUSB; api<USB_API_MAX; api++) {
4167 if (priv->composite_api_flags & flag) {
4168 r = usb_api_backend[api].reset_device(dev_handle);
4169 if (r != LIBUSB_SUCCESS) {
4170 return r;
4171 }
4172 }
4173 flag <<= 1;
4174 }
4175 return LIBUSB_SUCCESS;
4176}
4177
4178static int composite_copy_transfer_data(struct usbi_transfer *itransfer, uint32_t io_size)
4179{
4180 struct libusb_transfer *transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
4181 struct windows_transfer_priv *transfer_priv = usbi_transfer_get_os_priv(itransfer);
4182 struct windows_device_priv *priv = __device_priv(transfer->dev_handle->dev);
4183
4184 return priv->usb_interface[transfer_priv->interface_number].apib->copy_transfer_data(itransfer, io_size);
4185}
© 2009-2020 sukimashita.com - Generated by cgit - Icons from Tango - Uses Google Analytics