source: libusb1/vendor/current/libusb/os/windows_usb.h@ 1876

Last change on this file since 1876 was 1876, checked in by Silvan Scherrer, 8 years ago

libusb: import version 1.0.16
File size: 23.5 KB
Line 
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
54extern int _snprintf(char *buffer, size_t count, const char *format, ...);
55extern 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)
73static 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)
96const 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)
99const 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)
102const GUID GUID_DEVINTERFACE_USB_HUB = { 0xF18A0E88, 0xC30C, 0x11D0, {0x88, 0x15, 0x00, 0xA0, 0xC9, 0x06, 0xBE, 0xD8} };
103#endif
104const 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
117const GUID CLASS_GUID_LIBUSB_WINUSB = { 0x78A1C341, 0x4539, 0x11D3, {0xB8, 0x8D, 0x00, 0xC0, 0x4F, 0xAD, 0x51, 0x71} };
118const GUID CLASS_GUID_COMPOSITE = { 0x36FC9E60, 0xC465, 0x11cF, {0x80, 0x56, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00} };
119
120struct 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
143extern 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 */
154typedef struct libusb_device_descriptor USB_DEVICE_DESCRIPTOR, *PUSB_DEVICE_DESCRIPTOR;
155struct 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
173static inline struct windows_device_priv *_device_priv(struct libusb_device *dev) {
174 return (struct windows_device_priv *)dev->os_priv;
175}
176
177static 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
197static 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
212struct 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
217struct 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
223static 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
230struct 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
236struct 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 */
274DLL_DECLARE_PREFIXED(WINAPI, HRESULT, p, CLSIDFromString, (LPCOLESTR, LPCLSID));
275
276/* SetupAPI dependencies */
277DLL_DECLARE_PREFIXED(WINAPI, HDEVINFO, p, SetupDiGetClassDevsA, (const GUID*, PCSTR, HWND, DWORD));
278DLL_DECLARE_PREFIXED(WINAPI, BOOL, p, SetupDiEnumDeviceInfo, (HDEVINFO, DWORD, PSP_DEVINFO_DATA));
279DLL_DECLARE_PREFIXED(WINAPI, BOOL, p, SetupDiEnumDeviceInterfaces, (HDEVINFO, PSP_DEVINFO_DATA,
280 const GUID*, DWORD, PSP_DEVICE_INTERFACE_DATA));
281DLL_DECLARE_PREFIXED(WINAPI, BOOL, p, SetupDiGetDeviceInterfaceDetailA, (HDEVINFO, PSP_DEVICE_INTERFACE_DATA,
282 PSP_DEVICE_INTERFACE_DETAIL_DATA_A, DWORD, PDWORD, PSP_DEVINFO_DATA));
283DLL_DECLARE_PREFIXED(WINAPI, BOOL, p, SetupDiDestroyDeviceInfoList, (HDEVINFO));
284DLL_DECLARE_PREFIXED(WINAPI, HKEY, p, SetupDiOpenDevRegKey, (HDEVINFO, PSP_DEVINFO_DATA, DWORD, DWORD, DWORD, REGSAM));
285DLL_DECLARE_PREFIXED(WINAPI, BOOL, p, SetupDiGetDeviceRegistryPropertyA, (HDEVINFO,
286 PSP_DEVINFO_DATA, DWORD, PDWORD, PBYTE, DWORD, PDWORD));
287DLL_DECLARE_PREFIXED(WINAPI, LONG, p, RegQueryValueExW, (HKEY, LPCWSTR, LPDWORD, LPDWORD, LPBYTE, LPDWORD));
288DLL_DECLARE_PREFIXED(WINAPI, LONG, p, RegCloseKey, (HKEY));
289
290/*
291 * Windows DDK API definitions. Most of it copied from MinGW's includes
292 */
293typedef DWORD DEVNODE, DEVINST;
294typedef DEVNODE *PDEVNODE, *PDEVINST;
295typedef DWORD RETURN_TYPE;
296typedef 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
348typedef 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
360typedef enum USB_HUB_NODE {
361 UsbHub,
362 UsbMIParent
363} USB_HUB_NODE;
364
365/* Cfgmgr32.dll interface */
366DLL_DECLARE(WINAPI, CONFIGRET, CM_Get_Parent, (PDEVINST, DEVINST, ULONG));
367DLL_DECLARE(WINAPI, CONFIGRET, CM_Get_Child, (PDEVINST, DEVINST, ULONG));
368DLL_DECLARE(WINAPI, CONFIGRET, CM_Get_Sibling, (PDEVINST, DEVINST, ULONG));
369DLL_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
398typedef 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
410typedef 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
421typedef 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
435typedef 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
444typedef 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
456typedef 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
466typedef struct USB_ROOT_HUB_NAME {
467 ULONG ActualLength;
468 WCHAR RootHubName[1];
469} USB_ROOT_HUB_NAME, *PUSB_ROOT_HUB_NAME;
470
471typedef struct USB_ROOT_HUB_NAME_FIXED {
472 ULONG ActualLength;
473 WCHAR RootHubName[MAX_PATH_LENGTH];
474} USB_ROOT_HUB_NAME_FIXED;
475
476typedef 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
482typedef 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
488typedef 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
495typedef struct USB_HUB_INFORMATION {
496 USB_HUB_DESCRIPTOR HubDescriptor;
497 BOOLEAN HubIsBusPowered;
498} USB_HUB_INFORMATION, *PUSB_HUB_INFORMATION;
499
500typedef struct USB_MI_PARENT_INFORMATION {
501 ULONG NumberOfInterfaces;
502} USB_MI_PARENT_INFORMATION, *PUSB_MI_PARENT_INFORMATION;
503
504typedef 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
512typedef struct USB_PIPE_INFO {
513 USB_ENDPOINT_DESCRIPTOR EndpointDescriptor;
514 ULONG ScheduleOffset;
515} USB_PIPE_INFO, *PUSB_PIPE_INFO;
516
517typedef 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
529typedef 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
539typedef struct USB_HUB_CAPABILITIES {
540 ULONG HubIs2xCapable : 1;
541} USB_HUB_CAPABILITIES, *PUSB_HUB_CAPABILITIES;
542
543typedef 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
566typedef enum USBD_PIPE_TYPE {
567 UsbdPipeTypeControl,
568 UsbdPipeTypeIsochronous,
569 UsbdPipeTypeBulk,
570 UsbdPipeTypeInterrupt
571} USBD_PIPE_TYPE;
572
573typedef 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)
581typedef 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
590typedef void *WINUSB_INTERFACE_HANDLE, *PWINUSB_INTERFACE_HANDLE;
591
592DLL_DECLARE(WINAPI, BOOL, WinUsb_Initialize, (HANDLE, PWINUSB_INTERFACE_HANDLE));
593DLL_DECLARE(WINAPI, BOOL, WinUsb_Free, (WINUSB_INTERFACE_HANDLE));
594DLL_DECLARE(WINAPI, BOOL, WinUsb_GetAssociatedInterface, (WINUSB_INTERFACE_HANDLE, UCHAR, PWINUSB_INTERFACE_HANDLE));
595DLL_DECLARE(WINAPI, BOOL, WinUsb_GetDescriptor, (WINUSB_INTERFACE_HANDLE, UCHAR, UCHAR, USHORT, PUCHAR, ULONG, PULONG));
596DLL_DECLARE(WINAPI, BOOL, WinUsb_QueryInterfaceSettings, (WINUSB_INTERFACE_HANDLE, UCHAR, PUSB_INTERFACE_DESCRIPTOR));
597DLL_DECLARE(WINAPI, BOOL, WinUsb_QueryDeviceInformation, (WINUSB_INTERFACE_HANDLE, ULONG, PULONG, PVOID));
598DLL_DECLARE(WINAPI, BOOL, WinUsb_SetCurrentAlternateSetting, (WINUSB_INTERFACE_HANDLE, UCHAR));
599DLL_DECLARE(WINAPI, BOOL, WinUsb_GetCurrentAlternateSetting, (WINUSB_INTERFACE_HANDLE, PUCHAR));
600DLL_DECLARE(WINAPI, BOOL, WinUsb_QueryPipe, (WINUSB_INTERFACE_HANDLE, UCHAR, UCHAR, PWINUSB_PIPE_INFORMATION));
601DLL_DECLARE(WINAPI, BOOL, WinUsb_SetPipePolicy, (WINUSB_INTERFACE_HANDLE, UCHAR, ULONG, ULONG, PVOID));
602DLL_DECLARE(WINAPI, BOOL, WinUsb_GetPipePolicy, (WINUSB_INTERFACE_HANDLE, UCHAR, ULONG, PULONG, PVOID));
603DLL_DECLARE(WINAPI, BOOL, WinUsb_ReadPipe, (WINUSB_INTERFACE_HANDLE, UCHAR, PUCHAR, ULONG, PULONG, LPOVERLAPPED));
604DLL_DECLARE(WINAPI, BOOL, WinUsb_WritePipe, (WINUSB_INTERFACE_HANDLE, UCHAR, PUCHAR, ULONG, PULONG, LPOVERLAPPED));
605DLL_DECLARE(WINAPI, BOOL, WinUsb_ControlTransfer, (WINUSB_INTERFACE_HANDLE, WINUSB_SETUP_PACKET, PUCHAR, ULONG, PULONG, LPOVERLAPPED));
606DLL_DECLARE(WINAPI, BOOL, WinUsb_ResetPipe, (WINUSB_INTERFACE_HANDLE, UCHAR));
607DLL_DECLARE(WINAPI, BOOL, WinUsb_AbortPipe, (WINUSB_INTERFACE_HANDLE, UCHAR));
608DLL_DECLARE(WINAPI, BOOL, WinUsb_FlushPipe, (WINUSB_INTERFACE_HANDLE, UCHAR));
Note: See TracBrowser for help on using the repository browser.