release/src/router/libusb10/libusb/os/windows_usb.h

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