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 // cygwin produces a warning unless these prototypes are defined
  54 extern int _snprintf(char *buffer, size_t count, const char *format, ...);
  55 extern char *_strdup(const char *strSource);
  56 // _beginthreadex is MSVCRT => unavailable for cygwin. Fallback to using CreateThread
  57 #define _beginthreadex(a, b, c, d, e, f) CreateThread(a, b, (LPTHREAD_START_ROUTINE)c, d, e, f)
  58 #endif
  59 #define safe_free(p) do {if (p != NULL) {free((void*)p); p = NULL;}} while(0)
  60 #define safe_closehandle(h) do {if (h != INVALID_HANDLE_VALUE) {CloseHandle(h); h = INVALID_HANDLE_VALUE;}} while(0)
  61 #define safe_min(a, b) min((size_t)(a), (size_t)(b))
  62 #define safe_strcp(dst, dst_max, src, count) do {memcpy(dst, src, safe_min(count, dst_max)); \
  63         ((char*)dst)[safe_min(count, dst_max)-1] = 0;} while(0)
  64 #define safe_strcpy(dst, dst_max, src) safe_strcp(dst, dst_max, src, safe_strlen(src)+1)
  65 #define safe_strncat(dst, dst_max, src, count) strncat(dst, src, safe_min(count, dst_max - safe_strlen(dst) - 1))
  66 #define safe_strcat(dst, dst_max, src) safe_strncat(dst, dst_max, src, safe_strlen(src)+1)
  67 #define safe_strcmp(str1, str2) strcmp(((str1==NULL)?"<NULL>":str1), ((str2==NULL)?"<NULL>":str2))
  68 #define safe_strncmp(str1, str2, count) strncmp(((str1==NULL)?"<NULL>":str1), ((str2==NULL)?"<NULL>":str2), count)
  69 #define safe_strlen(str) ((str==NULL)?0:strlen(str))
  70 #define safe_sprintf _snprintf
  71 #define safe_unref_device(dev) do {if (dev != NULL) {libusb_unref_device(dev); dev = NULL;}} while(0)
  72 #define wchar_to_utf8_ms(wstr, str, strlen) WideCharToMultiByte(CP_UTF8, 0, wstr, -1, str, strlen, NULL, NULL)
  73 static inline void upperize(char* str) {
  74         size_t i;
  75         if (str == NULL) return;
  76         for (i=0; i<safe_strlen(str); i++)
  77                 str[i] = (char)toupper((int)str[i]);
  78 }
  79
  80 #define MAX_CTRL_BUFFER_LENGTH      4096
  81 #define MAX_USB_DEVICES             256
  82 #define MAX_USB_STRING_LENGTH       128
  83 #define MAX_HID_REPORT_SIZE         1024
  84 #define MAX_HID_DESCRIPTOR_SIZE     256
  85 #define MAX_GUID_STRING_LENGTH      40
  86 #define MAX_PATH_LENGTH             128
  87 #define MAX_KEY_LENGTH              256
  88 #define MAX_TIMER_SEMAPHORES        128
  89 #define TIMER_REQUEST_RETRY_MS      100
  90 #define ERR_BUFFER_SIZE             256
  91 #define LIST_SEPARATOR              ';'
  92 #define HTAB_SIZE                   1021
  93
  94 // Handle code for HID interface that have been claimed ("dibs")
  95 #define INTERFACE_CLAIMED           ((HANDLE)(intptr_t)0xD1B5)
  96 // Additional return code for HID operations that completed synchronously
  97 #define LIBUSB_COMPLETED            (LIBUSB_SUCCESS + 1)
  98
  99 // http://msdn.microsoft.com/en-us/library/ff545978.aspx
 100 // http://msdn.microsoft.com/en-us/library/ff545972.aspx
 101 // http://msdn.microsoft.com/en-us/library/ff545982.aspx
 102 #if !defined(GUID_DEVINTERFACE_USB_HOST_CONTROLLER)
 103 const GUID GUID_DEVINTERFACE_USB_HOST_CONTROLLER = { 0x3ABF6F2D, 0x71C4, 0x462A, {0x8A, 0x92, 0x1E, 0x68, 0x61, 0xE6, 0xAF, 0x27} };
 104 #endif
 105 #if !defined(GUID_DEVINTERFACE_USB_DEVICE)
 106 const GUID GUID_DEVINTERFACE_USB_DEVICE = { 0xA5DCBF10, 0x6530, 0x11D2, {0x90, 0x1F, 0x00, 0xC0, 0x4F, 0xB9, 0x51, 0xED} };
 107 #endif
 108 #if !defined(GUID_DEVINTERFACE_USB_HUB)
 109 const GUID GUID_DEVINTERFACE_USB_HUB = { 0xF18A0E88, 0xC30C, 0x11D0, {0x88, 0x15, 0x00, 0xA0, 0xC9, 0x06, 0xBE, 0xD8} };
 110 #endif
 111 const GUID GUID_NULL = { 0x00000000, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} };
 112
 113
 114 /*
 115  * Multiple USB API backend support
 116  */
 117 #define USB_API_UNSUPPORTED 0
 118 #define USB_API_HUB         1
 119 #define USB_API_COMPOSITE   2
 120 #define USB_API_WINUSB      3
 121 #define USB_API_HID         4
 122 #define USB_API_MAX         5
 123
 124 #define CLASS_GUID_UNSUPPORTED      GUID_NULL
 125 const GUID CLASS_GUID_HID           = { 0x745A17A0, 0x74D3, 0x11D0, {0xB6, 0xFE, 0x00, 0xA0, 0xC9, 0x0F, 0x57, 0xDA} };
 126 const GUID CLASS_GUID_LIBUSB_WINUSB = { 0x78A1C341, 0x4539, 0x11D3, {0xB8, 0x8D, 0x00, 0xC0, 0x4F, 0xAD, 0x51, 0x71} };
 127 const GUID CLASS_GUID_COMPOSITE     = { 0x36FC9E60, 0xC465, 0x11cF, {0x80, 0x56, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00} };
 128
 129 struct windows_usb_api_backend {
 130         const uint8_t id;
 131         const char* designation;
 132         const GUID *class_guid;  // The Class GUID (for fallback in case the driver name cannot be read)
 133         const char **driver_name_list; // Driver name, without .sys, e.g. "usbccgp"
 134         const uint8_t nb_driver_names;
 135         int (*init)(struct libusb_context *ctx);
 136         int (*exit)(void);
 137         int (*open)(struct libusb_device_handle *dev_handle);
 138         void (*close)(struct libusb_device_handle *dev_handle);
 139         int (*claim_interface)(struct libusb_device_handle *dev_handle, int iface);
 140         int (*set_interface_altsetting)(struct libusb_device_handle *dev_handle, int iface, int altsetting);
 141         int (*release_interface)(struct libusb_device_handle *dev_handle, int iface);
 142         int (*clear_halt)(struct libusb_device_handle *dev_handle, unsigned char endpoint);
 143         int (*reset_device)(struct libusb_device_handle *dev_handle);
 144         int (*submit_bulk_transfer)(struct usbi_transfer *itransfer);
 145         int (*submit_iso_transfer)(struct usbi_transfer *itransfer);
 146         int (*submit_control_transfer)(struct usbi_transfer *itransfer);
 147         int (*abort_control)(struct usbi_transfer *itransfer);
 148         int (*abort_transfers)(struct usbi_transfer *itransfer);
 149         int (*copy_transfer_data)(struct usbi_transfer *itransfer, uint32_t io_size);
 150 };
 151
 152 extern const struct windows_usb_api_backend usb_api_backend[USB_API_MAX];
 153
 154 #define PRINT_UNSUPPORTED_API(fname)              \
 155         usbi_dbg("unsupported API call for '"         \
 156                 #fname "' (unrecognized device driver)"); \
 157         return LIBUSB_ERROR_NOT_SUPPORTED;
 158
 159 /*
 160  * private structures definition
 161  * with inline pseudo constructors/destructors
 162  */
 163
 164 // TODO (v2+): move hid desc to libusb.h?
 165 struct libusb_hid_descriptor {
 166         uint8_t  bLength;
 167         uint8_t  bDescriptorType;
 168         uint16_t bcdHID;
 169         uint8_t  bCountryCode;
 170         uint8_t  bNumDescriptors;
 171         uint8_t  bClassDescriptorType;
 172         uint16_t wClassDescriptorLength;
 173 };
 174 #define LIBUSB_DT_HID_SIZE              9
 175 #define HID_MAX_CONFIG_DESC_SIZE (LIBUSB_DT_CONFIG_SIZE + LIBUSB_DT_INTERFACE_SIZE \
 176         + LIBUSB_DT_HID_SIZE + 2 * LIBUSB_DT_ENDPOINT_SIZE)
 177 #define HID_MAX_REPORT_SIZE             1024
 178 #define HID_IN_EP                       0x81
 179 #define HID_OUT_EP                      0x02
 180 #define LIBUSB_REQ_RECIPIENT(request_type) ((request_type) & 0x1F)
 181 #define LIBUSB_REQ_TYPE(request_type) ((request_type) & (0x03 << 5))
 182 #define LIBUSB_REQ_IN(request_type) ((request_type) & LIBUSB_ENDPOINT_IN)
 183 #define LIBUSB_REQ_OUT(request_type) (!LIBUSB_REQ_IN(request_type))
 184
 185 // The following are used for HID reports IOCTLs
 186 #define HID_CTL_CODE(id) \
 187   CTL_CODE (FILE_DEVICE_KEYBOARD, (id), METHOD_NEITHER, FILE_ANY_ACCESS)
 188 #define HID_BUFFER_CTL_CODE(id) \
 189   CTL_CODE (FILE_DEVICE_KEYBOARD, (id), METHOD_BUFFERED, FILE_ANY_ACCESS)
 190 #define HID_IN_CTL_CODE(id) \
 191   CTL_CODE (FILE_DEVICE_KEYBOARD, (id), METHOD_IN_DIRECT, FILE_ANY_ACCESS)
 192 #define HID_OUT_CTL_CODE(id) \
 193   CTL_CODE (FILE_DEVICE_KEYBOARD, (id), METHOD_OUT_DIRECT, FILE_ANY_ACCESS)
 194
 195 #define IOCTL_HID_GET_FEATURE                 HID_OUT_CTL_CODE(100)
 196 #define IOCTL_HID_GET_INPUT_REPORT            HID_OUT_CTL_CODE(104)
 197 #define IOCTL_HID_SET_FEATURE                 HID_IN_CTL_CODE(100)
 198 #define IOCTL_HID_SET_OUTPUT_REPORT           HID_IN_CTL_CODE(101)
 199
 200 enum libusb_hid_request_type {
 201         HID_REQ_GET_REPORT = 0x01,
 202         HID_REQ_GET_IDLE = 0x02,
 203         HID_REQ_GET_PROTOCOL = 0x03,
 204         HID_REQ_SET_REPORT = 0x09,
 205         HID_REQ_SET_IDLE = 0x0A,
 206         HID_REQ_SET_PROTOCOL = 0x0B
 207 };
 208
 209 enum libusb_hid_report_type {
 210         HID_REPORT_TYPE_INPUT = 0x01,
 211         HID_REPORT_TYPE_OUTPUT = 0x02,
 212         HID_REPORT_TYPE_FEATURE = 0x03
 213 };
 214
 215 struct hid_device_priv {
 216         uint16_t vid;
 217         uint16_t pid;
 218         uint8_t config;
 219         uint8_t nb_interfaces;
 220         bool uses_report_ids[3];        // input, ouptput, feature
 221         uint16_t input_report_size;
 222         uint16_t output_report_size;
 223         uint16_t feature_report_size;
 224         WCHAR string[3][MAX_USB_STRING_LENGTH];
 225         uint8_t string_index[3];        // man, prod, ser
 226 };
 227
 228 typedef struct libusb_device_descriptor USB_DEVICE_DESCRIPTOR, *PUSB_DEVICE_DESCRIPTOR;
 229 struct windows_device_priv {
 230         uint8_t depth;                                          // distance to HCD
 231         uint8_t port;                                           // port number on the hub
 232         struct libusb_device *parent_dev;       // access to parent is required for usermode ops
 233         char *path;                                                     // device interface path
 234         struct windows_usb_api_backend const *apib;
 235         struct {
 236                 char *path;                                             // each interface needs a device interface path,
 237                 struct windows_usb_api_backend const *apib; // an API backend (multiple drivers support),
 238                 int8_t nb_endpoints;                    // and a set of endpoint addresses (USB_MAXENDPOINTS)
 239                 uint8_t *endpoint;
 240                 bool restricted_functionality;  // indicates if the interface functionality is restricted
 241                                                                                 // by Windows (eg. HID keyboards or mice cannot do R/W)
 242         } usb_interface[USB_MAXINTERFACES];
 243         uint8_t composite_api_flags;            // HID and composite devices require additional data
 244         struct hid_device_priv *hid;
 245         uint8_t active_config;
 246         USB_DEVICE_DESCRIPTOR dev_descriptor;
 247         unsigned char **config_descriptor;      // list of pointers to the cached config descriptors
 248 };
 249
 250 static inline struct windows_device_priv *_device_priv(struct libusb_device *dev) {
 251         return (struct windows_device_priv *)dev->os_priv;
 252 }
 253
 254 static inline void windows_device_priv_init(libusb_device* dev) {
 255         struct windows_device_priv* p = _device_priv(dev);
 256         int i;
 257         p->depth = 0;
 258         p->port = 0;
 259         p->parent_dev = NULL;
 260         p->path = NULL;
 261         p->apib = &usb_api_backend[USB_API_UNSUPPORTED];
 262         p->composite_api_flags = 0;
 263         p->hid = NULL;
 264         p->active_config = 0;
 265         p->config_descriptor = NULL;
 266         memset(&(p->dev_descriptor), 0, sizeof(USB_DEVICE_DESCRIPTOR));
 267         for (i=0; i<USB_MAXINTERFACES; i++) {
 268                 p->usb_interface[i].path = NULL;
 269                 p->usb_interface[i].apib = &usb_api_backend[USB_API_UNSUPPORTED];
 270                 p->usb_interface[i].nb_endpoints = 0;
 271                 p->usb_interface[i].endpoint = NULL;
 272                 p->usb_interface[i].restricted_functionality = false;
 273         }
 274 }
 275
 276 static inline void windows_device_priv_release(libusb_device* dev) {
 277         struct windows_device_priv* p = _device_priv(dev);
 278         int i;
 279         safe_free(p->path);
 280         if ((dev->num_configurations > 0) && (p->config_descriptor != NULL)) {
 281                 for (i=0; i < dev->num_configurations; i++)
 282                         safe_free(p->config_descriptor[i]);
 283         }
 284         safe_free(p->config_descriptor);
 285         safe_free(p->hid);
 286         for (i=0; i<USB_MAXINTERFACES; i++) {
 287                 safe_free(p->usb_interface[i].path);
 288                 safe_free(p->usb_interface[i].endpoint);
 289         }
 290 }
 291
 292 struct interface_handle_t {
 293         HANDLE dev_handle; // WinUSB needs an extra handle for the file
 294         HANDLE api_handle; // used by the API to communicate with the device
 295 };
 296
 297 struct windows_device_handle_priv {
 298         int active_interface;
 299         struct interface_handle_t interface_handle[USB_MAXINTERFACES];
 300         int autoclaim_count[USB_MAXINTERFACES]; // For auto-release
 301 };
 302
 303 static inline struct windows_device_handle_priv *_device_handle_priv(
 304         struct libusb_device_handle *handle)
 305 {
 306         return (struct windows_device_handle_priv *) handle->os_priv;
 307 }
 308
 309 // used for async polling functions
 310 struct windows_transfer_priv {
 311         struct winfd pollable_fd;
 312         uint8_t interface_number;
 313         uint8_t *hid_buffer; // 1 byte extended data buffer, required for HID
 314         uint8_t *hid_dest;   // transfer buffer destination, required for HID
 315         size_t hid_expected_size;
 316 };
 317
 318 // used to match a device driver (including filter drivers) against a supported API
 319 struct driver_lookup {
 320         char list[MAX_KEY_LENGTH+1];// REG_MULTI_SZ list of services (driver) names
 321         const DWORD reg_prop;           // SPDRP registry key to use to retreive list
 322         const char* designation;        // internal designation (for debug output)
 323 };
 324
 325 /*
 326  * API macros - from libusb-win32 1.x
 327  */
 328 #define DLL_DECLARE_PREFIXNAME(api, ret, prefixname, name, args)    \
 329         typedef ret (api * __dll_##name##_t)args;                       \
 330         static __dll_##name##_t prefixname = NULL
 331
 332 #define DLL_LOAD_PREFIXNAME(dll, prefixname, name, ret_on_failure) \
 333         do {                                                           \
 334                 HMODULE h = GetModuleHandleA(#dll);                        \
 335         if (!h)                                                        \
 336                 h = LoadLibraryA(#dll);                                    \
 337         if (!h) {                                                      \
 338                 if (ret_on_failure) { return LIBUSB_ERROR_NOT_FOUND; }     \
 339                 else { break; }                                            \
 340         }                                                              \
 341         prefixname = (__dll_##name##_t)GetProcAddress(h, #name);       \
 342         if (prefixname) break;                                         \
 343         prefixname = (__dll_##name##_t)GetProcAddress(h, #name "A");   \
 344         if (prefixname) break;                                         \
 345         prefixname = (__dll_##name##_t)GetProcAddress(h, #name "W");   \
 346         if (prefixname) break;                                         \
 347         if(ret_on_failure)                                             \
 348                 return LIBUSB_ERROR_NOT_FOUND;                             \
 349         } while(0)
 350
 351 #define DLL_DECLARE(api, ret, name, args)   DLL_DECLARE_PREFIXNAME(api, ret, name, name, args)
 352 #define DLL_LOAD(dll, name, ret_on_failure) DLL_LOAD_PREFIXNAME(dll, name, name, ret_on_failure)
 353 #define DLL_DECLARE_PREFIXED(api, ret, prefix, name, args)   DLL_DECLARE_PREFIXNAME(api, ret, prefix##name, name, args)
 354 #define DLL_LOAD_PREFIXED(dll, prefix, name, ret_on_failure) DLL_LOAD_PREFIXNAME(dll, prefix##name, name, ret_on_failure)
 355
 356 /* OLE32 dependency */
 357 DLL_DECLARE_PREFIXED(WINAPI, HRESULT, p, CLSIDFromString, (LPCOLESTR, LPCLSID));
 358
 359 /* SetupAPI dependencies */
 360 DLL_DECLARE_PREFIXED(WINAPI, HDEVINFO, p, SetupDiGetClassDevsA, (const GUID*, PCSTR, HWND, DWORD));
 361 DLL_DECLARE_PREFIXED(WINAPI, BOOL, p, SetupDiEnumDeviceInfo, (HDEVINFO, DWORD, PSP_DEVINFO_DATA));
 362 DLL_DECLARE_PREFIXED(WINAPI, BOOL, p, SetupDiEnumDeviceInterfaces, (HDEVINFO, PSP_DEVINFO_DATA,
 363                         const GUID*, DWORD, PSP_DEVICE_INTERFACE_DATA));
 364 DLL_DECLARE_PREFIXED(WINAPI, BOOL, p, SetupDiGetDeviceInterfaceDetailA, (HDEVINFO, PSP_DEVICE_INTERFACE_DATA,
 365                         PSP_DEVICE_INTERFACE_DETAIL_DATA_A, DWORD, PDWORD, PSP_DEVINFO_DATA));
 366 DLL_DECLARE_PREFIXED(WINAPI, BOOL, p, SetupDiDestroyDeviceInfoList, (HDEVINFO));
 367 DLL_DECLARE_PREFIXED(WINAPI, HKEY, p, SetupDiOpenDevRegKey, (HDEVINFO, PSP_DEVINFO_DATA, DWORD, DWORD, DWORD, REGSAM));
 368 DLL_DECLARE_PREFIXED(WINAPI, BOOL, p, SetupDiGetDeviceRegistryPropertyA, (HDEVINFO,
 369                         PSP_DEVINFO_DATA, DWORD, PDWORD, PBYTE, DWORD, PDWORD));
 370 DLL_DECLARE_PREFIXED(WINAPI, LONG, p, RegQueryValueExW, (HKEY, LPCWSTR, LPDWORD, LPDWORD, LPBYTE, LPDWORD));
 371 DLL_DECLARE_PREFIXED(WINAPI, LONG, p, RegCloseKey, (HKEY));
 372
 373 /*
 374  * Windows DDK API definitions. Most of it copied from MinGW's includes
 375  */
 376 typedef DWORD DEVNODE, DEVINST;
 377 typedef DEVNODE *PDEVNODE, *PDEVINST;
 378 typedef DWORD RETURN_TYPE;
 379 typedef RETURN_TYPE CONFIGRET;
 380
 381 #define CR_SUCCESS                              0x00000000
 382 #define CR_NO_SUCH_DEVNODE                      0x0000000D
 383
 384 #define USB_DEVICE_DESCRIPTOR_TYPE              LIBUSB_DT_DEVICE
 385 #define USB_CONFIGURATION_DESCRIPTOR_TYPE       LIBUSB_DT_CONFIG
 386 #define USB_STRING_DESCRIPTOR_TYPE              LIBUSB_DT_STRING
 387 #define USB_INTERFACE_DESCRIPTOR_TYPE           LIBUSB_DT_INTERFACE
 388 #define USB_ENDPOINT_DESCRIPTOR_TYPE            LIBUSB_DT_ENDPOINT
 389
 390 #define USB_REQUEST_GET_STATUS                  LIBUSB_REQUEST_GET_STATUS
 391 #define USB_REQUEST_CLEAR_FEATURE               LIBUSB_REQUEST_CLEAR_FEATURE
 392 #define USB_REQUEST_SET_FEATURE                 LIBUSB_REQUEST_SET_FEATURE
 393 #define USB_REQUEST_SET_ADDRESS                 LIBUSB_REQUEST_SET_ADDRESS
 394 #define USB_REQUEST_GET_DESCRIPTOR              LIBUSB_REQUEST_GET_DESCRIPTOR
 395 #define USB_REQUEST_SET_DESCRIPTOR              LIBUSB_REQUEST_SET_DESCRIPTOR
 396 #define USB_REQUEST_GET_CONFIGURATION           LIBUSB_REQUEST_GET_CONFIGURATION
 397 #define USB_REQUEST_SET_CONFIGURATION           LIBUSB_REQUEST_SET_CONFIGURATION
 398 #define USB_REQUEST_GET_INTERFACE               LIBUSB_REQUEST_GET_INTERFACE
 399 #define USB_REQUEST_SET_INTERFACE               LIBUSB_REQUEST_SET_INTERFACE
 400 #define USB_REQUEST_SYNC_FRAME                  LIBUSB_REQUEST_SYNCH_FRAME
 401
 402 #define USB_GET_NODE_INFORMATION                258
 403 #define USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION 260
 404 #define USB_GET_NODE_CONNECTION_NAME            261
 405 #define USB_GET_HUB_CAPABILITIES                271
 406 #if !defined(USB_GET_NODE_CONNECTION_INFORMATION_EX)
 407 #define USB_GET_NODE_CONNECTION_INFORMATION_EX  274
 408 #endif
 409 #if !defined(USB_GET_HUB_CAPABILITIES_EX)
 410 #define USB_GET_HUB_CAPABILITIES_EX             276
 411 #endif
 412
 413 #ifndef METHOD_BUFFERED
 414 #define METHOD_BUFFERED                         0
 415 #endif
 416 #ifndef FILE_ANY_ACCESS
 417 #define FILE_ANY_ACCESS                         0x00000000
 418 #endif
 419 #ifndef FILE_DEVICE_UNKNOWN
 420 #define FILE_DEVICE_UNKNOWN                     0x00000022
 421 #endif
 422 #ifndef FILE_DEVICE_USB
 423 #define FILE_DEVICE_USB                         FILE_DEVICE_UNKNOWN
 424 #endif
 425
 426 #ifndef CTL_CODE
 427 #define CTL_CODE(DeviceType, Function, Method, Access)( \
 428   ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method))
 429 #endif
 430
 431 typedef enum USB_CONNECTION_STATUS {
 432         NoDeviceConnected,
 433         DeviceConnected,
 434         DeviceFailedEnumeration,
 435         DeviceGeneralFailure,
 436         DeviceCausedOvercurrent,
 437         DeviceNotEnoughPower,
 438         DeviceNotEnoughBandwidth,
 439         DeviceHubNestedTooDeeply,
 440         DeviceInLegacyHub
 441 } USB_CONNECTION_STATUS, *PUSB_CONNECTION_STATUS;
 442
 443 typedef enum USB_HUB_NODE {
 444         UsbHub,
 445         UsbMIParent
 446 } USB_HUB_NODE;
 447
 448 /* Cfgmgr32.dll interface */
 449 DLL_DECLARE(WINAPI, CONFIGRET, CM_Get_Parent, (PDEVINST, DEVINST, ULONG));
 450 DLL_DECLARE(WINAPI, CONFIGRET, CM_Get_Child, (PDEVINST, DEVINST, ULONG));
 451 DLL_DECLARE(WINAPI, CONFIGRET, CM_Get_Sibling, (PDEVINST, DEVINST, ULONG));
 452 DLL_DECLARE(WINAPI, CONFIGRET, CM_Get_Device_IDA, (DEVINST, PCHAR, ULONG, ULONG));
 453
 454 #define IOCTL_USB_GET_HUB_CAPABILITIES_EX \
 455   CTL_CODE( FILE_DEVICE_USB, USB_GET_HUB_CAPABILITIES_EX, METHOD_BUFFERED, FILE_ANY_ACCESS)
 456
 457 #define IOCTL_USB_GET_HUB_CAPABILITIES \
 458   CTL_CODE(FILE_DEVICE_USB, USB_GET_HUB_CAPABILITIES, METHOD_BUFFERED, FILE_ANY_ACCESS)
 459
 460 #define IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION \
 461   CTL_CODE(FILE_DEVICE_USB, USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION, METHOD_BUFFERED, FILE_ANY_ACCESS)
 462
 463 #define IOCTL_USB_GET_ROOT_HUB_NAME \
 464   CTL_CODE(FILE_DEVICE_USB, HCD_GET_ROOT_HUB_NAME, METHOD_BUFFERED, FILE_ANY_ACCESS)
 465
 466 #define IOCTL_USB_GET_NODE_INFORMATION \
 467   CTL_CODE(FILE_DEVICE_USB, USB_GET_NODE_INFORMATION, METHOD_BUFFERED, FILE_ANY_ACCESS)
 468
 469 #define IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX \
 470   CTL_CODE(FILE_DEVICE_USB, USB_GET_NODE_CONNECTION_INFORMATION_EX, METHOD_BUFFERED, FILE_ANY_ACCESS)
 471
 472 #define IOCTL_USB_GET_NODE_CONNECTION_ATTRIBUTES \
 473   CTL_CODE(FILE_DEVICE_USB, USB_GET_NODE_CONNECTION_ATTRIBUTES, METHOD_BUFFERED, FILE_ANY_ACCESS)
 474
 475 #define IOCTL_USB_GET_NODE_CONNECTION_NAME \
 476   CTL_CODE(FILE_DEVICE_USB, USB_GET_NODE_CONNECTION_NAME, METHOD_BUFFERED, FILE_ANY_ACCESS)
 477
 478 // Most of the structures below need to be packed
 479 #pragma pack(push, 1)
 480
 481 typedef struct USB_INTERFACE_DESCRIPTOR {
 482   UCHAR  bLength;
 483   UCHAR  bDescriptorType;
 484   UCHAR  bInterfaceNumber;
 485   UCHAR  bAlternateSetting;
 486   UCHAR  bNumEndpoints;
 487   UCHAR  bInterfaceClass;
 488   UCHAR  bInterfaceSubClass;
 489   UCHAR  bInterfaceProtocol;
 490   UCHAR  iInterface;
 491 } USB_INTERFACE_DESCRIPTOR, *PUSB_INTERFACE_DESCRIPTOR;
 492
 493 typedef struct USB_CONFIGURATION_DESCRIPTOR {
 494   UCHAR  bLength;
 495   UCHAR  bDescriptorType;
 496   USHORT wTotalLength;
 497   UCHAR  bNumInterfaces;
 498   UCHAR  bConfigurationValue;
 499   UCHAR  iConfiguration;
 500   UCHAR  bmAttributes;
 501   UCHAR  MaxPower;
 502 } USB_CONFIGURATION_DESCRIPTOR, *PUSB_CONFIGURATION_DESCRIPTOR;
 503
 504 typedef struct USB_CONFIGURATION_DESCRIPTOR_SHORT {
 505         struct {
 506                 ULONG ConnectionIndex;
 507                 struct {
 508                         UCHAR bmRequest;
 509                         UCHAR bRequest;
 510                         USHORT wValue;
 511                         USHORT wIndex;
 512                         USHORT wLength;
 513                 } SetupPacket;
 514         } req;
 515         USB_CONFIGURATION_DESCRIPTOR data;
 516 } USB_CONFIGURATION_DESCRIPTOR_SHORT;
 517
 518 typedef struct USB_ENDPOINT_DESCRIPTOR {
 519   UCHAR  bLength;
 520   UCHAR  bDescriptorType;
 521   UCHAR  bEndpointAddress;
 522   UCHAR  bmAttributes;
 523   USHORT  wMaxPacketSize;
 524   UCHAR  bInterval;
 525 } USB_ENDPOINT_DESCRIPTOR, *PUSB_ENDPOINT_DESCRIPTOR;
 526
 527 typedef struct USB_DESCRIPTOR_REQUEST {
 528         ULONG  ConnectionIndex;
 529         struct {
 530                 UCHAR  bmRequest;
 531                 UCHAR  bRequest;
 532                 USHORT  wValue;
 533                 USHORT  wIndex;
 534                 USHORT  wLength;
 535         } SetupPacket;
 536 //      UCHAR  Data[0];
 537 } USB_DESCRIPTOR_REQUEST, *PUSB_DESCRIPTOR_REQUEST;
 538
 539 typedef struct USB_HUB_DESCRIPTOR {
 540         UCHAR  bDescriptorLength;
 541         UCHAR  bDescriptorType;
 542         UCHAR  bNumberOfPorts;
 543         USHORT  wHubCharacteristics;
 544         UCHAR  bPowerOnToPowerGood;
 545         UCHAR  bHubControlCurrent;
 546         UCHAR  bRemoveAndPowerMask[64];
 547 } USB_HUB_DESCRIPTOR, *PUSB_HUB_DESCRIPTOR;
 548
 549 typedef struct USB_ROOT_HUB_NAME {
 550         ULONG  ActualLength;
 551         WCHAR  RootHubName[1];
 552 } USB_ROOT_HUB_NAME, *PUSB_ROOT_HUB_NAME;
 553
 554 typedef struct USB_ROOT_HUB_NAME_FIXED {
 555         ULONG ActualLength;
 556         WCHAR RootHubName[MAX_PATH_LENGTH];
 557 } USB_ROOT_HUB_NAME_FIXED;
 558
 559 typedef struct USB_NODE_CONNECTION_NAME {
 560         ULONG  ConnectionIndex;
 561         ULONG  ActualLength;
 562         WCHAR  NodeName[1];
 563 } USB_NODE_CONNECTION_NAME, *PUSB_NODE_CONNECTION_NAME;
 564
 565 typedef struct USB_NODE_CONNECTION_NAME_FIXED {
 566         ULONG ConnectionIndex;
 567         ULONG ActualLength;
 568         WCHAR NodeName[MAX_PATH_LENGTH];
 569 } USB_NODE_CONNECTION_NAME_FIXED;
 570
 571 typedef struct USB_HUB_NAME_FIXED {
 572         union {
 573                 USB_ROOT_HUB_NAME_FIXED root;
 574                 USB_NODE_CONNECTION_NAME_FIXED node;
 575         } u;
 576 } USB_HUB_NAME_FIXED;
 577
 578 typedef struct USB_HUB_INFORMATION {
 579         USB_HUB_DESCRIPTOR  HubDescriptor;
 580         BOOLEAN  HubIsBusPowered;
 581 } USB_HUB_INFORMATION, *PUSB_HUB_INFORMATION;
 582
 583 typedef struct USB_MI_PARENT_INFORMATION {
 584   ULONG  NumberOfInterfaces;
 585 } USB_MI_PARENT_INFORMATION, *PUSB_MI_PARENT_INFORMATION;
 586
 587 typedef struct USB_NODE_INFORMATION {
 588         USB_HUB_NODE  NodeType;
 589         union {
 590                 USB_HUB_INFORMATION  HubInformation;
 591                 USB_MI_PARENT_INFORMATION  MiParentInformation;
 592         } u;
 593 } USB_NODE_INFORMATION, *PUSB_NODE_INFORMATION;
 594
 595 typedef struct USB_PIPE_INFO {
 596         USB_ENDPOINT_DESCRIPTOR  EndpointDescriptor;
 597         ULONG  ScheduleOffset;
 598 } USB_PIPE_INFO, *PUSB_PIPE_INFO;
 599
 600 typedef struct USB_NODE_CONNECTION_INFORMATION_EX {
 601         ULONG  ConnectionIndex;
 602         USB_DEVICE_DESCRIPTOR  DeviceDescriptor;
 603         UCHAR  CurrentConfigurationValue;
 604         UCHAR  Speed;
 605         BOOLEAN  DeviceIsHub;
 606         USHORT  DeviceAddress;
 607         ULONG  NumberOfOpenPipes;
 608         USB_CONNECTION_STATUS  ConnectionStatus;
 609 //      USB_PIPE_INFO  PipeList[0];
 610 } USB_NODE_CONNECTION_INFORMATION_EX, *PUSB_NODE_CONNECTION_INFORMATION_EX;
 611
 612 typedef struct USB_HUB_CAP_FLAGS {
 613         ULONG HubIsHighSpeedCapable:1;
 614         ULONG HubIsHighSpeed:1;
 615         ULONG HubIsMultiTtCapable:1;
 616         ULONG HubIsMultiTt:1;
 617         ULONG HubIsRoot:1;
 618         ULONG HubIsArmedWakeOnConnect:1;
 619         ULONG ReservedMBZ:26;
 620 } USB_HUB_CAP_FLAGS, *PUSB_HUB_CAP_FLAGS;
 621
 622 typedef struct USB_HUB_CAPABILITIES {
 623   ULONG  HubIs2xCapable : 1;
 624 } USB_HUB_CAPABILITIES, *PUSB_HUB_CAPABILITIES;
 625
 626 typedef struct USB_HUB_CAPABILITIES_EX {
 627         USB_HUB_CAP_FLAGS CapabilityFlags;
 628 } USB_HUB_CAPABILITIES_EX, *PUSB_HUB_CAPABILITIES_EX;
 629
 630 #pragma pack(pop)
 631
 632 /* winusb.dll interface */
 633
 634 #define SHORT_PACKET_TERMINATE  0x01
 635 #define AUTO_CLEAR_STALL        0x02
 636 #define PIPE_TRANSFER_TIMEOUT   0x03
 637 #define IGNORE_SHORT_PACKETS    0x04
 638 #define ALLOW_PARTIAL_READS     0x05
 639 #define AUTO_FLUSH              0x06
 640 #define RAW_IO                  0x07
 641 #define MAXIMUM_TRANSFER_SIZE   0x08
 642 #define AUTO_SUSPEND            0x81
 643 #define SUSPEND_DELAY           0x83
 644 #define DEVICE_SPEED            0x01
 645 #define LowSpeed                0x01
 646 #define FullSpeed               0x02
 647 #define HighSpeed               0x03
 648
 649 typedef enum USBD_PIPE_TYPE {
 650         UsbdPipeTypeControl,
 651         UsbdPipeTypeIsochronous,
 652         UsbdPipeTypeBulk,
 653         UsbdPipeTypeInterrupt
 654 } USBD_PIPE_TYPE;
 655
 656 typedef struct {
 657   USBD_PIPE_TYPE PipeType;
 658   UCHAR          PipeId;
 659   USHORT         MaximumPacketSize;
 660   UCHAR          Interval;
 661 } WINUSB_PIPE_INFORMATION, *PWINUSB_PIPE_INFORMATION;
 662
 663 #pragma pack(1)
 664 typedef struct {
 665   UCHAR  request_type;
 666   UCHAR  request;
 667   USHORT value;
 668   USHORT index;
 669   USHORT length;
 670 } WINUSB_SETUP_PACKET, *PWINUSB_SETUP_PACKET;
 671 #pragma pack()
 672
 673 typedef void *WINUSB_INTERFACE_HANDLE, *PWINUSB_INTERFACE_HANDLE;
 674
 675 DLL_DECLARE(WINAPI, BOOL, WinUsb_Initialize, (HANDLE, PWINUSB_INTERFACE_HANDLE));
 676 DLL_DECLARE(WINAPI, BOOL, WinUsb_Free, (WINUSB_INTERFACE_HANDLE));
 677 DLL_DECLARE(WINAPI, BOOL, WinUsb_GetAssociatedInterface, (WINUSB_INTERFACE_HANDLE, UCHAR, PWINUSB_INTERFACE_HANDLE));
 678 DLL_DECLARE(WINAPI, BOOL, WinUsb_GetDescriptor, (WINUSB_INTERFACE_HANDLE, UCHAR, UCHAR, USHORT, PUCHAR, ULONG, PULONG));
 679 DLL_DECLARE(WINAPI, BOOL, WinUsb_QueryInterfaceSettings, (WINUSB_INTERFACE_HANDLE, UCHAR, PUSB_INTERFACE_DESCRIPTOR));
 680 DLL_DECLARE(WINAPI, BOOL, WinUsb_QueryDeviceInformation, (WINUSB_INTERFACE_HANDLE, ULONG, PULONG, PVOID));
 681 DLL_DECLARE(WINAPI, BOOL, WinUsb_SetCurrentAlternateSetting, (WINUSB_INTERFACE_HANDLE, UCHAR));
 682 DLL_DECLARE(WINAPI, BOOL, WinUsb_GetCurrentAlternateSetting, (WINUSB_INTERFACE_HANDLE, PUCHAR));
 683 DLL_DECLARE(WINAPI, BOOL, WinUsb_QueryPipe, (WINUSB_INTERFACE_HANDLE, UCHAR, UCHAR, PWINUSB_PIPE_INFORMATION));
 684 DLL_DECLARE(WINAPI, BOOL, WinUsb_SetPipePolicy, (WINUSB_INTERFACE_HANDLE, UCHAR, ULONG, ULONG, PVOID));
 685 DLL_DECLARE(WINAPI, BOOL, WinUsb_GetPipePolicy, (WINUSB_INTERFACE_HANDLE, UCHAR, ULONG, PULONG, PVOID));
 686 DLL_DECLARE(WINAPI, BOOL, WinUsb_ReadPipe, (WINUSB_INTERFACE_HANDLE, UCHAR, PUCHAR, ULONG, PULONG, LPOVERLAPPED));
 687 DLL_DECLARE(WINAPI, BOOL, WinUsb_WritePipe, (WINUSB_INTERFACE_HANDLE, UCHAR, PUCHAR, ULONG, PULONG, LPOVERLAPPED));
 688 DLL_DECLARE(WINAPI, BOOL, WinUsb_ControlTransfer, (WINUSB_INTERFACE_HANDLE, WINUSB_SETUP_PACKET, PUCHAR, ULONG, PULONG, LPOVERLAPPED));
 689 DLL_DECLARE(WINAPI, BOOL, WinUsb_ResetPipe, (WINUSB_INTERFACE_HANDLE, UCHAR));
 690 DLL_DECLARE(WINAPI, BOOL, WinUsb_AbortPipe, (WINUSB_INTERFACE_HANDLE, UCHAR));
 691 DLL_DECLARE(WINAPI, BOOL, WinUsb_FlushPipe, (WINUSB_INTERFACE_HANDLE, UCHAR));
 692
 693 /* hid.dll interface */
 694
 695 #define HIDP_STATUS_SUCCESS  0x110000
 696 typedef void* PHIDP_PREPARSED_DATA;
 697
 698 #pragma pack(1)
 699 typedef struct {
 700         ULONG Size;
 701         USHORT VendorID;
 702         USHORT ProductID;
 703         USHORT VersionNumber;
 704 } HIDD_ATTRIBUTES, *PHIDD_ATTRIBUTES;
 705 #pragma pack()
 706
 707 typedef USHORT USAGE;
 708 typedef struct {
 709   USAGE Usage;
 710   USAGE UsagePage;
 711   USHORT InputReportByteLength;
 712   USHORT OutputReportByteLength;
 713   USHORT FeatureReportByteLength;
 714   USHORT Reserved[17];
 715   USHORT NumberLinkCollectionNodes;
 716   USHORT NumberInputButtonCaps;
 717   USHORT NumberInputValueCaps;
 718   USHORT NumberInputDataIndices;
 719   USHORT NumberOutputButtonCaps;
 720   USHORT NumberOutputValueCaps;
 721   USHORT NumberOutputDataIndices;
 722   USHORT NumberFeatureButtonCaps;
 723   USHORT NumberFeatureValueCaps;
 724   USHORT NumberFeatureDataIndices;
 725 } HIDP_CAPS, *PHIDP_CAPS;
 726
 727 typedef enum _HIDP_REPORT_TYPE {
 728   HidP_Input,
 729   HidP_Output,
 730   HidP_Feature
 731 } HIDP_REPORT_TYPE;
 732
 733 typedef struct _HIDP_VALUE_CAPS {
 734   USAGE  UsagePage;
 735   UCHAR  ReportID;
 736   BOOLEAN  IsAlias;
 737   USHORT  BitField;
 738   USHORT  LinkCollection;
 739   USAGE  LinkUsage;
 740   USAGE  LinkUsagePage;
 741   BOOLEAN  IsRange;
 742   BOOLEAN  IsStringRange;
 743   BOOLEAN  IsDesignatorRange;
 744   BOOLEAN  IsAbsolute;
 745   BOOLEAN  HasNull;
 746   UCHAR  Reserved;
 747   USHORT  BitSize;
 748   USHORT  ReportCount;
 749   USHORT  Reserved2[5];
 750   ULONG  UnitsExp;
 751   ULONG  Units;
 752   LONG  LogicalMin, LogicalMax;
 753   LONG  PhysicalMin, PhysicalMax;
 754         union {
 755           struct {
 756                 USAGE  UsageMin, UsageMax;
 757                 USHORT  StringMin, StringMax;
 758                 USHORT  DesignatorMin, DesignatorMax;
 759                 USHORT  DataIndexMin, DataIndexMax;
 760           } Range;
 761           struct {
 762                 USAGE  Usage, Reserved1;
 763                 USHORT  StringIndex, Reserved2;
 764                 USHORT  DesignatorIndex, Reserved3;
 765                 USHORT  DataIndex, Reserved4;
 766           } NotRange;
 767         } u;
 768 } HIDP_VALUE_CAPS, *PHIDP_VALUE_CAPS;
 769
 770 DLL_DECLARE(WINAPI, BOOL, HidD_GetAttributes, (HANDLE, PHIDD_ATTRIBUTES));
 771 DLL_DECLARE(WINAPI, VOID, HidD_GetHidGuid, (LPGUID));
 772 DLL_DECLARE(WINAPI, BOOL, HidD_GetPreparsedData, (HANDLE, PHIDP_PREPARSED_DATA *));
 773 DLL_DECLARE(WINAPI, BOOL, HidD_FreePreparsedData, (PHIDP_PREPARSED_DATA));
 774 DLL_DECLARE(WINAPI, BOOL, HidD_GetManufacturerString, (HANDLE, PVOID, ULONG));
 775 DLL_DECLARE(WINAPI, BOOL, HidD_GetProductString, (HANDLE, PVOID, ULONG));
 776 DLL_DECLARE(WINAPI, BOOL, HidD_GetSerialNumberString, (HANDLE, PVOID, ULONG));
 777 DLL_DECLARE(WINAPI, LONG, HidP_GetCaps, (PHIDP_PREPARSED_DATA, PHIDP_CAPS));
 778 DLL_DECLARE(WINAPI, BOOL, HidD_SetNumInputBuffers, (HANDLE, ULONG));
 779 DLL_DECLARE(WINAPI, BOOL, HidD_SetFeature, (HANDLE, PVOID, ULONG));
 780 DLL_DECLARE(WINAPI, BOOL, HidD_GetFeature, (HANDLE, PVOID, ULONG));
 781 DLL_DECLARE(WINAPI, BOOL, HidD_GetPhysicalDescriptor, (HANDLE, PVOID, ULONG));
 782 DLL_DECLARE(WINAPI, BOOL, HidD_GetInputReport, (HANDLE, PVOID, ULONG));
 783 DLL_DECLARE(WINAPI, BOOL, HidD_SetOutputReport, (HANDLE, PVOID, ULONG));
 784 DLL_DECLARE(WINAPI, BOOL, HidD_FlushQueue, (HANDLE));
 785 DLL_DECLARE(WINAPI, BOOL, HidP_GetValueCaps, (HIDP_REPORT_TYPE, PHIDP_VALUE_CAPS, PULONG, PHIDP_PREPARSED_DATA));