libusb/os/windows_winusb.h

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