/* * Windows backend for libusb 1.0 * Copyright © 2009-2012 Pete Batard * With contributions from Michael Plante, Orin Eman et al. * Parts of this code adapted from libusb-win32-v1 by Stephan Meyer * Major code testing contribution by Xiaofan Chen * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #pragma once #include "windows_common.h" #include "windows_nt_common.h" #if defined(_MSC_VER) // disable /W4 MSVC warnings that are benign #pragma warning(disable:4100) // unreferenced formal parameter #pragma warning(disable:4127) // conditional expression is constant #pragma warning(disable:4201) // nameless struct/union #pragma warning(disable:4214) // bit field types other than int #pragma warning(disable:4996) // deprecated API calls #pragma warning(disable:28159) // more deprecated API calls #endif // Missing from MSVC6 setupapi.h #if !defined(SPDRP_ADDRESS) #define SPDRP_ADDRESS 28 #endif #if !defined(SPDRP_INSTALL_STATE) #define SPDRP_INSTALL_STATE 34 #endif #define MAX_CTRL_BUFFER_LENGTH 4096 #define MAX_USB_DEVICES 256 #define MAX_USB_STRING_LENGTH 128 #define MAX_HID_REPORT_SIZE 1024 #define MAX_HID_DESCRIPTOR_SIZE 256 #define MAX_GUID_STRING_LENGTH 40 #define MAX_PATH_LENGTH 128 #define MAX_KEY_LENGTH 256 #define LIST_SEPARATOR ';' // Handle code for HID interface that have been claimed ("dibs") #define INTERFACE_CLAIMED ((HANDLE)(intptr_t)0xD1B5) // Additional return code for HID operations that completed synchronously #define LIBUSB_COMPLETED (LIBUSB_SUCCESS + 1) // http://msdn.microsoft.com/en-us/library/ff545978.aspx // http://msdn.microsoft.com/en-us/library/ff545972.aspx // http://msdn.microsoft.com/en-us/library/ff545982.aspx #if !defined(GUID_DEVINTERFACE_USB_HOST_CONTROLLER) const GUID GUID_DEVINTERFACE_USB_HOST_CONTROLLER = { 0x3ABF6F2D, 0x71C4, 0x462A, {0x8A, 0x92, 0x1E, 0x68, 0x61, 0xE6, 0xAF, 0x27} }; #endif #if !defined(GUID_DEVINTERFACE_USB_DEVICE) const GUID GUID_DEVINTERFACE_USB_DEVICE = { 0xA5DCBF10, 0x6530, 0x11D2, {0x90, 0x1F, 0x00, 0xC0, 0x4F, 0xB9, 0x51, 0xED} }; #endif #if !defined(GUID_DEVINTERFACE_USB_HUB) const GUID GUID_DEVINTERFACE_USB_HUB = { 0xF18A0E88, 0xC30C, 0x11D0, {0x88, 0x15, 0x00, 0xA0, 0xC9, 0x06, 0xBE, 0xD8} }; #endif #if !defined(GUID_DEVINTERFACE_LIBUSB0_FILTER) const GUID GUID_DEVINTERFACE_LIBUSB0_FILTER = { 0xF9F3FF14, 0xAE21, 0x48A0, {0x8A, 0x25, 0x80, 0x11, 0xA7, 0xA9, 0x31, 0xD9} }; #endif /* * Multiple USB API backend support */ #define USB_API_UNSUPPORTED 0 #define USB_API_HUB 1 #define USB_API_COMPOSITE 2 #define USB_API_WINUSBX 3 #define USB_API_HID 4 #define USB_API_MAX 5 // The following is used to indicate if the HID or composite extra props have already been set. #define USB_API_SET (1 << USB_API_MAX) // Sub-APIs for WinUSB-like driver APIs (WinUSB, libusbK, libusb-win32 through the libusbK DLL) // Must have the same values as the KUSB_DRVID enum from libusbk.h #define SUB_API_NOTSET -1 #define SUB_API_LIBUSBK 0 #define SUB_API_LIBUSB0 1 #define SUB_API_WINUSB 2 #define SUB_API_MAX 3 #define WINUSBX_DRV_NAMES {"libusbK", "libusb0", "WinUSB"} struct windows_usb_api_backend { const uint8_t id; const char *designation; const char **driver_name_list; // Driver name, without .sys, e.g. "usbccgp" const uint8_t nb_driver_names; int (*init)(int sub_api, struct libusb_context *ctx); int (*exit)(int sub_api); int (*open)(int sub_api, struct libusb_device_handle *dev_handle); void (*close)(int sub_api, struct libusb_device_handle *dev_handle); int (*configure_endpoints)(int sub_api, struct libusb_device_handle *dev_handle, int iface); int (*claim_interface)(int sub_api, struct libusb_device_handle *dev_handle, int iface); int (*set_interface_altsetting)(int sub_api, struct libusb_device_handle *dev_handle, int iface, int altsetting); int (*release_interface)(int sub_api, struct libusb_device_handle *dev_handle, int iface); int (*clear_halt)(int sub_api, struct libusb_device_handle *dev_handle, unsigned char endpoint); int (*reset_device)(int sub_api, struct libusb_device_handle *dev_handle); int (*submit_bulk_transfer)(int sub_api, struct usbi_transfer *itransfer); int (*submit_iso_transfer)(int sub_api, struct usbi_transfer *itransfer); int (*submit_control_transfer)(int sub_api, struct usbi_transfer *itransfer); int (*abort_control)(int sub_api, struct usbi_transfer *itransfer); int (*abort_transfers)(int sub_api, struct usbi_transfer *itransfer); int (*copy_transfer_data)(int sub_api, struct usbi_transfer *itransfer, uint32_t io_size); }; extern const struct windows_usb_api_backend usb_api_backend[USB_API_MAX]; #define PRINT_UNSUPPORTED_API(fname) \ usbi_dbg("unsupported API call for '" \ #fname "' (unrecognized device driver)"); \ return LIBUSB_ERROR_NOT_SUPPORTED; /* * private structures definition * with inline pseudo constructors/destructors */ // TODO (v2+): move hid desc to libusb.h? struct libusb_hid_descriptor { uint8_t bLength; uint8_t bDescriptorType; uint16_t bcdHID; uint8_t bCountryCode; uint8_t bNumDescriptors; uint8_t bClassDescriptorType; uint16_t wClassDescriptorLength; }; #define LIBUSB_DT_HID_SIZE 9 #define HID_MAX_CONFIG_DESC_SIZE (LIBUSB_DT_CONFIG_SIZE + LIBUSB_DT_INTERFACE_SIZE \ + LIBUSB_DT_HID_SIZE + 2 * LIBUSB_DT_ENDPOINT_SIZE) #define HID_MAX_REPORT_SIZE 1024 #define HID_IN_EP 0x81 #define HID_OUT_EP 0x02 #define LIBUSB_REQ_RECIPIENT(request_type) ((request_type) & 0x1F) #define LIBUSB_REQ_TYPE(request_type) ((request_type) & (0x03 << 5)) #define LIBUSB_REQ_IN(request_type) ((request_type) & LIBUSB_ENDPOINT_IN) #define LIBUSB_REQ_OUT(request_type) (!LIBUSB_REQ_IN(request_type)) // The following are used for HID reports IOCTLs #define HID_CTL_CODE(id) \ CTL_CODE (FILE_DEVICE_KEYBOARD, (id), METHOD_NEITHER, FILE_ANY_ACCESS) #define HID_BUFFER_CTL_CODE(id) \ CTL_CODE (FILE_DEVICE_KEYBOARD, (id), METHOD_BUFFERED, FILE_ANY_ACCESS) #define HID_IN_CTL_CODE(id) \ CTL_CODE (FILE_DEVICE_KEYBOARD, (id), METHOD_IN_DIRECT, FILE_ANY_ACCESS) #define HID_OUT_CTL_CODE(id) \ CTL_CODE (FILE_DEVICE_KEYBOARD, (id), METHOD_OUT_DIRECT, FILE_ANY_ACCESS) #define IOCTL_HID_GET_FEATURE HID_OUT_CTL_CODE(100) #define IOCTL_HID_GET_INPUT_REPORT HID_OUT_CTL_CODE(104) #define IOCTL_HID_SET_FEATURE HID_IN_CTL_CODE(100) #define IOCTL_HID_SET_OUTPUT_REPORT HID_IN_CTL_CODE(101) enum libusb_hid_request_type { HID_REQ_GET_REPORT = 0x01, HID_REQ_GET_IDLE = 0x02, HID_REQ_GET_PROTOCOL = 0x03, HID_REQ_SET_REPORT = 0x09, HID_REQ_SET_IDLE = 0x0A, HID_REQ_SET_PROTOCOL = 0x0B }; enum libusb_hid_report_type { HID_REPORT_TYPE_INPUT = 0x01, HID_REPORT_TYPE_OUTPUT = 0x02, HID_REPORT_TYPE_FEATURE = 0x03 }; struct hid_device_priv { uint16_t vid; uint16_t pid; uint8_t config; uint8_t nb_interfaces; bool uses_report_ids[3]; // input, ouptput, feature uint16_t input_report_size; uint16_t output_report_size; uint16_t feature_report_size; WCHAR string[3][MAX_USB_STRING_LENGTH]; uint8_t string_index[3]; // man, prod, ser }; struct windows_device_priv { uint8_t depth; // distance to HCD uint8_t port; // port number on the hub uint8_t active_config; struct windows_usb_api_backend const *apib; char *path; // device interface path int sub_api; // for WinUSB-like APIs struct { char *path; // each interface needs a device interface path, struct windows_usb_api_backend const *apib; // an API backend (multiple drivers support), int sub_api; int8_t nb_endpoints; // and a set of endpoint addresses (USB_MAXENDPOINTS) uint8_t *endpoint; bool restricted_functionality; // indicates if the interface functionality is restricted // by Windows (eg. HID keyboards or mice cannot do R/W) } usb_interface[USB_MAXINTERFACES]; struct hid_device_priv *hid; USB_DEVICE_DESCRIPTOR dev_descriptor; unsigned char **config_descriptor; // list of pointers to the cached config descriptors }; static inline struct windows_device_priv *_device_priv(struct libusb_device *dev) { return (struct windows_device_priv *)dev->os_priv; } static inline struct windows_device_priv *windows_device_priv_init(struct libusb_device *dev) { struct windows_device_priv *p = _device_priv(dev); int i; p->depth = 0; p->port = 0; p->path = NULL; p->apib = &usb_api_backend[USB_API_UNSUPPORTED]; p->sub_api = SUB_API_NOTSET; p->hid = NULL; p->active_config = 0; p->config_descriptor = NULL; memset(&p->dev_descriptor, 0, sizeof(USB_DEVICE_DESCRIPTOR)); for (i = 0; i < USB_MAXINTERFACES; i++) { p->usb_interface[i].path = NULL; p->usb_interface[i].apib = &usb_api_backend[USB_API_UNSUPPORTED]; p->usb_interface[i].sub_api = SUB_API_NOTSET; p->usb_interface[i].nb_endpoints = 0; p->usb_interface[i].endpoint = NULL; p->usb_interface[i].restricted_functionality = false; } return p; } static inline void windows_device_priv_release(struct libusb_device *dev) { struct windows_device_priv *p = _device_priv(dev); int i; safe_free(p->path); if ((dev->num_configurations > 0) && (p->config_descriptor != NULL)) { for (i = 0; i < dev->num_configurations; i++) safe_free(p->config_descriptor[i]); } safe_free(p->config_descriptor); safe_free(p->hid); for (i = 0; i < USB_MAXINTERFACES; i++) { safe_free(p->usb_interface[i].path); safe_free(p->usb_interface[i].endpoint); } } struct interface_handle_t { HANDLE dev_handle; // WinUSB needs an extra handle for the file HANDLE api_handle; // used by the API to communicate with the device }; struct windows_device_handle_priv { int active_interface; struct interface_handle_t interface_handle[USB_MAXINTERFACES]; int autoclaim_count[USB_MAXINTERFACES]; // For auto-release }; static inline struct windows_device_handle_priv *_device_handle_priv( struct libusb_device_handle *handle) { return (struct windows_device_handle_priv *)handle->os_priv; } // used for async polling functions struct windows_transfer_priv { struct winfd pollable_fd; uint8_t interface_number; uint8_t *hid_buffer; // 1 byte extended data buffer, required for HID uint8_t *hid_dest; // transfer buffer destination, required for HID size_t hid_expected_size; }; // used to match a device driver (including filter drivers) against a supported API struct driver_lookup { char list[MAX_KEY_LENGTH + 1]; // REG_MULTI_SZ list of services (driver) names const DWORD reg_prop; // SPDRP registry key to use to retrieve list const char* designation; // internal designation (for debug output) }; /* OLE32 dependency */ DLL_DECLARE_HANDLE(OLE32); DLL_DECLARE_FUNC_PREFIXED(WINAPI, HRESULT, p, CLSIDFromString, (LPCOLESTR, LPCLSID)); /* Kernel32 dependencies */ DLL_DECLARE_HANDLE(Kernel32); /* This call is only available from XP SP2 */ DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, IsWow64Process, (HANDLE, PBOOL)); /* SetupAPI dependencies */ DLL_DECLARE_HANDLE(SetupAPI); DLL_DECLARE_FUNC_PREFIXED(WINAPI, HDEVINFO, p, SetupDiGetClassDevsA, (const GUID*, PCSTR, HWND, DWORD)); DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiEnumDeviceInfo, (HDEVINFO, DWORD, PSP_DEVINFO_DATA)); DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiEnumDeviceInterfaces, (HDEVINFO, PSP_DEVINFO_DATA, const GUID*, DWORD, PSP_DEVICE_INTERFACE_DATA)); DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiGetDeviceInterfaceDetailA, (HDEVINFO, PSP_DEVICE_INTERFACE_DATA, PSP_DEVICE_INTERFACE_DETAIL_DATA_A, DWORD, PDWORD, PSP_DEVINFO_DATA)); DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiDestroyDeviceInfoList, (HDEVINFO)); DLL_DECLARE_FUNC_PREFIXED(WINAPI, HKEY, p, SetupDiOpenDevRegKey, (HDEVINFO, PSP_DEVINFO_DATA, DWORD, DWORD, DWORD, REGSAM)); DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiGetDeviceRegistryPropertyA, (HDEVINFO, PSP_DEVINFO_DATA, DWORD, PDWORD, PBYTE, DWORD, PDWORD)); DLL_DECLARE_FUNC_PREFIXED(WINAPI, HKEY, p, SetupDiOpenDeviceInterfaceRegKey, (HDEVINFO, PSP_DEVICE_INTERFACE_DATA, DWORD, DWORD)); /* AdvAPI32 dependencies */ DLL_DECLARE_HANDLE(AdvAPI32); DLL_DECLARE_FUNC_PREFIXED(WINAPI, LONG, p, RegQueryValueExW, (HKEY, LPCWSTR, LPDWORD, LPDWORD, LPBYTE, LPDWORD)); DLL_DECLARE_FUNC_PREFIXED(WINAPI, LONG, p, RegCloseKey, (HKEY)); /* * Windows DDK API definitions. Most of it copied from MinGW's includes */ typedef DWORD DEVNODE, DEVINST; typedef DEVNODE *PDEVNODE, *PDEVINST; typedef DWORD RETURN_TYPE; typedef RETURN_TYPE CONFIGRET; #define CR_SUCCESS 0x00000000 #define CR_NO_SUCH_DEVNODE 0x0000000D #define USB_DEVICE_DESCRIPTOR_TYPE LIBUSB_DT_DEVICE #define USB_CONFIGURATION_DESCRIPTOR_TYPE LIBUSB_DT_CONFIG #define USB_STRING_DESCRIPTOR_TYPE LIBUSB_DT_STRING #define USB_INTERFACE_DESCRIPTOR_TYPE LIBUSB_DT_INTERFACE #define USB_ENDPOINT_DESCRIPTOR_TYPE LIBUSB_DT_ENDPOINT #define USB_REQUEST_GET_STATUS LIBUSB_REQUEST_GET_STATUS #define USB_REQUEST_CLEAR_FEATURE LIBUSB_REQUEST_CLEAR_FEATURE #define USB_REQUEST_SET_FEATURE LIBUSB_REQUEST_SET_FEATURE #define USB_REQUEST_SET_ADDRESS LIBUSB_REQUEST_SET_ADDRESS #define USB_REQUEST_GET_DESCRIPTOR LIBUSB_REQUEST_GET_DESCRIPTOR #define USB_REQUEST_SET_DESCRIPTOR LIBUSB_REQUEST_SET_DESCRIPTOR #define USB_REQUEST_GET_CONFIGURATION LIBUSB_REQUEST_GET_CONFIGURATION #define USB_REQUEST_SET_CONFIGURATION LIBUSB_REQUEST_SET_CONFIGURATION #define USB_REQUEST_GET_INTERFACE LIBUSB_REQUEST_GET_INTERFACE #define USB_REQUEST_SET_INTERFACE LIBUSB_REQUEST_SET_INTERFACE #define USB_REQUEST_SYNC_FRAME LIBUSB_REQUEST_SYNCH_FRAME #define USB_GET_NODE_INFORMATION 258 #define USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION 260 #define USB_GET_NODE_CONNECTION_NAME 261 #define USB_GET_HUB_CAPABILITIES 271 #if !defined(USB_GET_NODE_CONNECTION_INFORMATION_EX) #define USB_GET_NODE_CONNECTION_INFORMATION_EX 274 #endif #if !defined(USB_GET_HUB_CAPABILITIES_EX) #define USB_GET_HUB_CAPABILITIES_EX 276 #endif #if !defined(USB_GET_NODE_CONNECTION_INFORMATION_EX_V2) #define USB_GET_NODE_CONNECTION_INFORMATION_EX_V2 279 #endif #ifndef METHOD_BUFFERED #define METHOD_BUFFERED 0 #endif #ifndef FILE_ANY_ACCESS #define FILE_ANY_ACCESS 0x00000000 #endif #ifndef FILE_DEVICE_UNKNOWN #define FILE_DEVICE_UNKNOWN 0x00000022 #endif #ifndef FILE_DEVICE_USB #define FILE_DEVICE_USB FILE_DEVICE_UNKNOWN #endif #ifndef CTL_CODE #define CTL_CODE(DeviceType, Function, Method, Access) \ (((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method)) #endif typedef enum USB_CONNECTION_STATUS { NoDeviceConnected, DeviceConnected, DeviceFailedEnumeration, DeviceGeneralFailure, DeviceCausedOvercurrent, DeviceNotEnoughPower, DeviceNotEnoughBandwidth, DeviceHubNestedTooDeeply, DeviceInLegacyHub } USB_CONNECTION_STATUS, *PUSB_CONNECTION_STATUS; typedef enum USB_HUB_NODE { UsbHub, UsbMIParent } USB_HUB_NODE; /* Cfgmgr32.dll interface */ DLL_DECLARE_HANDLE(Cfgmgr32); DLL_DECLARE_FUNC(WINAPI, CONFIGRET, CM_Get_Parent, (PDEVINST, DEVINST, ULONG)); DLL_DECLARE_FUNC(WINAPI, CONFIGRET, CM_Get_Child, (PDEVINST, DEVINST, ULONG)); DLL_DECLARE_FUNC(WINAPI, CONFIGRET, CM_Get_Sibling, (PDEVINST, DEVINST, ULONG)); DLL_DECLARE_FUNC(WINAPI, CONFIGRET, CM_Get_Device_IDA, (DEVINST, PCHAR, ULONG, ULONG)); #define IOCTL_USB_GET_HUB_CAPABILITIES_EX \ CTL_CODE( FILE_DEVICE_USB, USB_GET_HUB_CAPABILITIES_EX, METHOD_BUFFERED, FILE_ANY_ACCESS) #define IOCTL_USB_GET_HUB_CAPABILITIES \ CTL_CODE(FILE_DEVICE_USB, USB_GET_HUB_CAPABILITIES, METHOD_BUFFERED, FILE_ANY_ACCESS) #define IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION \ CTL_CODE(FILE_DEVICE_USB, USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION, METHOD_BUFFERED, FILE_ANY_ACCESS) #define IOCTL_USB_GET_ROOT_HUB_NAME \ CTL_CODE(FILE_DEVICE_USB, HCD_GET_ROOT_HUB_NAME, METHOD_BUFFERED, FILE_ANY_ACCESS) #define IOCTL_USB_GET_NODE_INFORMATION \ CTL_CODE(FILE_DEVICE_USB, USB_GET_NODE_INFORMATION, METHOD_BUFFERED, FILE_ANY_ACCESS) #define IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX \ CTL_CODE(FILE_DEVICE_USB, USB_GET_NODE_CONNECTION_INFORMATION_EX, METHOD_BUFFERED, FILE_ANY_ACCESS) #define IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX_V2 \ CTL_CODE(FILE_DEVICE_USB, USB_GET_NODE_CONNECTION_INFORMATION_EX_V2, METHOD_BUFFERED, FILE_ANY_ACCESS) #define IOCTL_USB_GET_NODE_CONNECTION_ATTRIBUTES \ CTL_CODE(FILE_DEVICE_USB, USB_GET_NODE_CONNECTION_ATTRIBUTES, METHOD_BUFFERED, FILE_ANY_ACCESS) #define IOCTL_USB_GET_NODE_CONNECTION_NAME \ CTL_CODE(FILE_DEVICE_USB, USB_GET_NODE_CONNECTION_NAME, METHOD_BUFFERED, FILE_ANY_ACCESS) // Most of the structures below need to be packed #pragma pack(push, 1) typedef struct USB_INTERFACE_DESCRIPTOR { UCHAR bLength; UCHAR bDescriptorType; UCHAR bInterfaceNumber; UCHAR bAlternateSetting; UCHAR bNumEndpoints; UCHAR bInterfaceClass; UCHAR bInterfaceSubClass; UCHAR bInterfaceProtocol; UCHAR iInterface; } USB_INTERFACE_DESCRIPTOR, *PUSB_INTERFACE_DESCRIPTOR; typedef struct USB_CONFIGURATION_DESCRIPTOR_SHORT { struct { ULONG ConnectionIndex; struct { UCHAR bmRequest; UCHAR bRequest; USHORT wValue; USHORT wIndex; USHORT wLength; } SetupPacket; } req; USB_CONFIGURATION_DESCRIPTOR data; } USB_CONFIGURATION_DESCRIPTOR_SHORT; typedef struct USB_ENDPOINT_DESCRIPTOR { UCHAR bLength; UCHAR bDescriptorType; UCHAR bEndpointAddress; UCHAR bmAttributes; USHORT wMaxPacketSize; UCHAR bInterval; } USB_ENDPOINT_DESCRIPTOR, *PUSB_ENDPOINT_DESCRIPTOR; typedef struct USB_DESCRIPTOR_REQUEST { ULONG ConnectionIndex; struct { UCHAR bmRequest; UCHAR bRequest; USHORT wValue; USHORT wIndex; USHORT wLength; } SetupPacket; // UCHAR Data[0]; } USB_DESCRIPTOR_REQUEST, *PUSB_DESCRIPTOR_REQUEST; typedef struct USB_HUB_DESCRIPTOR { UCHAR bDescriptorLength; UCHAR bDescriptorType; UCHAR bNumberOfPorts; USHORT wHubCharacteristics; UCHAR bPowerOnToPowerGood; UCHAR bHubControlCurrent; UCHAR bRemoveAndPowerMask[64]; } USB_HUB_DESCRIPTOR, *PUSB_HUB_DESCRIPTOR; typedef struct USB_ROOT_HUB_NAME { ULONG ActualLength; WCHAR RootHubName[1]; } USB_ROOT_HUB_NAME, *PUSB_ROOT_HUB_NAME; typedef struct USB_ROOT_HUB_NAME_FIXED { ULONG ActualLength; WCHAR RootHubName[MAX_PATH_LENGTH]; } USB_ROOT_HUB_NAME_FIXED; typedef struct USB_NODE_CONNECTION_NAME { ULONG ConnectionIndex; ULONG ActualLength; WCHAR NodeName[1]; } USB_NODE_CONNECTION_NAME, *PUSB_NODE_CONNECTION_NAME; typedef struct USB_NODE_CONNECTION_NAME_FIXED { ULONG ConnectionIndex; ULONG ActualLength; WCHAR NodeName[MAX_PATH_LENGTH]; } USB_NODE_CONNECTION_NAME_FIXED; typedef struct USB_HUB_NAME_FIXED { union { USB_ROOT_HUB_NAME_FIXED root; USB_NODE_CONNECTION_NAME_FIXED node; } u; } USB_HUB_NAME_FIXED; typedef struct USB_HUB_INFORMATION { USB_HUB_DESCRIPTOR HubDescriptor; BOOLEAN HubIsBusPowered; } USB_HUB_INFORMATION, *PUSB_HUB_INFORMATION; typedef struct USB_MI_PARENT_INFORMATION { ULONG NumberOfInterfaces; } USB_MI_PARENT_INFORMATION, *PUSB_MI_PARENT_INFORMATION; typedef struct USB_NODE_INFORMATION { USB_HUB_NODE NodeType; union { USB_HUB_INFORMATION HubInformation; USB_MI_PARENT_INFORMATION MiParentInformation; } u; } USB_NODE_INFORMATION, *PUSB_NODE_INFORMATION; typedef struct USB_PIPE_INFO { USB_ENDPOINT_DESCRIPTOR EndpointDescriptor; ULONG ScheduleOffset; } USB_PIPE_INFO, *PUSB_PIPE_INFO; typedef struct USB_NODE_CONNECTION_INFORMATION_EX { ULONG ConnectionIndex; USB_DEVICE_DESCRIPTOR DeviceDescriptor; UCHAR CurrentConfigurationValue; UCHAR Speed; BOOLEAN DeviceIsHub; USHORT DeviceAddress; ULONG NumberOfOpenPipes; USB_CONNECTION_STATUS ConnectionStatus; // USB_PIPE_INFO PipeList[0]; } USB_NODE_CONNECTION_INFORMATION_EX, *PUSB_NODE_CONNECTION_INFORMATION_EX; typedef union _USB_PROTOCOLS { ULONG ul; struct { ULONG Usb110:1; ULONG Usb200:1; ULONG Usb300:1; ULONG ReservedMBZ:29; }; } USB_PROTOCOLS, *PUSB_PROTOCOLS; typedef union _USB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGS { ULONG ul; struct { ULONG DeviceIsOperatingAtSuperSpeedOrHigher:1; ULONG DeviceIsSuperSpeedCapableOrHigher:1; ULONG ReservedMBZ:30; }; } USB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGS, *PUSB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGS; typedef struct _USB_NODE_CONNECTION_INFORMATION_EX_V2 { ULONG ConnectionIndex; ULONG Length; USB_PROTOCOLS SupportedUsbProtocols; USB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGS Flags; } USB_NODE_CONNECTION_INFORMATION_EX_V2, *PUSB_NODE_CONNECTION_INFORMATION_EX_V2; typedef struct USB_HUB_CAP_FLAGS { ULONG HubIsHighSpeedCapable:1; ULONG HubIsHighSpeed:1; ULONG HubIsMultiTtCapable:1; ULONG HubIsMultiTt:1; ULONG HubIsRoot:1; ULONG HubIsArmedWakeOnConnect:1; ULONG ReservedMBZ:26; } USB_HUB_CAP_FLAGS, *PUSB_HUB_CAP_FLAGS; typedef struct USB_HUB_CAPABILITIES { ULONG HubIs2xCapable:1; } USB_HUB_CAPABILITIES, *PUSB_HUB_CAPABILITIES; typedef struct USB_HUB_CAPABILITIES_EX { USB_HUB_CAP_FLAGS CapabilityFlags; } USB_HUB_CAPABILITIES_EX, *PUSB_HUB_CAPABILITIES_EX; #pragma pack(pop) /* winusb.dll interface */ #define SHORT_PACKET_TERMINATE 0x01 #define AUTO_CLEAR_STALL 0x02 #define PIPE_TRANSFER_TIMEOUT 0x03 #define IGNORE_SHORT_PACKETS 0x04 #define ALLOW_PARTIAL_READS 0x05 #define AUTO_FLUSH 0x06 #define RAW_IO 0x07 #define MAXIMUM_TRANSFER_SIZE 0x08 #define AUTO_SUSPEND 0x81 #define SUSPEND_DELAY 0x83 #define DEVICE_SPEED 0x01 #define LowSpeed 0x01 #define FullSpeed 0x02 #define HighSpeed 0x03 typedef enum USBD_PIPE_TYPE { UsbdPipeTypeControl, UsbdPipeTypeIsochronous, UsbdPipeTypeBulk, UsbdPipeTypeInterrupt } USBD_PIPE_TYPE; typedef struct { USBD_PIPE_TYPE PipeType; UCHAR PipeId; USHORT MaximumPacketSize; UCHAR Interval; } WINUSB_PIPE_INFORMATION, *PWINUSB_PIPE_INFORMATION; #pragma pack(1) typedef struct { UCHAR request_type; UCHAR request; USHORT value; USHORT index; USHORT length; } WINUSB_SETUP_PACKET, *PWINUSB_SETUP_PACKET; #pragma pack() typedef void *WINUSB_INTERFACE_HANDLE, *PWINUSB_INTERFACE_HANDLE; typedef BOOL (WINAPI *WinUsb_AbortPipe_t)( WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR PipeID ); typedef BOOL (WINAPI *WinUsb_ControlTransfer_t)( WINUSB_INTERFACE_HANDLE InterfaceHandle, WINUSB_SETUP_PACKET SetupPacket, PUCHAR Buffer, ULONG BufferLength, PULONG LengthTransferred, LPOVERLAPPED Overlapped ); typedef BOOL (WINAPI *WinUsb_FlushPipe_t)( WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR PipeID ); typedef BOOL (WINAPI *WinUsb_Free_t)( WINUSB_INTERFACE_HANDLE InterfaceHandle ); typedef BOOL (WINAPI *WinUsb_GetAssociatedInterface_t)( WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR AssociatedInterfaceIndex, PWINUSB_INTERFACE_HANDLE AssociatedInterfaceHandle ); typedef BOOL (WINAPI *WinUsb_GetCurrentAlternateSetting_t)( WINUSB_INTERFACE_HANDLE InterfaceHandle, PUCHAR AlternateSetting ); typedef BOOL (WINAPI *WinUsb_GetDescriptor_t)( WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR DescriptorType, UCHAR Index, USHORT LanguageID, PUCHAR Buffer, ULONG BufferLength, PULONG LengthTransferred ); typedef BOOL (WINAPI *WinUsb_GetOverlappedResult_t)( WINUSB_INTERFACE_HANDLE InterfaceHandle, LPOVERLAPPED lpOverlapped, LPDWORD lpNumberOfBytesTransferred, BOOL bWait ); typedef BOOL (WINAPI *WinUsb_GetPipePolicy_t)( WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR PipeID, ULONG PolicyType, PULONG ValueLength, PVOID Value ); typedef BOOL (WINAPI *WinUsb_GetPowerPolicy_t)( WINUSB_INTERFACE_HANDLE InterfaceHandle, ULONG PolicyType, PULONG ValueLength, PVOID Value ); typedef BOOL (WINAPI *WinUsb_Initialize_t)( HANDLE DeviceHandle, PWINUSB_INTERFACE_HANDLE InterfaceHandle ); typedef BOOL (WINAPI *WinUsb_QueryDeviceInformation_t)( WINUSB_INTERFACE_HANDLE InterfaceHandle, ULONG InformationType, PULONG BufferLength, PVOID Buffer ); typedef BOOL (WINAPI *WinUsb_QueryInterfaceSettings_t)( WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR AlternateSettingNumber, PUSB_INTERFACE_DESCRIPTOR UsbAltInterfaceDescriptor ); typedef BOOL (WINAPI *WinUsb_QueryPipe_t)( WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR AlternateInterfaceNumber, UCHAR PipeIndex, PWINUSB_PIPE_INFORMATION PipeInformation ); typedef BOOL (WINAPI *WinUsb_ReadPipe_t)( WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR PipeID, PUCHAR Buffer, ULONG BufferLength, PULONG LengthTransferred, LPOVERLAPPED Overlapped ); typedef BOOL (WINAPI *WinUsb_ResetPipe_t)( WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR PipeID ); typedef BOOL (WINAPI *WinUsb_SetCurrentAlternateSetting_t)( WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR AlternateSetting ); typedef BOOL (WINAPI *WinUsb_SetPipePolicy_t)( WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR PipeID, ULONG PolicyType, ULONG ValueLength, PVOID Value ); typedef BOOL (WINAPI *WinUsb_SetPowerPolicy_t)( WINUSB_INTERFACE_HANDLE InterfaceHandle, ULONG PolicyType, ULONG ValueLength, PVOID Value ); typedef BOOL (WINAPI *WinUsb_WritePipe_t)( WINUSB_INTERFACE_HANDLE InterfaceHandle, UCHAR PipeID, PUCHAR Buffer, ULONG BufferLength, PULONG LengthTransferred, LPOVERLAPPED Overlapped ); typedef BOOL (WINAPI *WinUsb_ResetDevice_t)( WINUSB_INTERFACE_HANDLE InterfaceHandle ); /* /!\ These must match the ones from the official libusbk.h */ typedef enum _KUSB_FNID { KUSB_FNID_Init, KUSB_FNID_Free, KUSB_FNID_ClaimInterface, KUSB_FNID_ReleaseInterface, KUSB_FNID_SetAltInterface, KUSB_FNID_GetAltInterface, KUSB_FNID_GetDescriptor, KUSB_FNID_ControlTransfer, KUSB_FNID_SetPowerPolicy, KUSB_FNID_GetPowerPolicy, KUSB_FNID_SetConfiguration, KUSB_FNID_GetConfiguration, KUSB_FNID_ResetDevice, KUSB_FNID_Initialize, KUSB_FNID_SelectInterface, KUSB_FNID_GetAssociatedInterface, KUSB_FNID_Clone, KUSB_FNID_QueryInterfaceSettings, KUSB_FNID_QueryDeviceInformation, KUSB_FNID_SetCurrentAlternateSetting, KUSB_FNID_GetCurrentAlternateSetting, KUSB_FNID_QueryPipe, KUSB_FNID_SetPipePolicy, KUSB_FNID_GetPipePolicy, KUSB_FNID_ReadPipe, KUSB_FNID_WritePipe, KUSB_FNID_ResetPipe, KUSB_FNID_AbortPipe, KUSB_FNID_FlushPipe, KUSB_FNID_IsoReadPipe, KUSB_FNID_IsoWritePipe, KUSB_FNID_GetCurrentFrameNumber, KUSB_FNID_GetOverlappedResult, KUSB_FNID_GetProperty, KUSB_FNID_COUNT, } KUSB_FNID; typedef struct _KLIB_VERSION { INT Major; INT Minor; INT Micro; INT Nano; } KLIB_VERSION; typedef KLIB_VERSION* PKLIB_VERSION; typedef BOOL (WINAPI *LibK_GetProcAddress_t)( PVOID *ProcAddress, ULONG DriverID, ULONG FunctionID ); typedef VOID (WINAPI *LibK_GetVersion_t)( PKLIB_VERSION Version ); struct winusb_interface { bool initialized; WinUsb_AbortPipe_t AbortPipe; WinUsb_ControlTransfer_t ControlTransfer; WinUsb_FlushPipe_t FlushPipe; WinUsb_Free_t Free; WinUsb_GetAssociatedInterface_t GetAssociatedInterface; WinUsb_GetCurrentAlternateSetting_t GetCurrentAlternateSetting; WinUsb_GetDescriptor_t GetDescriptor; WinUsb_GetOverlappedResult_t GetOverlappedResult; WinUsb_GetPipePolicy_t GetPipePolicy; WinUsb_GetPowerPolicy_t GetPowerPolicy; WinUsb_Initialize_t Initialize; WinUsb_QueryDeviceInformation_t QueryDeviceInformation; WinUsb_QueryInterfaceSettings_t QueryInterfaceSettings; WinUsb_QueryPipe_t QueryPipe; WinUsb_ReadPipe_t ReadPipe; WinUsb_ResetPipe_t ResetPipe; WinUsb_SetCurrentAlternateSetting_t SetCurrentAlternateSetting; WinUsb_SetPipePolicy_t SetPipePolicy; WinUsb_SetPowerPolicy_t SetPowerPolicy; WinUsb_WritePipe_t WritePipe; WinUsb_ResetDevice_t ResetDevice; }; /* hid.dll interface */ #define HIDP_STATUS_SUCCESS 0x110000 typedef void * PHIDP_PREPARSED_DATA; #pragma pack(1) typedef struct { ULONG Size; USHORT VendorID; USHORT ProductID; USHORT VersionNumber; } HIDD_ATTRIBUTES, *PHIDD_ATTRIBUTES; #pragma pack() typedef USHORT USAGE; typedef struct { USAGE Usage; USAGE UsagePage; USHORT InputReportByteLength; USHORT OutputReportByteLength; USHORT FeatureReportByteLength; USHORT Reserved[17]; USHORT NumberLinkCollectionNodes; USHORT NumberInputButtonCaps; USHORT NumberInputValueCaps; USHORT NumberInputDataIndices; USHORT NumberOutputButtonCaps; USHORT NumberOutputValueCaps; USHORT NumberOutputDataIndices; USHORT NumberFeatureButtonCaps; USHORT NumberFeatureValueCaps; USHORT NumberFeatureDataIndices; } HIDP_CAPS, *PHIDP_CAPS; typedef enum _HIDP_REPORT_TYPE { HidP_Input, HidP_Output, HidP_Feature } HIDP_REPORT_TYPE; typedef struct _HIDP_VALUE_CAPS { USAGE UsagePage; UCHAR ReportID; BOOLEAN IsAlias; USHORT BitField; USHORT LinkCollection; USAGE LinkUsage; USAGE LinkUsagePage; BOOLEAN IsRange; BOOLEAN IsStringRange; BOOLEAN IsDesignatorRange; BOOLEAN IsAbsolute; BOOLEAN HasNull; UCHAR Reserved; USHORT BitSize; USHORT ReportCount; USHORT Reserved2[5]; ULONG UnitsExp; ULONG Units; LONG LogicalMin, LogicalMax; LONG PhysicalMin, PhysicalMax; union { struct { USAGE UsageMin, UsageMax; USHORT StringMin, StringMax; USHORT DesignatorMin, DesignatorMax; USHORT DataIndexMin, DataIndexMax; } Range; struct { USAGE Usage, Reserved1; USHORT StringIndex, Reserved2; USHORT DesignatorIndex, Reserved3; USHORT DataIndex, Reserved4; } NotRange; } u; } HIDP_VALUE_CAPS, *PHIDP_VALUE_CAPS; DLL_DECLARE_HANDLE(hid); DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetAttributes, (HANDLE, PHIDD_ATTRIBUTES)); DLL_DECLARE_FUNC(WINAPI, VOID, HidD_GetHidGuid, (LPGUID)); DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetPreparsedData, (HANDLE, PHIDP_PREPARSED_DATA *)); DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_FreePreparsedData, (PHIDP_PREPARSED_DATA)); DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetManufacturerString, (HANDLE, PVOID, ULONG)); DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetProductString, (HANDLE, PVOID, ULONG)); DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetSerialNumberString, (HANDLE, PVOID, ULONG)); DLL_DECLARE_FUNC(WINAPI, LONG, HidP_GetCaps, (PHIDP_PREPARSED_DATA, PHIDP_CAPS)); DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_SetNumInputBuffers, (HANDLE, ULONG)); DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_SetFeature, (HANDLE, PVOID, ULONG)); DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetFeature, (HANDLE, PVOID, ULONG)); DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetPhysicalDescriptor, (HANDLE, PVOID, ULONG)); DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetInputReport, (HANDLE, PVOID, ULONG)); DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_SetOutputReport, (HANDLE, PVOID, ULONG)); DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_FlushQueue, (HANDLE)); DLL_DECLARE_FUNC(WINAPI, BOOL, HidP_GetValueCaps, (HIDP_REPORT_TYPE, PHIDP_VALUE_CAPS, PULONG, PHIDP_PREPARSED_DATA));