libusb/os/windows_usb.h

   1 /*
   2  * Windows backend for libusbx 1.0
   3  * Copyright © 2009-2012 Pete Batard <pete@akeo.ie>
   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 #define _stricmp stricmp
  54 // cygwin produces a warning unless these prototypes are defined
  55 extern int _snprintf(char *buffer, size_t count, const char *format, ...);
  56 extern char *_strdup(const char *strSource);
  57 // _beginthreadex is MSVCRT => unavailable for cygwin. Fallback to using CreateThread
  58 #define _beginthreadex(a, b, c, d, e, f) CreateThread(a, b, (LPTHREAD_START_ROUTINE)c, d, e, f)
  59 #endif
  60 #define safe_free(p) do {if (p != NULL) {free((void*)p); p = NULL;}} while(0)
  61 #define safe_closehandle(h) do {if (h != INVALID_HANDLE_VALUE) {CloseHandle(h); h = INVALID_HANDLE_VALUE;}} while(0)
  62 #define safe_min(a, b) min((size_t)(a), (size_t)(b))
  63 #define safe_strcp(dst, dst_max, src, count) do {memcpy(dst, src, safe_min(count, dst_max)); \
  64         ((char*)dst)[safe_min(count, dst_max)-1] = 0;} while(0)
  65 #define safe_strcpy(dst, dst_max, src) safe_strcp(dst, dst_max, src, safe_strlen(src)+1)
  66 #define safe_strncat(dst, dst_max, src, count) strncat(dst, src, safe_min(count, dst_max - safe_strlen(dst) - 1))
  67 #define safe_strcat(dst, dst_max, src) safe_strncat(dst, dst_max, src, safe_strlen(src)+1)
  68 #define safe_strcmp(str1, str2) strcmp(((str1==NULL)?"<NULL>":str1), ((str2==NULL)?"<NULL>":str2))
  69 #define safe_stricmp(str1, str2) _stricmp(((str1==NULL)?"<NULL>":str1), ((str2==NULL)?"<NULL>":str2))
  70 #define safe_strncmp(str1, str2, count) strncmp(((str1==NULL)?"<NULL>":str1), ((str2==NULL)?"<NULL>":str2), count)
  71 #define safe_strlen(str) ((str==NULL)?0:strlen(str))
  72 #define safe_sprintf _snprintf
  73 #define safe_unref_device(dev) do {if (dev != NULL) {libusb_unref_device(dev); dev = NULL;}} while(0)
  74 #define wchar_to_utf8_ms(wstr, str, strlen) WideCharToMultiByte(CP_UTF8, 0, wstr, -1, str, strlen, NULL, NULL)
  75 #ifndef ARRAYSIZE
  76 #define ARRAYSIZE(A) (sizeof(A)/sizeof((A)[0]))
  77 #endif
  78
  79 #define MAX_CTRL_BUFFER_LENGTH      4096
  80 #define MAX_USB_DEVICES             256
  81 #define MAX_USB_STRING_LENGTH       128
  82 #define MAX_HID_REPORT_SIZE         1024
  83 #define MAX_HID_DESCRIPTOR_SIZE     256
  84 #define MAX_GUID_STRING_LENGTH      40
  85 #define MAX_PATH_LENGTH             128
  86 #define MAX_KEY_LENGTH              256
  87 #define MAX_TIMER_SEMAPHORES        128
  88 #define TIMER_REQUEST_RETRY_MS      100
  89 #define ERR_BUFFER_SIZE             256
  90 #define LIST_SEPARATOR              ';'
  91 #define HTAB_SIZE                   1021
  92
  93 // Handle code for HID interface that have been claimed ("dibs")
  94 #define INTERFACE_CLAIMED           ((HANDLE)(intptr_t)0xD1B5)
  95 // Additional return code for HID operations that completed synchronously
  96 #define LIBUSB_COMPLETED            (LIBUSB_SUCCESS + 1)
  97
  98 // http://msdn.microsoft.com/en-us/library/ff545978.aspx
  99 // http://msdn.microsoft.com/en-us/library/ff545972.aspx
 100 // http://msdn.microsoft.com/en-us/library/ff545982.aspx
 101 #if !defined(GUID_DEVINTERFACE_USB_HOST_CONTROLLER)
 102 const GUID GUID_DEVINTERFACE_USB_HOST_CONTROLLER = { 0x3ABF6F2D, 0x71C4, 0x462A, {0x8A, 0x92, 0x1E, 0x68, 0x61, 0xE6, 0xAF, 0x27} };
 103 #endif
 104 #if !defined(GUID_DEVINTERFACE_USB_DEVICE)
 105 const GUID GUID_DEVINTERFACE_USB_DEVICE = { 0xA5DCBF10, 0x6530, 0x11D2, {0x90, 0x1F, 0x00, 0xC0, 0x4F, 0xB9, 0x51, 0xED} };
 106 #endif
 107 #if !defined(GUID_DEVINTERFACE_USB_HUB)
 108 const GUID GUID_DEVINTERFACE_USB_HUB = { 0xF18A0E88, 0xC30C, 0x11D0, {0x88, 0x15, 0x00, 0xA0, 0xC9, 0x06, 0xBE, 0xD8} };
 109 #endif
 110 #if !defined(GUID_DEVINTERFACE_LIBUSB0_FILTER)
 111 const GUID GUID_DEVINTERFACE_LIBUSB0_FILTER = { 0xF9F3FF14, 0xAE21, 0x48A0, {0x8A, 0x25, 0x80, 0x11, 0xA7, 0xA9, 0x31, 0xD9} };
 112 #endif
 113
 114
 115 /*
 116  * Multiple USB API backend support
 117  */
 118 #define USB_API_UNSUPPORTED 0
 119 #define USB_API_HUB         1
 120 #define USB_API_COMPOSITE   2
 121 #define USB_API_WINUSBX     3
 122 #define USB_API_HID         4
 123 #define USB_API_MAX         5
 124 // The following is used to indicate if the HID or composite extra props have already been set.
 125 #define USB_API_SET         (1<<USB_API_MAX)
 126
 127 // Sub-APIs for WinUSB-like driver APIs (WinUSB, libusbK, libusb-win32 through the libusbK DLL)
 128 // Must have the same values as the KUSB_DRVID enum from libusbk.h
 129 #define SUB_API_NOTSET      -1
 130 #define SUB_API_LIBUSBK     0
 131 #define SUB_API_LIBUSB0     1
 132 #define SUB_API_WINUSB      2
 133 #define SUB_API_MAX         3
 134
 135 #define WINUSBX_DRV_NAMES   { "libusbK", "libusb0", "WinUSB"}
 136
 137 struct windows_usb_api_backend {
 138         const uint8_t id;
 139         const char* designation;
 140         const char **driver_name_list; // Driver name, without .sys, e.g. "usbccgp"
 141         const uint8_t nb_driver_names;
 142         int (*init)(int sub_api, struct libusb_context *ctx);
 143         int (*exit)(int sub_api);
 144         int (*open)(int sub_api, struct libusb_device_handle *dev_handle);
 145         void (*close)(int sub_api, struct libusb_device_handle *dev_handle);
 146         int (*configure_endpoints)(int sub_api, struct libusb_device_handle *dev_handle, int iface);
 147         int (*claim_interface)(int sub_api, struct libusb_device_handle *dev_handle, int iface);
 148         int (*set_interface_altsetting)(int sub_api, struct libusb_device_handle *dev_handle, int iface, int altsetting);
 149         int (*release_interface)(int sub_api, struct libusb_device_handle *dev_handle, int iface);
 150         int (*clear_halt)(int sub_api, struct libusb_device_handle *dev_handle, unsigned char endpoint);
 151         int (*reset_device)(int sub_api, struct libusb_device_handle *dev_handle);
 152         int (*submit_bulk_transfer)(int sub_api, struct usbi_transfer *itransfer);
 153         int (*submit_iso_transfer)(int sub_api, struct usbi_transfer *itransfer);
 154         int (*submit_control_transfer)(int sub_api, struct usbi_transfer *itransfer);
 155         int (*abort_control)(int sub_api, struct usbi_transfer *itransfer);
 156         int (*abort_transfers)(int sub_api, struct usbi_transfer *itransfer);
 157         int (*copy_transfer_data)(int sub_api, struct usbi_transfer *itransfer, uint32_t io_size);
 158 };
 159
 160 extern const struct windows_usb_api_backend usb_api_backend[USB_API_MAX];
 161
 162 #define PRINT_UNSUPPORTED_API(fname)              \
 163         usbi_dbg("unsupported API call for '"         \
 164                 #fname "' (unrecognized device driver)"); \
 165         return LIBUSB_ERROR_NOT_SUPPORTED;
 166
 167 /*
 168  * private structures definition
 169  * with inline pseudo constructors/destructors
 170  */
 171
 172 // TODO (v2+): move hid desc to libusb.h?
 173 struct libusb_hid_descriptor {
 174         uint8_t  bLength;
 175         uint8_t  bDescriptorType;
 176         uint16_t bcdHID;
 177         uint8_t  bCountryCode;
 178         uint8_t  bNumDescriptors;
 179         uint8_t  bClassDescriptorType;
 180         uint16_t wClassDescriptorLength;
 181 };
 182 #define LIBUSB_DT_HID_SIZE              9
 183 #define HID_MAX_CONFIG_DESC_SIZE (LIBUSB_DT_CONFIG_SIZE + LIBUSB_DT_INTERFACE_SIZE \
 184         + LIBUSB_DT_HID_SIZE + 2 * LIBUSB_DT_ENDPOINT_SIZE)
 185 #define HID_MAX_REPORT_SIZE             1024
 186 #define HID_IN_EP                       0x81
 187 #define HID_OUT_EP                      0x02
 188 #define LIBUSB_REQ_RECIPIENT(request_type) ((request_type) & 0x1F)
 189 #define LIBUSB_REQ_TYPE(request_type) ((request_type) & (0x03 << 5))
 190 #define LIBUSB_REQ_IN(request_type) ((request_type) & LIBUSB_ENDPOINT_IN)
 191 #define LIBUSB_REQ_OUT(request_type) (!LIBUSB_REQ_IN(request_type))
 192
 193 // The following are used for HID reports IOCTLs
 194 #define HID_CTL_CODE(id) \
 195   CTL_CODE (FILE_DEVICE_KEYBOARD, (id), METHOD_NEITHER, FILE_ANY_ACCESS)
 196 #define HID_BUFFER_CTL_CODE(id) \
 197   CTL_CODE (FILE_DEVICE_KEYBOARD, (id), METHOD_BUFFERED, FILE_ANY_ACCESS)
 198 #define HID_IN_CTL_CODE(id) \
 199   CTL_CODE (FILE_DEVICE_KEYBOARD, (id), METHOD_IN_DIRECT, FILE_ANY_ACCESS)
 200 #define HID_OUT_CTL_CODE(id) \
 201   CTL_CODE (FILE_DEVICE_KEYBOARD, (id), METHOD_OUT_DIRECT, FILE_ANY_ACCESS)
 202
 203 #define IOCTL_HID_GET_FEATURE                 HID_OUT_CTL_CODE(100)
 204 #define IOCTL_HID_GET_INPUT_REPORT            HID_OUT_CTL_CODE(104)
 205 #define IOCTL_HID_SET_FEATURE                 HID_IN_CTL_CODE(100)
 206 #define IOCTL_HID_SET_OUTPUT_REPORT           HID_IN_CTL_CODE(101)
 207
 208 enum libusb_hid_request_type {
 209         HID_REQ_GET_REPORT = 0x01,
 210         HID_REQ_GET_IDLE = 0x02,
 211         HID_REQ_GET_PROTOCOL = 0x03,
 212         HID_REQ_SET_REPORT = 0x09,
 213         HID_REQ_SET_IDLE = 0x0A,
 214         HID_REQ_SET_PROTOCOL = 0x0B
 215 };
 216
 217 enum libusb_hid_report_type {
 218         HID_REPORT_TYPE_INPUT = 0x01,
 219         HID_REPORT_TYPE_OUTPUT = 0x02,
 220         HID_REPORT_TYPE_FEATURE = 0x03
 221 };
 222
 223 struct hid_device_priv {
 224         uint16_t vid;
 225         uint16_t pid;
 226         uint8_t config;
 227         uint8_t nb_interfaces;
 228         bool uses_report_ids[3];        // input, ouptput, feature
 229         uint16_t input_report_size;
 230         uint16_t output_report_size;
 231         uint16_t feature_report_size;
 232         WCHAR string[3][MAX_USB_STRING_LENGTH];
 233         uint8_t string_index[3];        // man, prod, ser
 234 };
 235
 236 typedef struct libusb_device_descriptor USB_DEVICE_DESCRIPTOR, *PUSB_DEVICE_DESCRIPTOR;
 237 struct windows_device_priv {
 238         uint8_t depth;                                          // distance to HCD
 239         uint8_t port;                                           // port number on the hub
 240         uint8_t active_config;
 241         uint8_t api_flags;                                      // HID and composite devices require additional data
 242         struct libusb_device *parent_dev;       // access to parent is required for usermode ops
 243         struct windows_usb_api_backend const *apib;
 244         char *path;                                                     // device interface path
 245         int sub_api;                                            // for WinUSB-like APIs
 246         struct {
 247                 char *path;                                             // each interface needs a device interface path,
 248                 struct windows_usb_api_backend const *apib; // an API backend (multiple drivers support),
 249                 int sub_api;
 250                 int8_t nb_endpoints;                    // and a set of endpoint addresses (USB_MAXENDPOINTS)
 251                 uint8_t *endpoint;
 252                 bool restricted_functionality;  // indicates if the interface functionality is restricted
 253                                                                                 // by Windows (eg. HID keyboards or mice cannot do R/W)
 254         } usb_interface[USB_MAXINTERFACES];
 255         struct hid_device_priv *hid;
 256         USB_DEVICE_DESCRIPTOR dev_descriptor;
 257         unsigned char **config_descriptor;      // list of pointers to the cached config descriptors
 258 };
 259
 260 static inline struct windows_device_priv *_device_priv(struct libusb_device *dev) {
 261         return (struct windows_device_priv *)dev->os_priv;
 262 }
 263
 264 static inline void windows_device_priv_init(libusb_device* dev) {
 265         struct windows_device_priv* p = _device_priv(dev);
 266         int i;
 267         p->depth = 0;
 268         p->port = 0;
 269         p->parent_dev = NULL;
 270         p->path = NULL;
 271         p->apib = &usb_api_backend[USB_API_UNSUPPORTED];
 272         p->api_flags = 0;
 273         p->sub_api = SUB_API_NOTSET;
 274         p->hid = NULL;
 275         p->active_config = 0;
 276         p->config_descriptor = NULL;
 277         memset(&(p->dev_descriptor), 0, sizeof(USB_DEVICE_DESCRIPTOR));
 278         for (i=0; i<USB_MAXINTERFACES; i++) {
 279                 p->usb_interface[i].path = NULL;
 280                 p->usb_interface[i].apib = &usb_api_backend[USB_API_UNSUPPORTED];
 281                 p->usb_interface[i].sub_api = SUB_API_NOTSET;
 282                 p->usb_interface[i].nb_endpoints = 0;
 283                 p->usb_interface[i].endpoint = NULL;
 284                 p->usb_interface[i].restricted_functionality = false;
 285         }
 286 }
 287
 288 static inline void windows_device_priv_release(libusb_device* dev) {
 289         struct windows_device_priv* p = _device_priv(dev);
 290         int i;
 291         safe_free(p->path);
 292         if ((dev->num_configurations > 0) && (p->config_descriptor != NULL)) {
 293                 for (i=0; i < dev->num_configurations; i++)
 294                         safe_free(p->config_descriptor[i]);
 295         }
 296         safe_free(p->config_descriptor);
 297         safe_free(p->hid);
 298         for (i=0; i<USB_MAXINTERFACES; i++) {
 299                 safe_free(p->usb_interface[i].path);
 300                 safe_free(p->usb_interface[i].endpoint);
 301         }
 302 }
 303
 304 struct interface_handle_t {
 305         HANDLE dev_handle; // WinUSB needs an extra handle for the file
 306         HANDLE api_handle; // used by the API to communicate with the device
 307 };
 308
 309 struct windows_device_handle_priv {
 310         int active_interface;
 311         struct interface_handle_t interface_handle[USB_MAXINTERFACES];
 312         int autoclaim_count[USB_MAXINTERFACES]; // For auto-release
 313 };
 314
 315 static inline struct windows_device_handle_priv *_device_handle_priv(
 316         struct libusb_device_handle *handle)
 317 {
 318         return (struct windows_device_handle_priv *) handle->os_priv;
 319 }
 320
 321 // used for async polling functions
 322 struct windows_transfer_priv {
 323         struct winfd pollable_fd;
 324         uint8_t interface_number;
 325         uint8_t *hid_buffer; // 1 byte extended data buffer, required for HID
 326         uint8_t *hid_dest;   // transfer buffer destination, required for HID
 327         size_t hid_expected_size;
 328 };
 329
 330 // used to match a device driver (including filter drivers) against a supported API
 331 struct driver_lookup {
 332         char list[MAX_KEY_LENGTH+1];// REG_MULTI_SZ list of services (driver) names
 333         const DWORD reg_prop;           // SPDRP registry key to use to retreive list
 334         const char* designation;        // internal designation (for debug output)
 335 };
 336
 337 /*
 338  * API macros - from libusb-win32 1.x
 339  */
 340 #define DLL_DECLARE_PREFIXNAME(api, ret, prefixname, name, args)    \
 341         typedef ret (api * __dll_##name##_t)args;                       \
 342         static __dll_##name##_t prefixname = NULL
 343
 344 #define DLL_LOAD_PREFIXNAME(dll, prefixname, name, ret_on_failure) \
 345         do {                                                           \
 346                 HMODULE h = GetModuleHandleA(#dll);                        \
 347         if (!h)                                                        \
 348                 h = LoadLibraryA(#dll);                                    \
 349         if (!h) {                                                      \
 350                 if (ret_on_failure) { return LIBUSB_ERROR_NOT_FOUND; }     \
 351                 else { break; }                                            \
 352         }                                                              \
 353         prefixname = (__dll_##name##_t)GetProcAddress(h, #name);       \
 354         if (prefixname) break;                                         \
 355         prefixname = (__dll_##name##_t)GetProcAddress(h, #name "A");   \
 356         if (prefixname) break;                                         \
 357         prefixname = (__dll_##name##_t)GetProcAddress(h, #name "W");   \
 358         if (prefixname) break;                                         \
 359         if(ret_on_failure)                                             \
 360                 return LIBUSB_ERROR_NOT_FOUND;                             \
 361         } while(0)
 362
 363 #define DLL_DECLARE(api, ret, name, args)   DLL_DECLARE_PREFIXNAME(api, ret, name, name, args)
 364 #define DLL_LOAD(dll, name, ret_on_failure) DLL_LOAD_PREFIXNAME(dll, name, name, ret_on_failure)
 365 #define DLL_DECLARE_PREFIXED(api, ret, prefix, name, args)   DLL_DECLARE_PREFIXNAME(api, ret, prefix##name, name, args)
 366 #define DLL_LOAD_PREFIXED(dll, prefix, name, ret_on_failure) DLL_LOAD_PREFIXNAME(dll, prefix##name, name, ret_on_failure)
 367
 368 /* OLE32 dependency */
 369 DLL_DECLARE_PREFIXED(WINAPI, HRESULT, p, CLSIDFromString, (LPCOLESTR, LPCLSID));
 370
 371 /* SetupAPI dependencies */
 372 DLL_DECLARE_PREFIXED(WINAPI, HDEVINFO, p, SetupDiGetClassDevsA, (const GUID*, PCSTR, HWND, DWORD));
 373 DLL_DECLARE_PREFIXED(WINAPI, BOOL, p, SetupDiEnumDeviceInfo, (HDEVINFO, DWORD, PSP_DEVINFO_DATA));
 374 DLL_DECLARE_PREFIXED(WINAPI, BOOL, p, SetupDiEnumDeviceInterfaces, (HDEVINFO, PSP_DEVINFO_DATA,
 375                         const GUID*, DWORD, PSP_DEVICE_INTERFACE_DATA));
 376 DLL_DECLARE_PREFIXED(WINAPI, BOOL, p, SetupDiGetDeviceInterfaceDetailA, (HDEVINFO, PSP_DEVICE_INTERFACE_DATA,
 377                         PSP_DEVICE_INTERFACE_DETAIL_DATA_A, DWORD, PDWORD, PSP_DEVINFO_DATA));
 378 DLL_DECLARE_PREFIXED(WINAPI, BOOL, p, SetupDiDestroyDeviceInfoList, (HDEVINFO));
 379 DLL_DECLARE_PREFIXED(WINAPI, HKEY, p, SetupDiOpenDevRegKey, (HDEVINFO, PSP_DEVINFO_DATA, DWORD, DWORD, DWORD, REGSAM));
 380 DLL_DECLARE_PREFIXED(WINAPI, BOOL, p, SetupDiGetDeviceRegistryPropertyA, (HDEVINFO,
 381                         PSP_DEVINFO_DATA, DWORD, PDWORD, PBYTE, DWORD, PDWORD));
 382 DLL_DECLARE_PREFIXED(WINAPI, HKEY, p, SetupDiOpenDeviceInterfaceRegKey, (HDEVINFO, PSP_DEVICE_INTERFACE_DATA, DWORD, DWORD));
 383 DLL_DECLARE_PREFIXED(WINAPI, LONG, p, RegQueryValueExW, (HKEY, LPCWSTR, LPDWORD, LPDWORD, LPBYTE, LPDWORD));
 384 DLL_DECLARE_PREFIXED(WINAPI, LONG, p, RegCloseKey, (HKEY));
 385
 386 /*
 387  * Windows DDK API definitions. Most of it copied from MinGW's includes
 388  */
 389 typedef DWORD DEVNODE, DEVINST;
 390 typedef DEVNODE *PDEVNODE, *PDEVINST;
 391 typedef DWORD RETURN_TYPE;
 392 typedef RETURN_TYPE CONFIGRET;
 393
 394 #define CR_SUCCESS                              0x00000000
 395 #define CR_NO_SUCH_DEVNODE                      0x0000000D
 396
 397 #define USB_DEVICE_DESCRIPTOR_TYPE              LIBUSB_DT_DEVICE
 398 #define USB_CONFIGURATION_DESCRIPTOR_TYPE       LIBUSB_DT_CONFIG
 399 #define USB_STRING_DESCRIPTOR_TYPE              LIBUSB_DT_STRING
 400 #define USB_INTERFACE_DESCRIPTOR_TYPE           LIBUSB_DT_INTERFACE
 401 #define USB_ENDPOINT_DESCRIPTOR_TYPE            LIBUSB_DT_ENDPOINT
 402
 403 #define USB_REQUEST_GET_STATUS                  LIBUSB_REQUEST_GET_STATUS
 404 #define USB_REQUEST_CLEAR_FEATURE               LIBUSB_REQUEST_CLEAR_FEATURE
 405 #define USB_REQUEST_SET_FEATURE                 LIBUSB_REQUEST_SET_FEATURE
 406 #define USB_REQUEST_SET_ADDRESS                 LIBUSB_REQUEST_SET_ADDRESS
 407 #define USB_REQUEST_GET_DESCRIPTOR              LIBUSB_REQUEST_GET_DESCRIPTOR
 408 #define USB_REQUEST_SET_DESCRIPTOR              LIBUSB_REQUEST_SET_DESCRIPTOR
 409 #define USB_REQUEST_GET_CONFIGURATION           LIBUSB_REQUEST_GET_CONFIGURATION
 410 #define USB_REQUEST_SET_CONFIGURATION           LIBUSB_REQUEST_SET_CONFIGURATION
 411 #define USB_REQUEST_GET_INTERFACE               LIBUSB_REQUEST_GET_INTERFACE
 412 #define USB_REQUEST_SET_INTERFACE               LIBUSB_REQUEST_SET_INTERFACE
 413 #define USB_REQUEST_SYNC_FRAME                  LIBUSB_REQUEST_SYNCH_FRAME
 414
 415 #define USB_GET_NODE_INFORMATION                258
 416 #define USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION 260
 417 #define USB_GET_NODE_CONNECTION_NAME            261
 418 #define USB_GET_HUB_CAPABILITIES                271
 419 #if !defined(USB_GET_NODE_CONNECTION_INFORMATION_EX)
 420 #define USB_GET_NODE_CONNECTION_INFORMATION_EX  274
 421 #endif
 422 #if !defined(USB_GET_HUB_CAPABILITIES_EX)
 423 #define USB_GET_HUB_CAPABILITIES_EX             276
 424 #endif
 425
 426 #ifndef METHOD_BUFFERED
 427 #define METHOD_BUFFERED                         0
 428 #endif
 429 #ifndef FILE_ANY_ACCESS
 430 #define FILE_ANY_ACCESS                         0x00000000
 431 #endif
 432 #ifndef FILE_DEVICE_UNKNOWN
 433 #define FILE_DEVICE_UNKNOWN                     0x00000022
 434 #endif
 435 #ifndef FILE_DEVICE_USB
 436 #define FILE_DEVICE_USB                         FILE_DEVICE_UNKNOWN
 437 #endif
 438
 439 #ifndef CTL_CODE
 440 #define CTL_CODE(DeviceType, Function, Method, Access)( \
 441   ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method))
 442 #endif
 443
 444 typedef enum USB_CONNECTION_STATUS {
 445         NoDeviceConnected,
 446         DeviceConnected,
 447         DeviceFailedEnumeration,
 448         DeviceGeneralFailure,
 449         DeviceCausedOvercurrent,
 450         DeviceNotEnoughPower,
 451         DeviceNotEnoughBandwidth,
 452         DeviceHubNestedTooDeeply,
 453         DeviceInLegacyHub
 454 } USB_CONNECTION_STATUS, *PUSB_CONNECTION_STATUS;
 455
 456 typedef enum USB_HUB_NODE {
 457         UsbHub,
 458         UsbMIParent
 459 } USB_HUB_NODE;
 460
 461 /* Cfgmgr32.dll interface */
 462 DLL_DECLARE(WINAPI, CONFIGRET, CM_Get_Parent, (PDEVINST, DEVINST, ULONG));
 463 DLL_DECLARE(WINAPI, CONFIGRET, CM_Get_Child, (PDEVINST, DEVINST, ULONG));
 464 DLL_DECLARE(WINAPI, CONFIGRET, CM_Get_Sibling, (PDEVINST, DEVINST, ULONG));
 465 DLL_DECLARE(WINAPI, CONFIGRET, CM_Get_Device_IDA, (DEVINST, PCHAR, ULONG, ULONG));
 466
 467 #define IOCTL_USB_GET_HUB_CAPABILITIES_EX \
 468   CTL_CODE( FILE_DEVICE_USB, USB_GET_HUB_CAPABILITIES_EX, METHOD_BUFFERED, FILE_ANY_ACCESS)
 469
 470 #define IOCTL_USB_GET_HUB_CAPABILITIES \
 471   CTL_CODE(FILE_DEVICE_USB, USB_GET_HUB_CAPABILITIES, METHOD_BUFFERED, FILE_ANY_ACCESS)
 472
 473 #define IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION \
 474   CTL_CODE(FILE_DEVICE_USB, USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION, METHOD_BUFFERED, FILE_ANY_ACCESS)
 475
 476 #define IOCTL_USB_GET_ROOT_HUB_NAME \
 477   CTL_CODE(FILE_DEVICE_USB, HCD_GET_ROOT_HUB_NAME, METHOD_BUFFERED, FILE_ANY_ACCESS)
 478
 479 #define IOCTL_USB_GET_NODE_INFORMATION \
 480   CTL_CODE(FILE_DEVICE_USB, USB_GET_NODE_INFORMATION, METHOD_BUFFERED, FILE_ANY_ACCESS)
 481
 482 #define IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX \
 483   CTL_CODE(FILE_DEVICE_USB, USB_GET_NODE_CONNECTION_INFORMATION_EX, METHOD_BUFFERED, FILE_ANY_ACCESS)
 484
 485 #define IOCTL_USB_GET_NODE_CONNECTION_ATTRIBUTES \
 486   CTL_CODE(FILE_DEVICE_USB, USB_GET_NODE_CONNECTION_ATTRIBUTES, METHOD_BUFFERED, FILE_ANY_ACCESS)
 487
 488 #define IOCTL_USB_GET_NODE_CONNECTION_NAME \
 489   CTL_CODE(FILE_DEVICE_USB, USB_GET_NODE_CONNECTION_NAME, METHOD_BUFFERED, FILE_ANY_ACCESS)
 490
 491 // Most of the structures below need to be packed
 492 #pragma pack(push, 1)
 493
 494 typedef struct USB_INTERFACE_DESCRIPTOR {
 495   UCHAR  bLength;
 496   UCHAR  bDescriptorType;
 497   UCHAR  bInterfaceNumber;
 498   UCHAR  bAlternateSetting;
 499   UCHAR  bNumEndpoints;
 500   UCHAR  bInterfaceClass;
 501   UCHAR  bInterfaceSubClass;
 502   UCHAR  bInterfaceProtocol;
 503   UCHAR  iInterface;
 504 } USB_INTERFACE_DESCRIPTOR, *PUSB_INTERFACE_DESCRIPTOR;
 505
 506 typedef struct USB_CONFIGURATION_DESCRIPTOR {
 507   UCHAR  bLength;
 508   UCHAR  bDescriptorType;
 509   USHORT wTotalLength;
 510   UCHAR  bNumInterfaces;
 511   UCHAR  bConfigurationValue;
 512   UCHAR  iConfiguration;
 513   UCHAR  bmAttributes;
 514   UCHAR  MaxPower;
 515 } USB_CONFIGURATION_DESCRIPTOR, *PUSB_CONFIGURATION_DESCRIPTOR;
 516
 517 typedef struct USB_CONFIGURATION_DESCRIPTOR_SHORT {
 518         struct {
 519                 ULONG ConnectionIndex;
 520                 struct {
 521                         UCHAR bmRequest;
 522                         UCHAR bRequest;
 523                         USHORT wValue;
 524                         USHORT wIndex;
 525                         USHORT wLength;
 526                 } SetupPacket;
 527         } req;
 528         USB_CONFIGURATION_DESCRIPTOR data;
 529 } USB_CONFIGURATION_DESCRIPTOR_SHORT;
 530
 531 typedef struct USB_ENDPOINT_DESCRIPTOR {
 532   UCHAR  bLength;
 533   UCHAR  bDescriptorType;
 534   UCHAR  bEndpointAddress;
 535   UCHAR  bmAttributes;
 536   USHORT  wMaxPacketSize;
 537   UCHAR  bInterval;
 538 } USB_ENDPOINT_DESCRIPTOR, *PUSB_ENDPOINT_DESCRIPTOR;
 539
 540 typedef struct USB_DESCRIPTOR_REQUEST {
 541         ULONG  ConnectionIndex;
 542         struct {
 543                 UCHAR  bmRequest;
 544                 UCHAR  bRequest;
 545                 USHORT  wValue;
 546                 USHORT  wIndex;
 547                 USHORT  wLength;
 548         } SetupPacket;
 549 //      UCHAR  Data[0];
 550 } USB_DESCRIPTOR_REQUEST, *PUSB_DESCRIPTOR_REQUEST;
 551
 552 typedef struct USB_HUB_DESCRIPTOR {
 553         UCHAR  bDescriptorLength;
 554         UCHAR  bDescriptorType;
 555         UCHAR  bNumberOfPorts;
 556         USHORT  wHubCharacteristics;
 557         UCHAR  bPowerOnToPowerGood;
 558         UCHAR  bHubControlCurrent;
 559         UCHAR  bRemoveAndPowerMask[64];
 560 } USB_HUB_DESCRIPTOR, *PUSB_HUB_DESCRIPTOR;
 561
 562 typedef struct USB_ROOT_HUB_NAME {
 563         ULONG  ActualLength;
 564         WCHAR  RootHubName[1];
 565 } USB_ROOT_HUB_NAME, *PUSB_ROOT_HUB_NAME;
 566
 567 typedef struct USB_ROOT_HUB_NAME_FIXED {
 568         ULONG ActualLength;
 569         WCHAR RootHubName[MAX_PATH_LENGTH];
 570 } USB_ROOT_HUB_NAME_FIXED;
 571
 572 typedef struct USB_NODE_CONNECTION_NAME {
 573         ULONG  ConnectionIndex;
 574         ULONG  ActualLength;
 575         WCHAR  NodeName[1];
 576 } USB_NODE_CONNECTION_NAME, *PUSB_NODE_CONNECTION_NAME;
 577
 578 typedef struct USB_NODE_CONNECTION_NAME_FIXED {
 579         ULONG ConnectionIndex;
 580         ULONG ActualLength;
 581         WCHAR NodeName[MAX_PATH_LENGTH];
 582 } USB_NODE_CONNECTION_NAME_FIXED;
 583
 584 typedef struct USB_HUB_NAME_FIXED {
 585         union {
 586                 USB_ROOT_HUB_NAME_FIXED root;
 587                 USB_NODE_CONNECTION_NAME_FIXED node;
 588         } u;
 589 } USB_HUB_NAME_FIXED;
 590
 591 typedef struct USB_HUB_INFORMATION {
 592         USB_HUB_DESCRIPTOR  HubDescriptor;
 593         BOOLEAN  HubIsBusPowered;
 594 } USB_HUB_INFORMATION, *PUSB_HUB_INFORMATION;
 595
 596 typedef struct USB_MI_PARENT_INFORMATION {
 597   ULONG  NumberOfInterfaces;
 598 } USB_MI_PARENT_INFORMATION, *PUSB_MI_PARENT_INFORMATION;
 599
 600 typedef struct USB_NODE_INFORMATION {
 601         USB_HUB_NODE  NodeType;
 602         union {
 603                 USB_HUB_INFORMATION  HubInformation;
 604                 USB_MI_PARENT_INFORMATION  MiParentInformation;
 605         } u;
 606 } USB_NODE_INFORMATION, *PUSB_NODE_INFORMATION;
 607
 608 typedef struct USB_PIPE_INFO {
 609         USB_ENDPOINT_DESCRIPTOR  EndpointDescriptor;
 610         ULONG  ScheduleOffset;
 611 } USB_PIPE_INFO, *PUSB_PIPE_INFO;
 612
 613 typedef struct USB_NODE_CONNECTION_INFORMATION_EX {
 614         ULONG  ConnectionIndex;
 615         USB_DEVICE_DESCRIPTOR  DeviceDescriptor;
 616         UCHAR  CurrentConfigurationValue;
 617         UCHAR  Speed;
 618         BOOLEAN  DeviceIsHub;
 619         USHORT  DeviceAddress;
 620         ULONG  NumberOfOpenPipes;
 621         USB_CONNECTION_STATUS  ConnectionStatus;
 622 //      USB_PIPE_INFO  PipeList[0];
 623 } USB_NODE_CONNECTION_INFORMATION_EX, *PUSB_NODE_CONNECTION_INFORMATION_EX;
 624
 625 typedef struct USB_HUB_CAP_FLAGS {
 626         ULONG HubIsHighSpeedCapable:1;
 627         ULONG HubIsHighSpeed:1;
 628         ULONG HubIsMultiTtCapable:1;
 629         ULONG HubIsMultiTt:1;
 630         ULONG HubIsRoot:1;
 631         ULONG HubIsArmedWakeOnConnect:1;
 632         ULONG ReservedMBZ:26;
 633 } USB_HUB_CAP_FLAGS, *PUSB_HUB_CAP_FLAGS;
 634
 635 typedef struct USB_HUB_CAPABILITIES {
 636   ULONG  HubIs2xCapable : 1;
 637 } USB_HUB_CAPABILITIES, *PUSB_HUB_CAPABILITIES;
 638
 639 typedef struct USB_HUB_CAPABILITIES_EX {
 640         USB_HUB_CAP_FLAGS CapabilityFlags;
 641 } USB_HUB_CAPABILITIES_EX, *PUSB_HUB_CAPABILITIES_EX;
 642
 643 #pragma pack(pop)
 644
 645 /* winusb.dll interface */
 646
 647 #define SHORT_PACKET_TERMINATE  0x01
 648 #define AUTO_CLEAR_STALL        0x02
 649 #define PIPE_TRANSFER_TIMEOUT   0x03
 650 #define IGNORE_SHORT_PACKETS    0x04
 651 #define ALLOW_PARTIAL_READS     0x05
 652 #define AUTO_FLUSH              0x06
 653 #define RAW_IO                  0x07
 654 #define MAXIMUM_TRANSFER_SIZE   0x08
 655 #define AUTO_SUSPEND            0x81
 656 #define SUSPEND_DELAY           0x83
 657 #define DEVICE_SPEED            0x01
 658 #define LowSpeed                0x01
 659 #define FullSpeed               0x02
 660 #define HighSpeed               0x03
 661
 662 typedef enum USBD_PIPE_TYPE {
 663         UsbdPipeTypeControl,
 664         UsbdPipeTypeIsochronous,
 665         UsbdPipeTypeBulk,
 666         UsbdPipeTypeInterrupt
 667 } USBD_PIPE_TYPE;
 668
 669 typedef struct {
 670   USBD_PIPE_TYPE PipeType;
 671   UCHAR          PipeId;
 672   USHORT         MaximumPacketSize;
 673   UCHAR          Interval;
 674 } WINUSB_PIPE_INFORMATION, *PWINUSB_PIPE_INFORMATION;
 675
 676 #pragma pack(1)
 677 typedef struct {
 678   UCHAR  request_type;
 679   UCHAR  request;
 680   USHORT value;
 681   USHORT index;
 682   USHORT length;
 683 } WINUSB_SETUP_PACKET, *PWINUSB_SETUP_PACKET;
 684 #pragma pack()
 685
 686 typedef void *WINUSB_INTERFACE_HANDLE, *PWINUSB_INTERFACE_HANDLE;
 687
 688 typedef BOOL (WINAPI *WinUsb_AbortPipe_t)(
 689         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 690         UCHAR PipeID
 691 );
 692 typedef BOOL (WINAPI *WinUsb_ControlTransfer_t)(
 693         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 694         WINUSB_SETUP_PACKET SetupPacket,
 695         PUCHAR Buffer,
 696         ULONG BufferLength,
 697         PULONG LengthTransferred,
 698         LPOVERLAPPED Overlapped
 699 );
 700 typedef BOOL (WINAPI *WinUsb_FlushPipe_t)(
 701         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 702         UCHAR PipeID
 703 );
 704 typedef BOOL (WINAPI *WinUsb_Free_t)(
 705         WINUSB_INTERFACE_HANDLE InterfaceHandle
 706 );
 707 typedef BOOL (WINAPI *WinUsb_GetAssociatedInterface_t)(
 708         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 709         UCHAR AssociatedInterfaceIndex,
 710         PWINUSB_INTERFACE_HANDLE AssociatedInterfaceHandle
 711 );
 712 typedef BOOL (WINAPI *WinUsb_GetCurrentAlternateSetting_t)(
 713         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 714         PUCHAR AlternateSetting
 715 );
 716 typedef BOOL (WINAPI *WinUsb_GetDescriptor_t)(
 717         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 718         UCHAR DescriptorType,
 719         UCHAR Index,
 720         USHORT LanguageID,
 721         PUCHAR Buffer,
 722         ULONG BufferLength,
 723         PULONG LengthTransferred
 724 );
 725 typedef BOOL (WINAPI *WinUsb_GetOverlappedResult_t)(
 726         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 727         LPOVERLAPPED lpOverlapped,
 728         LPDWORD lpNumberOfBytesTransferred,
 729         BOOL bWait
 730 );
 731 typedef BOOL (WINAPI *WinUsb_GetPipePolicy_t)(
 732         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 733         UCHAR PipeID,
 734         ULONG PolicyType,
 735         PULONG ValueLength,
 736         PVOID Value
 737 );
 738 typedef BOOL (WINAPI *WinUsb_GetPowerPolicy_t)(
 739         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 740         ULONG PolicyType,
 741         PULONG ValueLength,
 742         PVOID Value
 743 );
 744 typedef BOOL (WINAPI *WinUsb_Initialize_t)(
 745         HANDLE DeviceHandle,
 746         PWINUSB_INTERFACE_HANDLE InterfaceHandle
 747 );
 748 typedef BOOL (WINAPI *WinUsb_QueryDeviceInformation_t)(
 749         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 750         ULONG InformationType,
 751         PULONG BufferLength,
 752         PVOID Buffer
 753 );
 754 typedef BOOL (WINAPI *WinUsb_QueryInterfaceSettings_t)(
 755         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 756         UCHAR AlternateSettingNumber,
 757         PUSB_INTERFACE_DESCRIPTOR UsbAltInterfaceDescriptor
 758 );
 759 typedef BOOL (WINAPI *WinUsb_QueryPipe_t)(
 760         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 761         UCHAR AlternateInterfaceNumber,
 762         UCHAR PipeIndex,
 763         PWINUSB_PIPE_INFORMATION PipeInformation
 764 );
 765 typedef BOOL (WINAPI *WinUsb_ReadPipe_t)(
 766         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 767         UCHAR PipeID,
 768         PUCHAR Buffer,
 769         ULONG BufferLength,
 770         PULONG LengthTransferred,
 771         LPOVERLAPPED Overlapped
 772 );
 773 typedef BOOL (WINAPI *WinUsb_ResetPipe_t)(
 774         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 775         UCHAR PipeID
 776 );
 777 typedef BOOL (WINAPI *WinUsb_SetCurrentAlternateSetting_t)(
 778         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 779         UCHAR AlternateSetting
 780 );
 781 typedef BOOL (WINAPI *WinUsb_SetPipePolicy_t)(
 782         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 783         UCHAR PipeID,
 784         ULONG PolicyType,
 785         ULONG ValueLength,
 786         PVOID Value
 787 );
 788 typedef BOOL (WINAPI *WinUsb_SetPowerPolicy_t)(
 789         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 790         ULONG PolicyType,
 791         ULONG ValueLength,
 792         PVOID Value
 793 );
 794 typedef BOOL (WINAPI *WinUsb_WritePipe_t)(
 795         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 796         UCHAR PipeID,
 797         PUCHAR Buffer,
 798         ULONG BufferLength,
 799         PULONG LengthTransferred,
 800         LPOVERLAPPED Overlapped
 801 );
 802 typedef BOOL (WINAPI *WinUsb_ResetDevice_t)(
 803         WINUSB_INTERFACE_HANDLE InterfaceHandle
 804 );
 805
 806 /* /!\ These must match the ones from the official libusbk.h */
 807 typedef enum _KUSB_FNID
 808 {
 809         KUSB_FNID_Init,
 810         KUSB_FNID_Free,
 811         KUSB_FNID_ClaimInterface,
 812         KUSB_FNID_ReleaseInterface,
 813         KUSB_FNID_SetAltInterface,
 814         KUSB_FNID_GetAltInterface,
 815         KUSB_FNID_GetDescriptor,
 816         KUSB_FNID_ControlTransfer,
 817         KUSB_FNID_SetPowerPolicy,
 818         KUSB_FNID_GetPowerPolicy,
 819         KUSB_FNID_SetConfiguration,
 820         KUSB_FNID_GetConfiguration,
 821         KUSB_FNID_ResetDevice,
 822         KUSB_FNID_Initialize,
 823         KUSB_FNID_SelectInterface,
 824         KUSB_FNID_GetAssociatedInterface,
 825         KUSB_FNID_Clone,
 826         KUSB_FNID_QueryInterfaceSettings,
 827         KUSB_FNID_QueryDeviceInformation,
 828         KUSB_FNID_SetCurrentAlternateSetting,
 829         KUSB_FNID_GetCurrentAlternateSetting,
 830         KUSB_FNID_QueryPipe,
 831         KUSB_FNID_SetPipePolicy,
 832         KUSB_FNID_GetPipePolicy,
 833         KUSB_FNID_ReadPipe,
 834         KUSB_FNID_WritePipe,
 835         KUSB_FNID_ResetPipe,
 836         KUSB_FNID_AbortPipe,
 837         KUSB_FNID_FlushPipe,
 838         KUSB_FNID_IsoReadPipe,
 839         KUSB_FNID_IsoWritePipe,
 840         KUSB_FNID_GetCurrentFrameNumber,
 841         KUSB_FNID_GetOverlappedResult,
 842         KUSB_FNID_GetProperty,
 843         KUSB_FNID_COUNT,
 844 } KUSB_FNID;
 845
 846 typedef struct _KLIB_VERSION {
 847         INT Major;
 848         INT Minor;
 849         INT Micro;
 850         INT Nano;
 851 } KLIB_VERSION;
 852 typedef KLIB_VERSION* PKLIB_VERSION;
 853
 854 typedef BOOL (WINAPI *LibK_GetProcAddress_t)(
 855         PVOID* ProcAddress,
 856         ULONG DriverID,
 857         ULONG FunctionID
 858 );
 859
 860 typedef VOID (WINAPI *LibK_GetVersion_t)(
 861         PKLIB_VERSION Version
 862 );
 863
 864 struct winusb_interface {
 865         bool initialized;
 866         WinUsb_AbortPipe_t AbortPipe;
 867         WinUsb_ControlTransfer_t ControlTransfer;
 868         WinUsb_FlushPipe_t FlushPipe;
 869         WinUsb_Free_t Free;
 870         WinUsb_GetAssociatedInterface_t GetAssociatedInterface;
 871         WinUsb_GetCurrentAlternateSetting_t GetCurrentAlternateSetting;
 872         WinUsb_GetDescriptor_t GetDescriptor;
 873         WinUsb_GetOverlappedResult_t GetOverlappedResult;
 874         WinUsb_GetPipePolicy_t GetPipePolicy;
 875         WinUsb_GetPowerPolicy_t GetPowerPolicy;
 876         WinUsb_Initialize_t Initialize;
 877         WinUsb_QueryDeviceInformation_t QueryDeviceInformation;
 878         WinUsb_QueryInterfaceSettings_t QueryInterfaceSettings;
 879         WinUsb_QueryPipe_t QueryPipe;
 880         WinUsb_ReadPipe_t ReadPipe;
 881         WinUsb_ResetPipe_t ResetPipe;
 882         WinUsb_SetCurrentAlternateSetting_t SetCurrentAlternateSetting;
 883         WinUsb_SetPipePolicy_t SetPipePolicy;
 884         WinUsb_SetPowerPolicy_t SetPowerPolicy;
 885         WinUsb_WritePipe_t WritePipe;
 886         WinUsb_ResetDevice_t ResetDevice;
 887 };
 888
 889 /* hid.dll interface */
 890
 891 #define HIDP_STATUS_SUCCESS  0x110000
 892 typedef void* PHIDP_PREPARSED_DATA;
 893
 894 #pragma pack(1)
 895 typedef struct {
 896         ULONG Size;
 897         USHORT VendorID;
 898         USHORT ProductID;
 899         USHORT VersionNumber;
 900 } HIDD_ATTRIBUTES, *PHIDD_ATTRIBUTES;
 901 #pragma pack()
 902
 903 typedef USHORT USAGE;
 904 typedef struct {
 905   USAGE Usage;
 906   USAGE UsagePage;
 907   USHORT InputReportByteLength;
 908   USHORT OutputReportByteLength;
 909   USHORT FeatureReportByteLength;
 910   USHORT Reserved[17];
 911   USHORT NumberLinkCollectionNodes;
 912   USHORT NumberInputButtonCaps;
 913   USHORT NumberInputValueCaps;
 914   USHORT NumberInputDataIndices;
 915   USHORT NumberOutputButtonCaps;
 916   USHORT NumberOutputValueCaps;
 917   USHORT NumberOutputDataIndices;
 918   USHORT NumberFeatureButtonCaps;
 919   USHORT NumberFeatureValueCaps;
 920   USHORT NumberFeatureDataIndices;
 921 } HIDP_CAPS, *PHIDP_CAPS;
 922
 923 typedef enum _HIDP_REPORT_TYPE {
 924   HidP_Input,
 925   HidP_Output,
 926   HidP_Feature
 927 } HIDP_REPORT_TYPE;
 928
 929 typedef struct _HIDP_VALUE_CAPS {
 930   USAGE  UsagePage;
 931   UCHAR  ReportID;
 932   BOOLEAN  IsAlias;
 933   USHORT  BitField;
 934   USHORT  LinkCollection;
 935   USAGE  LinkUsage;
 936   USAGE  LinkUsagePage;
 937   BOOLEAN  IsRange;
 938   BOOLEAN  IsStringRange;
 939   BOOLEAN  IsDesignatorRange;
 940   BOOLEAN  IsAbsolute;
 941   BOOLEAN  HasNull;
 942   UCHAR  Reserved;
 943   USHORT  BitSize;
 944   USHORT  ReportCount;
 945   USHORT  Reserved2[5];
 946   ULONG  UnitsExp;
 947   ULONG  Units;
 948   LONG  LogicalMin, LogicalMax;
 949   LONG  PhysicalMin, PhysicalMax;
 950         union {
 951           struct {
 952                 USAGE  UsageMin, UsageMax;
 953                 USHORT  StringMin, StringMax;
 954                 USHORT  DesignatorMin, DesignatorMax;
 955                 USHORT  DataIndexMin, DataIndexMax;
 956           } Range;
 957           struct {
 958                 USAGE  Usage, Reserved1;
 959                 USHORT  StringIndex, Reserved2;
 960                 USHORT  DesignatorIndex, Reserved3;
 961                 USHORT  DataIndex, Reserved4;
 962           } NotRange;
 963         } u;
 964 } HIDP_VALUE_CAPS, *PHIDP_VALUE_CAPS;
 965
 966 DLL_DECLARE(WINAPI, BOOL, HidD_GetAttributes, (HANDLE, PHIDD_ATTRIBUTES));
 967 DLL_DECLARE(WINAPI, VOID, HidD_GetHidGuid, (LPGUID));
 968 DLL_DECLARE(WINAPI, BOOL, HidD_GetPreparsedData, (HANDLE, PHIDP_PREPARSED_DATA *));
 969 DLL_DECLARE(WINAPI, BOOL, HidD_FreePreparsedData, (PHIDP_PREPARSED_DATA));
 970 DLL_DECLARE(WINAPI, BOOL, HidD_GetManufacturerString, (HANDLE, PVOID, ULONG));
 971 DLL_DECLARE(WINAPI, BOOL, HidD_GetProductString, (HANDLE, PVOID, ULONG));
 972 DLL_DECLARE(WINAPI, BOOL, HidD_GetSerialNumberString, (HANDLE, PVOID, ULONG));
 973 DLL_DECLARE(WINAPI, LONG, HidP_GetCaps, (PHIDP_PREPARSED_DATA, PHIDP_CAPS));
 974 DLL_DECLARE(WINAPI, BOOL, HidD_SetNumInputBuffers, (HANDLE, ULONG));
 975 DLL_DECLARE(WINAPI, BOOL, HidD_SetFeature, (HANDLE, PVOID, ULONG));
 976 DLL_DECLARE(WINAPI, BOOL, HidD_GetFeature, (HANDLE, PVOID, ULONG));
 977 DLL_DECLARE(WINAPI, BOOL, HidD_GetPhysicalDescriptor, (HANDLE, PVOID, ULONG));
 978 DLL_DECLARE(WINAPI, BOOL, HidD_GetInputReport, (HANDLE, PVOID, ULONG));
 979 DLL_DECLARE(WINAPI, BOOL, HidD_SetOutputReport, (HANDLE, PVOID, ULONG));
 980 DLL_DECLARE(WINAPI, BOOL, HidD_FlushQueue, (HANDLE));
 981 DLL_DECLARE(WINAPI, BOOL, HidP_GetValueCaps, (HIDP_REPORT_TYPE, PHIDP_VALUE_CAPS, PULONG, PHIDP_PREPARSED_DATA));