• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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  * Major code testing contribution by Xiaofan Chen
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #pragma once
24 
25 #if defined(_MSC_VER)
26 // disable /W4 MSVC warnings that are benign
27 #pragma warning(disable:4127) // conditional expression is constant
28 #pragma warning(disable:4100) // unreferenced formal parameter
29 #pragma warning(disable:4214) // bit field types other than int
30 #pragma warning(disable:4201) // nameless struct/union
31 #endif
32 
33 // Windows API default is uppercase - ugh!
34 #if !defined(bool)
35 #define bool BOOL
36 #endif
37 #if !defined(true)
38 #define true TRUE
39 #endif
40 #if !defined(false)
41 #define false FALSE
42 #endif
43 
44 // Missing from MSVC6 setupapi.h
45 #if !defined(SPDRP_ADDRESS)
46 #define SPDRP_ADDRESS	28
47 #endif
48 #if !defined(SPDRP_INSTALL_STATE)
49 #define SPDRP_INSTALL_STATE	34
50 #endif
51 
52 #if defined(__CYGWIN__ )
53 // cygwin produces a warning unless these prototypes are defined
54 extern int _snprintf(char *buffer, size_t count, const char *format, ...);
55 extern char *_strdup(const char *strSource);
56 // _beginthreadex is MSVCRT => unavailable for cygwin. Fallback to using CreateThread
57 #define _beginthreadex(a, b, c, d, e, f) CreateThread(a, b, (LPTHREAD_START_ROUTINE)c, d, e, f)
58 #endif
59 #define safe_free(p) do {if (p != NULL) {free((void*)p); p = NULL;}} while(0)
60 #define safe_closehandle(h) do {if (h != INVALID_HANDLE_VALUE) {CloseHandle(h); h = INVALID_HANDLE_VALUE;}} while(0)
61 #define safe_min(a, b) min((size_t)(a), (size_t)(b))
62 #define safe_strcp(dst, dst_max, src, count) do {memcpy(dst, src, safe_min(count, dst_max)); \
63 	((char*)dst)[safe_min(count, dst_max)-1] = 0;} while(0)
64 #define safe_strcpy(dst, dst_max, src) safe_strcp(dst, dst_max, src, safe_strlen(src)+1)
65 #define safe_strncat(dst, dst_max, src, count) strncat(dst, src, safe_min(count, dst_max - safe_strlen(dst) - 1))
66 #define safe_strcat(dst, dst_max, src) safe_strncat(dst, dst_max, src, safe_strlen(src)+1)
67 #define safe_strcmp(str1, str2) strcmp(((str1==NULL)?"<NULL>":str1), ((str2==NULL)?"<NULL>":str2))
68 #define safe_strncmp(str1, str2, count) strncmp(((str1==NULL)?"<NULL>":str1), ((str2==NULL)?"<NULL>":str2), count)
69 #define safe_strlen(str) ((str==NULL)?0:strlen(str))
70 #define safe_sprintf _snprintf
71 #define safe_unref_device(dev) do {if (dev != NULL) {libusb_unref_device(dev); dev = NULL;}} while(0)
72 #define wchar_to_utf8_ms(wstr, str, strlen) WideCharToMultiByte(CP_UTF8, 0, wstr, -1, str, strlen, NULL, NULL)
upperize(char * str)73 static inline void upperize(char* str) {
74 	size_t i;
75 	if (str == NULL) return;
76 	for (i=0; i<safe_strlen(str); i++)
77 		str[i] = (char)toupper((int)str[i]);
78 }
79 
80 #define MAX_CTRL_BUFFER_LENGTH      4096
81 #define MAX_USB_DEVICES             256
82 #define MAX_USB_STRING_LENGTH       128
83 #define MAX_GUID_STRING_LENGTH      40
84 #define MAX_PATH_LENGTH             128
85 #define MAX_KEY_LENGTH              256
86 #define MAX_TIMER_SEMAPHORES        128
87 #define TIMER_REQUEST_RETRY_MS      100
88 #define ERR_BUFFER_SIZE             256
89 #define LIST_SEPARATOR              ';'
90 #define HTAB_SIZE                   1021
91 
92 // http://msdn.microsoft.com/en-us/library/ff545978.aspx
93 // http://msdn.microsoft.com/en-us/library/ff545972.aspx
94 // http://msdn.microsoft.com/en-us/library/ff545982.aspx
95 #if !defined(GUID_DEVINTERFACE_USB_HOST_CONTROLLER)
96 const GUID GUID_DEVINTERFACE_USB_HOST_CONTROLLER = { 0x3ABF6F2D, 0x71C4, 0x462A, {0x8A, 0x92, 0x1E, 0x68, 0x61, 0xE6, 0xAF, 0x27} };
97 #endif
98 #if !defined(GUID_DEVINTERFACE_USB_DEVICE)
99 const GUID GUID_DEVINTERFACE_USB_DEVICE = { 0xA5DCBF10, 0x6530, 0x11D2, {0x90, 0x1F, 0x00, 0xC0, 0x4F, 0xB9, 0x51, 0xED} };
100 #endif
101 #if !defined(GUID_DEVINTERFACE_USB_HUB)
102 const GUID GUID_DEVINTERFACE_USB_HUB = { 0xF18A0E88, 0xC30C, 0x11D0, {0x88, 0x15, 0x00, 0xA0, 0xC9, 0x06, 0xBE, 0xD8} };
103 #endif
104 const GUID GUID_NULL = { 0x00000000, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} };
105 
106 
107 /*
108  * Multiple USB API backend support
109  */
110 #define USB_API_UNSUPPORTED 0
111 #define USB_API_HUB         1
112 #define USB_API_COMPOSITE   2
113 #define USB_API_WINUSB      3
114 #define USB_API_MAX         4
115 
116 #define CLASS_GUID_UNSUPPORTED      GUID_NULL
117 const GUID CLASS_GUID_LIBUSB_WINUSB = { 0x78A1C341, 0x4539, 0x11D3, {0xB8, 0x8D, 0x00, 0xC0, 0x4F, 0xAD, 0x51, 0x71} };
118 const GUID CLASS_GUID_COMPOSITE     = { 0x36FC9E60, 0xC465, 0x11cF, {0x80, 0x56, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00} };
119 
120 struct windows_usb_api_backend {
121 	const uint8_t id;
122 	const char* designation;
123 	const GUID *class_guid;  // The Class GUID (for fallback in case the driver name cannot be read)
124 	const char **driver_name_list; // Driver name, without .sys, e.g. "usbccgp"
125 	const uint8_t nb_driver_names;
126 	int (*init)(struct libusb_context *ctx);
127 	int (*exit)(void);
128 	int (*open)(struct libusb_device_handle *dev_handle);
129 	void (*close)(struct libusb_device_handle *dev_handle);
130 	int (*claim_interface)(struct libusb_device_handle *dev_handle, int iface);
131 	int (*set_interface_altsetting)(struct libusb_device_handle *dev_handle, int iface, int altsetting);
132 	int (*release_interface)(struct libusb_device_handle *dev_handle, int iface);
133 	int (*clear_halt)(struct libusb_device_handle *dev_handle, unsigned char endpoint);
134 	int (*reset_device)(struct libusb_device_handle *dev_handle);
135 	int (*submit_bulk_transfer)(struct usbi_transfer *itransfer);
136 	int (*submit_iso_transfer)(struct usbi_transfer *itransfer);
137 	int (*submit_control_transfer)(struct usbi_transfer *itransfer);
138 	int (*abort_control)(struct usbi_transfer *itransfer);
139 	int (*abort_transfers)(struct usbi_transfer *itransfer);
140 	int (*copy_transfer_data)(struct usbi_transfer *itransfer, uint32_t io_size);
141 };
142 
143 extern const struct windows_usb_api_backend usb_api_backend[USB_API_MAX];
144 
145 #define PRINT_UNSUPPORTED_API(fname)              \
146 	usbi_dbg("unsupported API call for '"         \
147 		#fname "' (unrecognized device driver)"); \
148 	return LIBUSB_ERROR_NOT_SUPPORTED;
149 
150 /*
151  * private structures definition
152  * with inline pseudo constructors/destructors
153  */
154 typedef struct libusb_device_descriptor USB_DEVICE_DESCRIPTOR, *PUSB_DEVICE_DESCRIPTOR;
155 struct windows_device_priv {
156 	uint8_t depth;						// distance to HCD
157 	uint8_t port;						// port number on the hub
158 	struct libusb_device *parent_dev;	// access to parent is required for usermode ops
159 	char *path;							// device interface path
160 	struct windows_usb_api_backend const *apib;
161 	struct {
162 		char *path;						// each interface needs a device interface path,
163 		struct windows_usb_api_backend const *apib; // an API backend (multiple drivers support),
164 		int8_t nb_endpoints;			// and a set of endpoint addresses (USB_MAXENDPOINTS)
165 		uint8_t *endpoint;
166 	} usb_interface[USB_MAXINTERFACES];
167 	uint8_t composite_api_flags;		// composite devices require additional data
168 	uint8_t active_config;
169 	USB_DEVICE_DESCRIPTOR dev_descriptor;
170 	unsigned char **config_descriptor;	// list of pointers to the cached config descriptors
171 };
172 
_device_priv(struct libusb_device * dev)173 static inline struct windows_device_priv *_device_priv(struct libusb_device *dev) {
174 	return (struct windows_device_priv *)dev->os_priv;
175 }
176 
windows_device_priv_init(libusb_device * dev)177 static inline void windows_device_priv_init(libusb_device* dev) {
178 	struct windows_device_priv* p = _device_priv(dev);
179 	int i;
180 	p->depth = 0;
181 	p->port = 0;
182 	p->parent_dev = NULL;
183 	p->path = NULL;
184 	p->apib = &usb_api_backend[USB_API_UNSUPPORTED];
185 	p->composite_api_flags = 0;
186 	p->active_config = 0;
187 	p->config_descriptor = NULL;
188 	memset(&(p->dev_descriptor), 0, sizeof(USB_DEVICE_DESCRIPTOR));
189 	for (i=0; i<USB_MAXINTERFACES; i++) {
190 		p->usb_interface[i].path = NULL;
191 		p->usb_interface[i].apib = &usb_api_backend[USB_API_UNSUPPORTED];
192 		p->usb_interface[i].nb_endpoints = 0;
193 		p->usb_interface[i].endpoint = NULL;
194 	}
195 }
196 
windows_device_priv_release(libusb_device * dev)197 static inline void windows_device_priv_release(libusb_device* dev) {
198 	struct windows_device_priv* p = _device_priv(dev);
199 	int i;
200 	safe_free(p->path);
201 	if ((dev->num_configurations > 0) && (p->config_descriptor != NULL)) {
202 		for (i=0; i < dev->num_configurations; i++)
203 			safe_free(p->config_descriptor[i]);
204 	}
205 	safe_free(p->config_descriptor);
206 	for (i=0; i<USB_MAXINTERFACES; i++) {
207 		safe_free(p->usb_interface[i].path);
208 		safe_free(p->usb_interface[i].endpoint);
209 	}
210 }
211 
212 struct interface_handle_t {
213 	HANDLE dev_handle; // WinUSB needs an extra handle for the file
214 	HANDLE api_handle; // used by the API to communicate with the device
215 };
216 
217 struct windows_device_handle_priv {
218 	int active_interface;
219 	struct interface_handle_t interface_handle[USB_MAXINTERFACES];
220 	int autoclaim_count[USB_MAXINTERFACES]; // For auto-release
221 };
222 
_device_handle_priv(struct libusb_device_handle * handle)223 static inline struct windows_device_handle_priv *_device_handle_priv(
224 	struct libusb_device_handle *handle)
225 {
226 	return (struct windows_device_handle_priv *) handle->os_priv;
227 }
228 
229 // used for async polling functions
230 struct windows_transfer_priv {
231 	struct winfd pollable_fd;
232 	uint8_t interface_number;
233 };
234 
235 // used to match a device driver (including filter drivers) against a supported API
236 struct driver_lookup {
237 	char list[MAX_KEY_LENGTH+1];// REG_MULTI_SZ list of services (driver) names
238 	const DWORD reg_prop;		// SPDRP registry key to use to retreive list
239 	const char* designation;	// internal designation (for debug output)
240 };
241 
242 /*
243  * API macros - from libusb-win32 1.x
244  */
245 #define DLL_DECLARE_PREFIXNAME(api, ret, prefixname, name, args)    \
246 	typedef ret (api * __dll_##name##_t)args;                 \
247 	static __dll_##name##_t prefixname = NULL
248 
249 #define DLL_LOAD_PREFIXNAME(dll, prefixname, name, ret_on_failure) \
250 	do {                                                      \
251 		HMODULE h = GetModuleHandleA(#dll);                   \
252 	if (!h)                                                   \
253 		h = LoadLibraryA(#dll);                               \
254 	if (!h) {                                                 \
255 		if (ret_on_failure) { return LIBUSB_ERROR_NOT_FOUND; }\
256 		else { break; }                                       \
257 	}                                                         \
258 	prefixname = (__dll_##name##_t)GetProcAddress(h, #name);       \
259 	if (prefixname) break;                                         \
260 	prefixname = (__dll_##name##_t)GetProcAddress(h, #name "A");   \
261 	if (prefixname) break;                                         \
262 	prefixname = (__dll_##name##_t)GetProcAddress(h, #name "W");   \
263 	if (prefixname) break;                                         \
264 	if(ret_on_failure)                                        \
265 		return LIBUSB_ERROR_NOT_FOUND;                        \
266 	} while(0)
267 
268 #define DLL_DECLARE(api, ret, name, args)   DLL_DECLARE_PREFIXNAME(api, ret, name, name, args)
269 #define DLL_LOAD(dll, name, ret_on_failure) DLL_LOAD_PREFIXNAME(dll, name, name, ret_on_failure)
270 #define DLL_DECLARE_PREFIXED(api, ret, prefix, name, args)   DLL_DECLARE_PREFIXNAME(api, ret, prefix##name, name, args)
271 #define DLL_LOAD_PREFIXED(dll, prefix, name, ret_on_failure) DLL_LOAD_PREFIXNAME(dll, prefix##name, name, ret_on_failure)
272 
273 /* OLE32 dependency */
274 DLL_DECLARE_PREFIXED(WINAPI, HRESULT, p, CLSIDFromString, (LPCOLESTR, LPCLSID));
275 
276 /* SetupAPI dependencies */
277 DLL_DECLARE_PREFIXED(WINAPI, HDEVINFO, p, SetupDiGetClassDevsA, (const GUID*, PCSTR, HWND, DWORD));
278 DLL_DECLARE_PREFIXED(WINAPI, BOOL, p, SetupDiEnumDeviceInfo, (HDEVINFO, DWORD, PSP_DEVINFO_DATA));
279 DLL_DECLARE_PREFIXED(WINAPI, BOOL, p, SetupDiEnumDeviceInterfaces, (HDEVINFO, PSP_DEVINFO_DATA,
280 			const GUID*, DWORD, PSP_DEVICE_INTERFACE_DATA));
281 DLL_DECLARE_PREFIXED(WINAPI, BOOL, p, SetupDiGetDeviceInterfaceDetailA, (HDEVINFO, PSP_DEVICE_INTERFACE_DATA,
282 			PSP_DEVICE_INTERFACE_DETAIL_DATA_A, DWORD, PDWORD, PSP_DEVINFO_DATA));
283 DLL_DECLARE_PREFIXED(WINAPI, BOOL, p, SetupDiDestroyDeviceInfoList, (HDEVINFO));
284 DLL_DECLARE_PREFIXED(WINAPI, HKEY, p, SetupDiOpenDevRegKey, (HDEVINFO, PSP_DEVINFO_DATA, DWORD, DWORD, DWORD, REGSAM));
285 DLL_DECLARE_PREFIXED(WINAPI, BOOL, p, SetupDiGetDeviceRegistryPropertyA, (HDEVINFO,
286 			PSP_DEVINFO_DATA, DWORD, PDWORD, PBYTE, DWORD, PDWORD));
287 DLL_DECLARE_PREFIXED(WINAPI, LONG, p, RegQueryValueExW, (HKEY, LPCWSTR, LPDWORD, LPDWORD, LPBYTE, LPDWORD));
288 DLL_DECLARE_PREFIXED(WINAPI, LONG, p, RegCloseKey, (HKEY));
289 
290 /*
291  * Windows DDK API definitions. Most of it copied from MinGW's includes
292  */
293 typedef DWORD DEVNODE, DEVINST;
294 typedef DEVNODE *PDEVNODE, *PDEVINST;
295 typedef DWORD RETURN_TYPE;
296 typedef RETURN_TYPE CONFIGRET;
297 
298 #define CR_SUCCESS                              0x00000000
299 #define CR_NO_SUCH_DEVNODE                      0x0000000D
300 
301 #define USB_DEVICE_DESCRIPTOR_TYPE              LIBUSB_DT_DEVICE
302 #define USB_CONFIGURATION_DESCRIPTOR_TYPE       LIBUSB_DT_CONFIG
303 #define USB_STRING_DESCRIPTOR_TYPE              LIBUSB_DT_STRING
304 #define USB_INTERFACE_DESCRIPTOR_TYPE           LIBUSB_DT_INTERFACE
305 #define USB_ENDPOINT_DESCRIPTOR_TYPE            LIBUSB_DT_ENDPOINT
306 
307 #define USB_REQUEST_GET_STATUS                  LIBUSB_REQUEST_GET_STATUS
308 #define USB_REQUEST_CLEAR_FEATURE               LIBUSB_REQUEST_CLEAR_FEATURE
309 #define USB_REQUEST_SET_FEATURE                 LIBUSB_REQUEST_SET_FEATURE
310 #define USB_REQUEST_SET_ADDRESS                 LIBUSB_REQUEST_SET_ADDRESS
311 #define USB_REQUEST_GET_DESCRIPTOR              LIBUSB_REQUEST_GET_DESCRIPTOR
312 #define USB_REQUEST_SET_DESCRIPTOR              LIBUSB_REQUEST_SET_DESCRIPTOR
313 #define USB_REQUEST_GET_CONFIGURATION           LIBUSB_REQUEST_GET_CONFIGURATION
314 #define USB_REQUEST_SET_CONFIGURATION           LIBUSB_REQUEST_SET_CONFIGURATION
315 #define USB_REQUEST_GET_INTERFACE               LIBUSB_REQUEST_GET_INTERFACE
316 #define USB_REQUEST_SET_INTERFACE               LIBUSB_REQUEST_SET_INTERFACE
317 #define USB_REQUEST_SYNC_FRAME                  LIBUSB_REQUEST_SYNCH_FRAME
318 
319 #define USB_GET_NODE_INFORMATION                258
320 #define USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION 260
321 #define USB_GET_NODE_CONNECTION_NAME            261
322 #define USB_GET_HUB_CAPABILITIES                271
323 #if !defined(USB_GET_NODE_CONNECTION_INFORMATION_EX)
324 #define USB_GET_NODE_CONNECTION_INFORMATION_EX  274
325 #endif
326 #if !defined(USB_GET_HUB_CAPABILITIES_EX)
327 #define USB_GET_HUB_CAPABILITIES_EX             276
328 #endif
329 
330 #ifndef METHOD_BUFFERED
331 #define METHOD_BUFFERED                         0
332 #endif
333 #ifndef FILE_ANY_ACCESS
334 #define FILE_ANY_ACCESS                         0x00000000
335 #endif
336 #ifndef FILE_DEVICE_UNKNOWN
337 #define FILE_DEVICE_UNKNOWN                     0x00000022
338 #endif
339 #ifndef FILE_DEVICE_USB
340 #define FILE_DEVICE_USB                         FILE_DEVICE_UNKNOWN
341 #endif
342 
343 #ifndef CTL_CODE
344 #define CTL_CODE(DeviceType, Function, Method, Access)( \
345   ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method))
346 #endif
347 
348 typedef enum USB_CONNECTION_STATUS {
349 	NoDeviceConnected,
350 	DeviceConnected,
351 	DeviceFailedEnumeration,
352 	DeviceGeneralFailure,
353 	DeviceCausedOvercurrent,
354 	DeviceNotEnoughPower,
355 	DeviceNotEnoughBandwidth,
356 	DeviceHubNestedTooDeeply,
357 	DeviceInLegacyHub
358 } USB_CONNECTION_STATUS, *PUSB_CONNECTION_STATUS;
359 
360 typedef enum USB_HUB_NODE {
361 	UsbHub,
362 	UsbMIParent
363 } USB_HUB_NODE;
364 
365 /* Cfgmgr32.dll interface */
366 DLL_DECLARE(WINAPI, CONFIGRET, CM_Get_Parent, (PDEVINST, DEVINST, ULONG));
367 DLL_DECLARE(WINAPI, CONFIGRET, CM_Get_Child, (PDEVINST, DEVINST, ULONG));
368 DLL_DECLARE(WINAPI, CONFIGRET, CM_Get_Sibling, (PDEVINST, DEVINST, ULONG));
369 DLL_DECLARE(WINAPI, CONFIGRET, CM_Get_Device_IDA, (DEVINST, PCHAR, ULONG, ULONG));
370 
371 #define IOCTL_USB_GET_HUB_CAPABILITIES_EX \
372   CTL_CODE( FILE_DEVICE_USB, USB_GET_HUB_CAPABILITIES_EX, METHOD_BUFFERED, FILE_ANY_ACCESS)
373 
374 #define IOCTL_USB_GET_HUB_CAPABILITIES \
375   CTL_CODE(FILE_DEVICE_USB, USB_GET_HUB_CAPABILITIES, METHOD_BUFFERED, FILE_ANY_ACCESS)
376 
377 #define IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION \
378   CTL_CODE(FILE_DEVICE_USB, USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION, METHOD_BUFFERED, FILE_ANY_ACCESS)
379 
380 #define IOCTL_USB_GET_ROOT_HUB_NAME \
381   CTL_CODE(FILE_DEVICE_USB, HCD_GET_ROOT_HUB_NAME, METHOD_BUFFERED, FILE_ANY_ACCESS)
382 
383 #define IOCTL_USB_GET_NODE_INFORMATION \
384   CTL_CODE(FILE_DEVICE_USB, USB_GET_NODE_INFORMATION, METHOD_BUFFERED, FILE_ANY_ACCESS)
385 
386 #define IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX \
387   CTL_CODE(FILE_DEVICE_USB, USB_GET_NODE_CONNECTION_INFORMATION_EX, METHOD_BUFFERED, FILE_ANY_ACCESS)
388 
389 #define IOCTL_USB_GET_NODE_CONNECTION_ATTRIBUTES \
390   CTL_CODE(FILE_DEVICE_USB, USB_GET_NODE_CONNECTION_ATTRIBUTES, METHOD_BUFFERED, FILE_ANY_ACCESS)
391 
392 #define IOCTL_USB_GET_NODE_CONNECTION_NAME \
393   CTL_CODE(FILE_DEVICE_USB, USB_GET_NODE_CONNECTION_NAME, METHOD_BUFFERED, FILE_ANY_ACCESS)
394 
395 // Most of the structures below need to be packed
396 #pragma pack(push, 1)
397 
398 typedef struct USB_INTERFACE_DESCRIPTOR {
399   UCHAR  bLength;
400   UCHAR  bDescriptorType;
401   UCHAR  bInterfaceNumber;
402   UCHAR  bAlternateSetting;
403   UCHAR  bNumEndpoints;
404   UCHAR  bInterfaceClass;
405   UCHAR  bInterfaceSubClass;
406   UCHAR  bInterfaceProtocol;
407   UCHAR  iInterface;
408 } USB_INTERFACE_DESCRIPTOR, *PUSB_INTERFACE_DESCRIPTOR;
409 
410 typedef struct USB_CONFIGURATION_DESCRIPTOR {
411   UCHAR  bLength;
412   UCHAR  bDescriptorType;
413   USHORT wTotalLength;
414   UCHAR  bNumInterfaces;
415   UCHAR  bConfigurationValue;
416   UCHAR  iConfiguration;
417   UCHAR  bmAttributes;
418   UCHAR  MaxPower;
419 } USB_CONFIGURATION_DESCRIPTOR, *PUSB_CONFIGURATION_DESCRIPTOR;
420 
421 typedef struct USB_CONFIGURATION_DESCRIPTOR_SHORT {
422 	struct {
423 		ULONG ConnectionIndex;
424 		struct {
425 			UCHAR bmRequest;
426 			UCHAR bRequest;
427 			USHORT wValue;
428 			USHORT wIndex;
429 			USHORT wLength;
430 		} SetupPacket;
431 	} req;
432 	USB_CONFIGURATION_DESCRIPTOR data;
433 } USB_CONFIGURATION_DESCRIPTOR_SHORT;
434 
435 typedef struct USB_ENDPOINT_DESCRIPTOR {
436   UCHAR  bLength;
437   UCHAR  bDescriptorType;
438   UCHAR  bEndpointAddress;
439   UCHAR  bmAttributes;
440   USHORT  wMaxPacketSize;
441   UCHAR  bInterval;
442 } USB_ENDPOINT_DESCRIPTOR, *PUSB_ENDPOINT_DESCRIPTOR;
443 
444 typedef struct USB_DESCRIPTOR_REQUEST {
445 	ULONG  ConnectionIndex;
446 	struct {
447 		UCHAR  bmRequest;
448 		UCHAR  bRequest;
449 		USHORT  wValue;
450 		USHORT  wIndex;
451 		USHORT  wLength;
452 	} SetupPacket;
453 //	UCHAR  Data[0];
454 } USB_DESCRIPTOR_REQUEST, *PUSB_DESCRIPTOR_REQUEST;
455 
456 typedef struct USB_HUB_DESCRIPTOR {
457 	UCHAR  bDescriptorLength;
458 	UCHAR  bDescriptorType;
459 	UCHAR  bNumberOfPorts;
460 	USHORT  wHubCharacteristics;
461 	UCHAR  bPowerOnToPowerGood;
462 	UCHAR  bHubControlCurrent;
463 	UCHAR  bRemoveAndPowerMask[64];
464 } USB_HUB_DESCRIPTOR, *PUSB_HUB_DESCRIPTOR;
465 
466 typedef struct USB_ROOT_HUB_NAME {
467 	ULONG  ActualLength;
468 	WCHAR  RootHubName[1];
469 } USB_ROOT_HUB_NAME, *PUSB_ROOT_HUB_NAME;
470 
471 typedef struct USB_ROOT_HUB_NAME_FIXED {
472 	ULONG ActualLength;
473 	WCHAR RootHubName[MAX_PATH_LENGTH];
474 } USB_ROOT_HUB_NAME_FIXED;
475 
476 typedef struct USB_NODE_CONNECTION_NAME {
477 	ULONG  ConnectionIndex;
478 	ULONG  ActualLength;
479 	WCHAR  NodeName[1];
480 } USB_NODE_CONNECTION_NAME, *PUSB_NODE_CONNECTION_NAME;
481 
482 typedef struct USB_NODE_CONNECTION_NAME_FIXED {
483 	ULONG ConnectionIndex;
484 	ULONG ActualLength;
485 	WCHAR NodeName[MAX_PATH_LENGTH];
486 } USB_NODE_CONNECTION_NAME_FIXED;
487 
488 typedef struct USB_HUB_NAME_FIXED {
489 	union {
490 		USB_ROOT_HUB_NAME_FIXED root;
491 		USB_NODE_CONNECTION_NAME_FIXED node;
492 	} u;
493 } USB_HUB_NAME_FIXED;
494 
495 typedef struct USB_HUB_INFORMATION {
496 	USB_HUB_DESCRIPTOR  HubDescriptor;
497 	BOOLEAN  HubIsBusPowered;
498 } USB_HUB_INFORMATION, *PUSB_HUB_INFORMATION;
499 
500 typedef struct USB_MI_PARENT_INFORMATION {
501   ULONG  NumberOfInterfaces;
502 } USB_MI_PARENT_INFORMATION, *PUSB_MI_PARENT_INFORMATION;
503 
504 typedef struct USB_NODE_INFORMATION {
505 	USB_HUB_NODE  NodeType;
506 	union {
507 		USB_HUB_INFORMATION  HubInformation;
508 		USB_MI_PARENT_INFORMATION  MiParentInformation;
509 	} u;
510 } USB_NODE_INFORMATION, *PUSB_NODE_INFORMATION;
511 
512 typedef struct USB_PIPE_INFO {
513 	USB_ENDPOINT_DESCRIPTOR  EndpointDescriptor;
514 	ULONG  ScheduleOffset;
515 } USB_PIPE_INFO, *PUSB_PIPE_INFO;
516 
517 typedef struct USB_NODE_CONNECTION_INFORMATION_EX {
518 	ULONG  ConnectionIndex;
519 	USB_DEVICE_DESCRIPTOR  DeviceDescriptor;
520 	UCHAR  CurrentConfigurationValue;
521 	UCHAR  Speed;
522 	BOOLEAN  DeviceIsHub;
523 	USHORT  DeviceAddress;
524 	ULONG  NumberOfOpenPipes;
525 	USB_CONNECTION_STATUS  ConnectionStatus;
526 //	USB_PIPE_INFO  PipeList[0];
527 } USB_NODE_CONNECTION_INFORMATION_EX, *PUSB_NODE_CONNECTION_INFORMATION_EX;
528 
529 typedef struct USB_HUB_CAP_FLAGS {
530 	ULONG HubIsHighSpeedCapable:1;
531 	ULONG HubIsHighSpeed:1;
532 	ULONG HubIsMultiTtCapable:1;
533 	ULONG HubIsMultiTt:1;
534 	ULONG HubIsRoot:1;
535 	ULONG HubIsArmedWakeOnConnect:1;
536 	ULONG ReservedMBZ:26;
537 } USB_HUB_CAP_FLAGS, *PUSB_HUB_CAP_FLAGS;
538 
539 typedef struct USB_HUB_CAPABILITIES {
540   ULONG  HubIs2xCapable : 1;
541 } USB_HUB_CAPABILITIES, *PUSB_HUB_CAPABILITIES;
542 
543 typedef struct USB_HUB_CAPABILITIES_EX {
544 	USB_HUB_CAP_FLAGS CapabilityFlags;
545 } USB_HUB_CAPABILITIES_EX, *PUSB_HUB_CAPABILITIES_EX;
546 
547 #pragma pack(pop)
548 
549 /* winusb.dll interface */
550 
551 #define SHORT_PACKET_TERMINATE  0x01
552 #define AUTO_CLEAR_STALL        0x02
553 #define PIPE_TRANSFER_TIMEOUT   0x03
554 #define IGNORE_SHORT_PACKETS    0x04
555 #define ALLOW_PARTIAL_READS     0x05
556 #define AUTO_FLUSH              0x06
557 #define RAW_IO                  0x07
558 #define MAXIMUM_TRANSFER_SIZE   0x08
559 #define AUTO_SUSPEND            0x81
560 #define SUSPEND_DELAY           0x83
561 #define DEVICE_SPEED            0x01
562 #define LowSpeed                0x01
563 #define FullSpeed               0x02
564 #define HighSpeed               0x03
565 
566 typedef enum USBD_PIPE_TYPE {
567 	UsbdPipeTypeControl,
568 	UsbdPipeTypeIsochronous,
569 	UsbdPipeTypeBulk,
570 	UsbdPipeTypeInterrupt
571 } USBD_PIPE_TYPE;
572 
573 typedef struct {
574   USBD_PIPE_TYPE PipeType;
575   UCHAR          PipeId;
576   USHORT         MaximumPacketSize;
577   UCHAR          Interval;
578 } WINUSB_PIPE_INFORMATION, *PWINUSB_PIPE_INFORMATION;
579 
580 #pragma pack(1)
581 typedef struct {
582   UCHAR  request_type;
583   UCHAR  request;
584   USHORT value;
585   USHORT index;
586   USHORT length;
587 } WINUSB_SETUP_PACKET, *PWINUSB_SETUP_PACKET;
588 #pragma pack()
589 
590 typedef void *WINUSB_INTERFACE_HANDLE, *PWINUSB_INTERFACE_HANDLE;
591 
592 DLL_DECLARE(WINAPI, BOOL, WinUsb_Initialize, (HANDLE, PWINUSB_INTERFACE_HANDLE));
593 DLL_DECLARE(WINAPI, BOOL, WinUsb_Free, (WINUSB_INTERFACE_HANDLE));
594 DLL_DECLARE(WINAPI, BOOL, WinUsb_GetAssociatedInterface, (WINUSB_INTERFACE_HANDLE, UCHAR, PWINUSB_INTERFACE_HANDLE));
595 DLL_DECLARE(WINAPI, BOOL, WinUsb_GetDescriptor, (WINUSB_INTERFACE_HANDLE, UCHAR, UCHAR, USHORT, PUCHAR, ULONG, PULONG));
596 DLL_DECLARE(WINAPI, BOOL, WinUsb_QueryInterfaceSettings, (WINUSB_INTERFACE_HANDLE, UCHAR, PUSB_INTERFACE_DESCRIPTOR));
597 DLL_DECLARE(WINAPI, BOOL, WinUsb_QueryDeviceInformation, (WINUSB_INTERFACE_HANDLE, ULONG, PULONG, PVOID));
598 DLL_DECLARE(WINAPI, BOOL, WinUsb_SetCurrentAlternateSetting, (WINUSB_INTERFACE_HANDLE, UCHAR));
599 DLL_DECLARE(WINAPI, BOOL, WinUsb_GetCurrentAlternateSetting, (WINUSB_INTERFACE_HANDLE, PUCHAR));
600 DLL_DECLARE(WINAPI, BOOL, WinUsb_QueryPipe, (WINUSB_INTERFACE_HANDLE, UCHAR, UCHAR, PWINUSB_PIPE_INFORMATION));
601 DLL_DECLARE(WINAPI, BOOL, WinUsb_SetPipePolicy, (WINUSB_INTERFACE_HANDLE, UCHAR, ULONG, ULONG, PVOID));
602 DLL_DECLARE(WINAPI, BOOL, WinUsb_GetPipePolicy, (WINUSB_INTERFACE_HANDLE, UCHAR, ULONG, PULONG, PVOID));
603 DLL_DECLARE(WINAPI, BOOL, WinUsb_ReadPipe, (WINUSB_INTERFACE_HANDLE, UCHAR, PUCHAR, ULONG, PULONG, LPOVERLAPPED));
604 DLL_DECLARE(WINAPI, BOOL, WinUsb_WritePipe, (WINUSB_INTERFACE_HANDLE, UCHAR, PUCHAR, ULONG, PULONG, LPOVERLAPPED));
605 DLL_DECLARE(WINAPI, BOOL, WinUsb_ControlTransfer, (WINUSB_INTERFACE_HANDLE, WINUSB_SETUP_PACKET, PUCHAR, ULONG, PULONG, LPOVERLAPPED));
606 DLL_DECLARE(WINAPI, BOOL, WinUsb_ResetPipe, (WINUSB_INTERFACE_HANDLE, UCHAR));
607 DLL_DECLARE(WINAPI, BOOL, WinUsb_AbortPipe, (WINUSB_INTERFACE_HANDLE, UCHAR));
608 DLL_DECLARE(WINAPI, BOOL, WinUsb_FlushPipe, (WINUSB_INTERFACE_HANDLE, UCHAR));
609