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 #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
_device_priv(struct libusb_device * dev)229 static inline struct windows_device_priv *_device_priv(struct libusb_device *dev) {
230 return (struct windows_device_priv *)dev->os_priv;
231 }
232
windows_device_priv_init(libusb_device * dev)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
windows_device_priv_release(libusb_device * dev)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
_device_handle_priv(struct libusb_device_handle * handle)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