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