app/src/main/jni/libusb-1.0.22/libusb/os/windows_winusb.h

   1 /*
   2  * Windows backend for libusb 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 #include "windows_nt_common.h"
  27
  28 #if defined(_MSC_VER)
  29 // disable /W4 MSVC warnings that are benign
  30 #pragma warning(disable:4100)  // unreferenced formal parameter
  31 #pragma warning(disable:4127)  // conditional expression is constant
  32 #pragma warning(disable:4201)  // nameless struct/union
  33 #pragma warning(disable:4214)  // bit field types other than int
  34 #pragma warning(disable:4996)  // deprecated API calls
  35 #pragma warning(disable:28159) // more deprecated API calls
  36 #endif
  37
  38 // Missing from MSVC6 setupapi.h
  39 #ifndef SPDRP_ADDRESS
  40 #define SPDRP_ADDRESS           28
  41 #endif
  42 #ifndef SPDRP_INSTALL_STATE
  43 #define SPDRP_INSTALL_STATE     34
  44 #endif
  45
  46 #define MAX_CTRL_BUFFER_LENGTH  4096
  47 #define MAX_USB_STRING_LENGTH   128
  48 #define MAX_HID_REPORT_SIZE     1024
  49 #define MAX_HID_DESCRIPTOR_SIZE 256
  50 #define MAX_GUID_STRING_LENGTH  40
  51 #define MAX_PATH_LENGTH         128
  52 #define MAX_KEY_LENGTH          256
  53 #define LIST_SEPARATOR          ';'
  54
  55 // Handle code for HID interface that have been claimed ("dibs")
  56 #define INTERFACE_CLAIMED       ((HANDLE)(intptr_t)0xD1B5)
  57 // Additional return code for HID operations that completed synchronously
  58 #define LIBUSB_COMPLETED        (LIBUSB_SUCCESS + 1)
  59
  60 // http://msdn.microsoft.com/en-us/library/ff545978.aspx
  61 // http://msdn.microsoft.com/en-us/library/ff545972.aspx
  62 // http://msdn.microsoft.com/en-us/library/ff545982.aspx
  63 #ifndef GUID_DEVINTERFACE_USB_HOST_CONTROLLER
  64 const GUID GUID_DEVINTERFACE_USB_HOST_CONTROLLER = {0x3ABF6F2D, 0x71C4, 0x462A, {0x8A, 0x92, 0x1E, 0x68, 0x61, 0xE6, 0xAF, 0x27}};
  65 #endif
  66 #ifndef GUID_DEVINTERFACE_USB_DEVICE
  67 const GUID GUID_DEVINTERFACE_USB_DEVICE = {0xA5DCBF10, 0x6530, 0x11D2, {0x90, 0x1F, 0x00, 0xC0, 0x4F, 0xB9, 0x51, 0xED}};
  68 #endif
  69 #ifndef GUID_DEVINTERFACE_USB_HUB
  70 const GUID GUID_DEVINTERFACE_USB_HUB = {0xF18A0E88, 0xC30C, 0x11D0, {0x88, 0x15, 0x00, 0xA0, 0xC9, 0x06, 0xBE, 0xD8}};
  71 #endif
  72 #ifndef GUID_DEVINTERFACE_LIBUSB0_FILTER
  73 const GUID GUID_DEVINTERFACE_LIBUSB0_FILTER = {0xF9F3FF14, 0xAE21, 0x48A0, {0x8A, 0x25, 0x80, 0x11, 0xA7, 0xA9, 0x31, 0xD9}};
  74 #endif
  75
  76
  77 /*
  78  * Multiple USB API backend support
  79  */
  80 #define USB_API_UNSUPPORTED     0
  81 #define USB_API_HUB             1
  82 #define USB_API_COMPOSITE       2
  83 #define USB_API_WINUSBX         3
  84 #define USB_API_HID             4
  85 #define USB_API_MAX             5
  86
  87 // Sub-APIs for WinUSB-like driver APIs (WinUSB, libusbK, libusb-win32 through the libusbK DLL)
  88 // Must have the same values as the KUSB_DRVID enum from libusbk.h
  89 #define SUB_API_NOTSET          -1
  90 #define SUB_API_LIBUSBK         0
  91 #define SUB_API_LIBUSB0         1
  92 #define SUB_API_WINUSB          2
  93 #define SUB_API_MAX             3
  94
  95 struct windows_usb_api_backend {
  96         const uint8_t id;
  97         const char * const designation;
  98         const char * const * const driver_name_list; // Driver name, without .sys, e.g. "usbccgp"
  99         const uint8_t nb_driver_names;
 100         int (*init)(struct libusb_context *ctx);
 101         void (*exit)(void);
 102         int (*open)(int sub_api, struct libusb_device_handle *dev_handle);
 103         void (*close)(int sub_api, struct libusb_device_handle *dev_handle);
 104         int (*configure_endpoints)(int sub_api, struct libusb_device_handle *dev_handle, int iface);
 105         int (*claim_interface)(int sub_api, struct libusb_device_handle *dev_handle, int iface);
 106         int (*set_interface_altsetting)(int sub_api, struct libusb_device_handle *dev_handle, int iface, int altsetting);
 107         int (*release_interface)(int sub_api, struct libusb_device_handle *dev_handle, int iface);
 108         int (*clear_halt)(int sub_api, struct libusb_device_handle *dev_handle, unsigned char endpoint);
 109         int (*reset_device)(int sub_api, struct libusb_device_handle *dev_handle);
 110         int (*submit_bulk_transfer)(int sub_api, struct usbi_transfer *itransfer);
 111         int (*submit_iso_transfer)(int sub_api, struct usbi_transfer *itransfer);
 112         int (*submit_control_transfer)(int sub_api, struct usbi_transfer *itransfer);
 113         int (*abort_control)(int sub_api, struct usbi_transfer *itransfer);
 114         int (*abort_transfers)(int sub_api, struct usbi_transfer *itransfer);
 115         int (*copy_transfer_data)(int sub_api, struct usbi_transfer *itransfer, uint32_t io_size);
 116 };
 117
 118 extern const struct windows_usb_api_backend usb_api_backend[USB_API_MAX];
 119
 120 #define PRINT_UNSUPPORTED_API(fname)                            \
 121         usbi_dbg("unsupported API call for '%s' "               \
 122                 "(unrecognized device driver)", #fname)
 123
 124 #define CHECK_SUPPORTED_API(apip, fname)                        \
 125         do {                                                    \
 126                 if ((apip)->fname == NULL) {                    \
 127                         PRINT_UNSUPPORTED_API(fname);           \
 128                         return LIBUSB_ERROR_NOT_SUPPORTED;      \
 129                 }                                               \
 130         } while (0)
 131
 132 /*
 133  * private structures definition
 134  * with inline pseudo constructors/destructors
 135  */
 136
 137 // TODO (v2+): move hid desc to libusb.h?
 138 struct libusb_hid_descriptor {
 139         uint8_t bLength;
 140         uint8_t bDescriptorType;
 141         uint16_t bcdHID;
 142         uint8_t bCountryCode;
 143         uint8_t bNumDescriptors;
 144         uint8_t bClassDescriptorType;
 145         uint16_t wClassDescriptorLength;
 146 };
 147
 148 #define LIBUSB_DT_HID_SIZE              9
 149 #define HID_MAX_CONFIG_DESC_SIZE (LIBUSB_DT_CONFIG_SIZE + LIBUSB_DT_INTERFACE_SIZE \
 150         + LIBUSB_DT_HID_SIZE + 2 * LIBUSB_DT_ENDPOINT_SIZE)
 151 #define HID_MAX_REPORT_SIZE             1024
 152 #define HID_IN_EP                       0x81
 153 #define HID_OUT_EP                      0x02
 154 #define LIBUSB_REQ_RECIPIENT(request_type)      ((request_type) & 0x1F)
 155 #define LIBUSB_REQ_TYPE(request_type)           ((request_type) & (0x03 << 5))
 156 #define LIBUSB_REQ_IN(request_type)             ((request_type) & LIBUSB_ENDPOINT_IN)
 157 #define LIBUSB_REQ_OUT(request_type)            (!LIBUSB_REQ_IN(request_type))
 158
 159 #ifndef CTL_CODE
 160 #define CTL_CODE(DeviceType, Function, Method, Access) \
 161         (((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method))
 162 #endif
 163
 164 // The following are used for HID reports IOCTLs
 165 #define HID_IN_CTL_CODE(id) \
 166         CTL_CODE(FILE_DEVICE_KEYBOARD, (id), METHOD_IN_DIRECT, FILE_ANY_ACCESS)
 167 #define HID_OUT_CTL_CODE(id) \
 168         CTL_CODE(FILE_DEVICE_KEYBOARD, (id), METHOD_OUT_DIRECT, FILE_ANY_ACCESS)
 169
 170 #define IOCTL_HID_GET_FEATURE           HID_OUT_CTL_CODE(100)
 171 #define IOCTL_HID_GET_INPUT_REPORT      HID_OUT_CTL_CODE(104)
 172 #define IOCTL_HID_SET_FEATURE           HID_IN_CTL_CODE(100)
 173 #define IOCTL_HID_SET_OUTPUT_REPORT     HID_IN_CTL_CODE(101)
 174
 175 enum libusb_hid_request_type {
 176         HID_REQ_GET_REPORT = 0x01,
 177         HID_REQ_GET_IDLE = 0x02,
 178         HID_REQ_GET_PROTOCOL = 0x03,
 179         HID_REQ_SET_REPORT = 0x09,
 180         HID_REQ_SET_IDLE = 0x0A,
 181         HID_REQ_SET_PROTOCOL = 0x0B
 182 };
 183
 184 enum libusb_hid_report_type {
 185         HID_REPORT_TYPE_INPUT = 0x01,
 186         HID_REPORT_TYPE_OUTPUT = 0x02,
 187         HID_REPORT_TYPE_FEATURE = 0x03
 188 };
 189
 190 struct hid_device_priv {
 191         uint16_t vid;
 192         uint16_t pid;
 193         uint8_t config;
 194         uint8_t nb_interfaces;
 195         bool uses_report_ids[3]; // input, ouptput, feature
 196         uint16_t input_report_size;
 197         uint16_t output_report_size;
 198         uint16_t feature_report_size;
 199         uint16_t usage;
 200         uint16_t usagePage;
 201         WCHAR string[3][MAX_USB_STRING_LENGTH];
 202         uint8_t string_index[3]; // man, prod, ser
 203 };
 204
 205 static inline struct winusb_device_priv *_device_priv(struct libusb_device *dev)
 206 {
 207         return (struct winusb_device_priv *)dev->os_priv;
 208 }
 209
 210 static inline struct winusb_device_priv *winusb_device_priv_init(struct libusb_device *dev)
 211 {
 212         struct winusb_device_priv *p = _device_priv(dev);
 213         int i;
 214
 215         p->apib = &usb_api_backend[USB_API_UNSUPPORTED];
 216         p->sub_api = SUB_API_NOTSET;
 217         for (i = 0; i < USB_MAXINTERFACES; i++) {
 218                 p->usb_interface[i].apib = &usb_api_backend[USB_API_UNSUPPORTED];
 219                 p->usb_interface[i].sub_api = SUB_API_NOTSET;
 220         }
 221
 222         return p;
 223 }
 224
 225 static inline void winusb_device_priv_release(struct libusb_device *dev)
 226 {
 227         struct winusb_device_priv *p = _device_priv(dev);
 228         int i;
 229
 230         free(p->dev_id);
 231         free(p->path);
 232         if ((dev->num_configurations > 0) && (p->config_descriptor != NULL)) {
 233                 for (i = 0; i < dev->num_configurations; i++)
 234                         free(p->config_descriptor[i]);
 235         }
 236         free(p->config_descriptor);
 237         free(p->hid);
 238         for (i = 0; i < USB_MAXINTERFACES; i++) {
 239                 free(p->usb_interface[i].path);
 240                 free(p->usb_interface[i].endpoint);
 241         }
 242 }
 243
 244 static inline struct winusb_device_handle_priv *_device_handle_priv(
 245         struct libusb_device_handle *handle)
 246 {
 247         return (struct winusb_device_handle_priv *)handle->os_priv;
 248 }
 249
 250 // used to match a device driver (including filter drivers) against a supported API
 251 struct driver_lookup {
 252         char list[MAX_KEY_LENGTH + 1]; // REG_MULTI_SZ list of services (driver) names
 253         const DWORD reg_prop;          // SPDRP registry key to use to retrieve list
 254         const char* designation;       // internal designation (for debug output)
 255 };
 256
 257 /*
 258  * Windows DDK API definitions. Most of it copied from MinGW's includes
 259  */
 260 typedef DWORD DEVNODE, DEVINST;
 261 typedef DEVNODE *PDEVNODE, *PDEVINST;
 262 typedef DWORD RETURN_TYPE;
 263 typedef RETURN_TYPE CONFIGRET;
 264
 265 #define CR_SUCCESS      0x00000000
 266
 267 /* Cfgmgr32 dependencies */
 268 DLL_DECLARE_HANDLE(Cfgmgr32);
 269 DLL_DECLARE_FUNC(WINAPI, CONFIGRET, CM_Get_Parent, (PDEVINST, DEVINST, ULONG));
 270 DLL_DECLARE_FUNC(WINAPI, CONFIGRET, CM_Get_Child, (PDEVINST, DEVINST, ULONG));
 271
 272 /* AdvAPI32 dependencies */
 273 DLL_DECLARE_HANDLE(AdvAPI32);
 274 DLL_DECLARE_FUNC_PREFIXED(WINAPI, LONG, p, RegQueryValueExW, (HKEY, LPCWSTR, LPDWORD, LPDWORD, LPBYTE, LPDWORD));
 275 DLL_DECLARE_FUNC_PREFIXED(WINAPI, LONG, p, RegCloseKey, (HKEY));
 276
 277 /* OLE32 dependency */
 278 DLL_DECLARE_HANDLE(OLE32);
 279 DLL_DECLARE_FUNC_PREFIXED(WINAPI, HRESULT, p, IIDFromString, (LPCOLESTR, LPIID));
 280
 281 /* SetupAPI dependencies */
 282 DLL_DECLARE_HANDLE(SetupAPI);
 283 DLL_DECLARE_FUNC_PREFIXED(WINAPI, HDEVINFO, p, SetupDiGetClassDevsA, (LPCGUID, PCSTR, HWND, DWORD));
 284 DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiEnumDeviceInfo, (HDEVINFO, DWORD, PSP_DEVINFO_DATA));
 285 DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiEnumDeviceInterfaces, (HDEVINFO, PSP_DEVINFO_DATA,
 286                         LPCGUID, DWORD, PSP_DEVICE_INTERFACE_DATA));
 287 DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiGetDeviceInstanceIdA, (HDEVINFO, PSP_DEVINFO_DATA,
 288                         PCSTR, DWORD, PDWORD));
 289 DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiGetDeviceInterfaceDetailA, (HDEVINFO, PSP_DEVICE_INTERFACE_DATA,
 290                         PSP_DEVICE_INTERFACE_DETAIL_DATA_A, DWORD, PDWORD, PSP_DEVINFO_DATA));
 291 DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiGetDeviceRegistryPropertyA, (HDEVINFO,
 292                         PSP_DEVINFO_DATA, DWORD, PDWORD, PBYTE, DWORD, PDWORD));
 293 DLL_DECLARE_FUNC_PREFIXED(WINAPI, BOOL, p, SetupDiDestroyDeviceInfoList, (HDEVINFO));
 294 DLL_DECLARE_FUNC_PREFIXED(WINAPI, HKEY, p, SetupDiOpenDevRegKey, (HDEVINFO, PSP_DEVINFO_DATA, DWORD, DWORD, DWORD, REGSAM));
 295 DLL_DECLARE_FUNC_PREFIXED(WINAPI, HKEY, p, SetupDiOpenDeviceInterfaceRegKey, (HDEVINFO, PSP_DEVICE_INTERFACE_DATA, DWORD, DWORD));
 296
 297
 298 #ifndef USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION
 299 #define USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION         260
 300 #endif
 301 #ifndef USB_GET_NODE_CONNECTION_INFORMATION_EX
 302 #define USB_GET_NODE_CONNECTION_INFORMATION_EX          274
 303 #endif
 304 #ifndef USB_GET_NODE_CONNECTION_INFORMATION_EX_V2
 305 #define USB_GET_NODE_CONNECTION_INFORMATION_EX_V2       279
 306 #endif
 307
 308 #ifndef FILE_DEVICE_USB
 309 #define FILE_DEVICE_USB         FILE_DEVICE_UNKNOWN
 310 #endif
 311
 312 #define USB_CTL_CODE(id) \
 313         CTL_CODE(FILE_DEVICE_USB, (id), METHOD_BUFFERED, FILE_ANY_ACCESS)
 314
 315 #define IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION \
 316         USB_CTL_CODE(USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION)
 317
 318 #define IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX \
 319         USB_CTL_CODE(USB_GET_NODE_CONNECTION_INFORMATION_EX)
 320
 321 #define IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX_V2 \
 322         USB_CTL_CODE(USB_GET_NODE_CONNECTION_INFORMATION_EX_V2)
 323
 324 typedef enum USB_CONNECTION_STATUS {
 325         NoDeviceConnected,
 326         DeviceConnected,
 327         DeviceFailedEnumeration,
 328         DeviceGeneralFailure,
 329         DeviceCausedOvercurrent,
 330         DeviceNotEnoughPower,
 331         DeviceNotEnoughBandwidth,
 332         DeviceHubNestedTooDeeply,
 333         DeviceInLegacyHub
 334 } USB_CONNECTION_STATUS, *PUSB_CONNECTION_STATUS;
 335
 336 typedef enum USB_HUB_NODE {
 337         UsbHub,
 338         UsbMIParent
 339 } USB_HUB_NODE;
 340
 341 // Most of the structures below need to be packed
 342 #include <pshpack1.h>
 343
 344 typedef struct _USB_DESCRIPTOR_REQUEST {
 345         ULONG ConnectionIndex;
 346         struct {
 347                 UCHAR bmRequest;
 348                 UCHAR bRequest;
 349                 USHORT wValue;
 350                 USHORT wIndex;
 351                 USHORT wLength;
 352         } SetupPacket;
 353 //      UCHAR Data[0];
 354 } USB_DESCRIPTOR_REQUEST, *PUSB_DESCRIPTOR_REQUEST;
 355
 356 typedef struct _USB_CONFIGURATION_DESCRIPTOR_SHORT {
 357         USB_DESCRIPTOR_REQUEST req;
 358         USB_CONFIGURATION_DESCRIPTOR desc;
 359 } USB_CONFIGURATION_DESCRIPTOR_SHORT;
 360
 361 typedef struct USB_INTERFACE_DESCRIPTOR {
 362         UCHAR bLength;
 363         UCHAR bDescriptorType;
 364         UCHAR bInterfaceNumber;
 365         UCHAR bAlternateSetting;
 366         UCHAR bNumEndpoints;
 367         UCHAR bInterfaceClass;
 368         UCHAR bInterfaceSubClass;
 369         UCHAR bInterfaceProtocol;
 370         UCHAR iInterface;
 371 } USB_INTERFACE_DESCRIPTOR, *PUSB_INTERFACE_DESCRIPTOR;
 372
 373 typedef struct _USB_NODE_CONNECTION_INFORMATION_EX {
 374         ULONG ConnectionIndex;
 375         USB_DEVICE_DESCRIPTOR DeviceDescriptor;
 376         UCHAR CurrentConfigurationValue;
 377         UCHAR Speed;
 378         BOOLEAN DeviceIsHub;
 379         USHORT DeviceAddress;
 380         ULONG NumberOfOpenPipes;
 381         USB_CONNECTION_STATUS ConnectionStatus;
 382 //      USB_PIPE_INFO PipeList[0];
 383 } USB_NODE_CONNECTION_INFORMATION_EX, *PUSB_NODE_CONNECTION_INFORMATION_EX;
 384
 385 typedef union _USB_PROTOCOLS {
 386         ULONG ul;
 387         struct {
 388                 ULONG Usb110:1;
 389                 ULONG Usb200:1;
 390                 ULONG Usb300:1;
 391                 ULONG ReservedMBZ:29;
 392         };
 393 } USB_PROTOCOLS, *PUSB_PROTOCOLS;
 394
 395 typedef union _USB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGS {
 396         ULONG ul;
 397         struct {
 398                 ULONG DeviceIsOperatingAtSuperSpeedOrHigher:1;
 399                 ULONG DeviceIsSuperSpeedCapableOrHigher:1;
 400                 ULONG ReservedMBZ:30;
 401         };
 402 } USB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGS, *PUSB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGS;
 403
 404 typedef struct _USB_NODE_CONNECTION_INFORMATION_EX_V2 {
 405         ULONG ConnectionIndex;
 406         ULONG Length;
 407         USB_PROTOCOLS SupportedUsbProtocols;
 408         USB_NODE_CONNECTION_INFORMATION_EX_V2_FLAGS Flags;
 409 } USB_NODE_CONNECTION_INFORMATION_EX_V2, *PUSB_NODE_CONNECTION_INFORMATION_EX_V2;
 410
 411 #include <poppack.h>
 412
 413 /* winusb.dll interface */
 414
 415 #define SHORT_PACKET_TERMINATE  0x01
 416 #define AUTO_CLEAR_STALL        0x02
 417 #define PIPE_TRANSFER_TIMEOUT   0x03
 418 #define IGNORE_SHORT_PACKETS    0x04
 419 #define ALLOW_PARTIAL_READS     0x05
 420 #define AUTO_FLUSH              0x06
 421 #define RAW_IO                  0x07
 422 #define MAXIMUM_TRANSFER_SIZE   0x08
 423
 424 typedef enum _USBD_PIPE_TYPE {
 425         UsbdPipeTypeControl,
 426         UsbdPipeTypeIsochronous,
 427         UsbdPipeTypeBulk,
 428         UsbdPipeTypeInterrupt
 429 } USBD_PIPE_TYPE;
 430
 431 #include <pshpack1.h>
 432
 433 typedef struct _WINUSB_SETUP_PACKET {
 434         UCHAR RequestType;
 435         UCHAR Request;
 436         USHORT Value;
 437         USHORT Index;
 438         USHORT Length;
 439 } WINUSB_SETUP_PACKET, *PWINUSB_SETUP_PACKET;
 440
 441 #include <poppack.h>
 442
 443 typedef void *WINUSB_INTERFACE_HANDLE, *PWINUSB_INTERFACE_HANDLE;
 444
 445 typedef BOOL (WINAPI *WinUsb_AbortPipe_t)(
 446         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 447         UCHAR PipeID
 448 );
 449 typedef BOOL (WINAPI *WinUsb_ControlTransfer_t)(
 450         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 451         WINUSB_SETUP_PACKET SetupPacket,
 452         PUCHAR Buffer,
 453         ULONG BufferLength,
 454         PULONG LengthTransferred,
 455         LPOVERLAPPED Overlapped
 456 );
 457 typedef BOOL (WINAPI *WinUsb_FlushPipe_t)(
 458         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 459         UCHAR PipeID
 460 );
 461 typedef BOOL (WINAPI *WinUsb_Free_t)(
 462         WINUSB_INTERFACE_HANDLE InterfaceHandle
 463 );
 464 typedef BOOL (WINAPI *WinUsb_GetAssociatedInterface_t)(
 465         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 466         UCHAR AssociatedInterfaceIndex,
 467         PWINUSB_INTERFACE_HANDLE AssociatedInterfaceHandle
 468 );
 469 typedef BOOL (WINAPI *WinUsb_Initialize_t)(
 470         HANDLE DeviceHandle,
 471         PWINUSB_INTERFACE_HANDLE InterfaceHandle
 472 );
 473 typedef BOOL (WINAPI *WinUsb_ReadPipe_t)(
 474         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 475         UCHAR PipeID,
 476         PUCHAR Buffer,
 477         ULONG BufferLength,
 478         PULONG LengthTransferred,
 479         LPOVERLAPPED Overlapped
 480 );
 481 typedef BOOL (WINAPI *WinUsb_ResetDevice_t)(
 482         WINUSB_INTERFACE_HANDLE InterfaceHandle
 483 );
 484 typedef BOOL (WINAPI *WinUsb_ResetPipe_t)(
 485         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 486         UCHAR PipeID
 487 );
 488 typedef BOOL (WINAPI *WinUsb_SetCurrentAlternateSetting_t)(
 489         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 490         UCHAR AlternateSetting
 491 );
 492 typedef BOOL (WINAPI *WinUsb_SetPipePolicy_t)(
 493         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 494         UCHAR PipeID,
 495         ULONG PolicyType,
 496         ULONG ValueLength,
 497         PVOID Value
 498 );
 499 typedef BOOL (WINAPI *WinUsb_WritePipe_t)(
 500         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 501         UCHAR PipeID,
 502         PUCHAR Buffer,
 503         ULONG BufferLength,
 504         PULONG LengthTransferred,
 505         LPOVERLAPPED Overlapped
 506 );
 507
 508 /* /!\ These must match the ones from the official libusbk.h */
 509 typedef enum _KUSB_FNID {
 510         KUSB_FNID_Init,
 511         KUSB_FNID_Free,
 512         KUSB_FNID_ClaimInterface,
 513         KUSB_FNID_ReleaseInterface,
 514         KUSB_FNID_SetAltInterface,
 515         KUSB_FNID_GetAltInterface,
 516         KUSB_FNID_GetDescriptor,
 517         KUSB_FNID_ControlTransfer,
 518         KUSB_FNID_SetPowerPolicy,
 519         KUSB_FNID_GetPowerPolicy,
 520         KUSB_FNID_SetConfiguration,
 521         KUSB_FNID_GetConfiguration,
 522         KUSB_FNID_ResetDevice,
 523         KUSB_FNID_Initialize,
 524         KUSB_FNID_SelectInterface,
 525         KUSB_FNID_GetAssociatedInterface,
 526         KUSB_FNID_Clone,
 527         KUSB_FNID_QueryInterfaceSettings,
 528         KUSB_FNID_QueryDeviceInformation,
 529         KUSB_FNID_SetCurrentAlternateSetting,
 530         KUSB_FNID_GetCurrentAlternateSetting,
 531         KUSB_FNID_QueryPipe,
 532         KUSB_FNID_SetPipePolicy,
 533         KUSB_FNID_GetPipePolicy,
 534         KUSB_FNID_ReadPipe,
 535         KUSB_FNID_WritePipe,
 536         KUSB_FNID_ResetPipe,
 537         KUSB_FNID_AbortPipe,
 538         KUSB_FNID_FlushPipe,
 539         KUSB_FNID_IsoReadPipe,
 540         KUSB_FNID_IsoWritePipe,
 541         KUSB_FNID_GetCurrentFrameNumber,
 542         KUSB_FNID_GetOverlappedResult,
 543         KUSB_FNID_GetProperty,
 544         KUSB_FNID_COUNT,
 545 } KUSB_FNID;
 546
 547 typedef struct _KLIB_VERSION {
 548         INT Major;
 549         INT Minor;
 550         INT Micro;
 551         INT Nano;
 552 } KLIB_VERSION, *PKLIB_VERSION;
 553
 554 typedef BOOL (WINAPI *LibK_GetProcAddress_t)(
 555         PVOID *ProcAddress,
 556         ULONG DriverID,
 557         ULONG FunctionID
 558 );
 559
 560 typedef VOID (WINAPI *LibK_GetVersion_t)(
 561         PKLIB_VERSION Version
 562 );
 563
 564 //KISO_PACKET is equivalent of libusb_iso_packet_descriptor except uses absolute "offset" field instead of sequential Lengths
 565 typedef struct _KISO_PACKET {
 566         UINT offset;
 567         USHORT actual_length; //changed from libusbk_shared.h "Length" for clarity
 568         USHORT status;
 569 } KISO_PACKET, *PKISO_PACKET;
 570
 571 typedef enum _KISO_FLAG {
 572         KISO_FLAG_NONE = 0,
 573         KISO_FLAG_SET_START_FRAME = 0x00000001,
 574 } KISO_FLAG;
 575
 576 //KISO_CONTEXT is the conceptual equivalent of libusb_transfer except is isochronous-specific and must match libusbk's version
 577 typedef struct _KISO_CONTEXT {
 578         KISO_FLAG Flags;
 579         UINT StartFrame;
 580         SHORT ErrorCount;
 581         SHORT NumberOfPackets;
 582         UINT UrbHdrStatus;
 583         KISO_PACKET IsoPackets[0];
 584 } KISO_CONTEXT, *PKISO_CONTEXT;
 585
 586 typedef BOOL(WINAPI *WinUsb_IsoReadPipe_t)(
 587         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 588         UCHAR PipeID,
 589         PUCHAR Buffer,
 590         ULONG BufferLength,
 591         LPOVERLAPPED Overlapped,
 592         PKISO_CONTEXT IsoContext
 593 );
 594
 595 typedef BOOL(WINAPI *WinUsb_IsoWritePipe_t)(
 596         WINUSB_INTERFACE_HANDLE InterfaceHandle,
 597         UCHAR PipeID,
 598         PUCHAR Buffer,
 599         ULONG BufferLength,
 600         LPOVERLAPPED Overlapped,
 601         PKISO_CONTEXT IsoContext
 602 );
 603
 604 struct winusb_interface {
 605         bool initialized;
 606         bool CancelIoEx_supported;
 607         WinUsb_AbortPipe_t AbortPipe;
 608         WinUsb_ControlTransfer_t ControlTransfer;
 609         WinUsb_FlushPipe_t FlushPipe;
 610         WinUsb_Free_t Free;
 611         WinUsb_GetAssociatedInterface_t GetAssociatedInterface;
 612         WinUsb_Initialize_t Initialize;
 613         WinUsb_ReadPipe_t ReadPipe;
 614         WinUsb_ResetDevice_t ResetDevice;
 615         WinUsb_ResetPipe_t ResetPipe;
 616         WinUsb_SetCurrentAlternateSetting_t SetCurrentAlternateSetting;
 617         WinUsb_SetPipePolicy_t SetPipePolicy;
 618         WinUsb_WritePipe_t WritePipe;
 619         WinUsb_IsoReadPipe_t IsoReadPipe;
 620         WinUsb_IsoWritePipe_t IsoWritePipe;
 621 };
 622
 623 /* hid.dll interface */
 624
 625 #define HIDP_STATUS_SUCCESS     0x110000
 626 typedef void * PHIDP_PREPARSED_DATA;
 627
 628 #include <pshpack1.h>
 629
 630 typedef struct _HIDD_ATTIRBUTES {
 631         ULONG Size;
 632         USHORT VendorID;
 633         USHORT ProductID;
 634         USHORT VersionNumber;
 635 } HIDD_ATTRIBUTES, *PHIDD_ATTRIBUTES;
 636
 637 #include <poppack.h>
 638
 639 typedef USHORT USAGE;
 640 typedef struct _HIDP_CAPS {
 641         USAGE Usage;
 642         USAGE UsagePage;
 643         USHORT InputReportByteLength;
 644         USHORT OutputReportByteLength;
 645         USHORT FeatureReportByteLength;
 646         USHORT Reserved[17];
 647         USHORT NumberLinkCollectionNodes;
 648         USHORT NumberInputButtonCaps;
 649         USHORT NumberInputValueCaps;
 650         USHORT NumberInputDataIndices;
 651         USHORT NumberOutputButtonCaps;
 652         USHORT NumberOutputValueCaps;
 653         USHORT NumberOutputDataIndices;
 654         USHORT NumberFeatureButtonCaps;
 655         USHORT NumberFeatureValueCaps;
 656         USHORT NumberFeatureDataIndices;
 657 } HIDP_CAPS, *PHIDP_CAPS;
 658
 659 typedef enum _HIDP_REPORT_TYPE {
 660         HidP_Input,
 661         HidP_Output,
 662         HidP_Feature
 663 } HIDP_REPORT_TYPE;
 664
 665 typedef struct _HIDP_VALUE_CAPS {
 666         USAGE UsagePage;
 667         UCHAR ReportID;
 668         BOOLEAN IsAlias;
 669         USHORT BitField;
 670         USHORT LinkCollection;
 671         USAGE LinkUsage;
 672         USAGE LinkUsagePage;
 673         BOOLEAN IsRange;
 674         BOOLEAN IsStringRange;
 675         BOOLEAN IsDesignatorRange;
 676         BOOLEAN IsAbsolute;
 677         BOOLEAN HasNull;
 678         UCHAR Reserved;
 679         USHORT BitSize;
 680         USHORT ReportCount;
 681         USHORT Reserved2[5];
 682         ULONG UnitsExp;
 683         ULONG Units;
 684         LONG LogicalMin, LogicalMax;
 685         LONG PhysicalMin, PhysicalMax;
 686         union {
 687                 struct {
 688                         USAGE UsageMin, UsageMax;
 689                         USHORT StringMin, StringMax;
 690                         USHORT DesignatorMin, DesignatorMax;
 691                         USHORT DataIndexMin, DataIndexMax;
 692                 } Range;
 693                 struct {
 694                         USAGE Usage, Reserved1;
 695                         USHORT StringIndex, Reserved2;
 696                         USHORT DesignatorIndex, Reserved3;
 697                         USHORT DataIndex, Reserved4;
 698                 } NotRange;
 699         } u;
 700 } HIDP_VALUE_CAPS, *PHIDP_VALUE_CAPS;
 701
 702 DLL_DECLARE_HANDLE(hid);
 703 DLL_DECLARE_FUNC(WINAPI, VOID, HidD_GetHidGuid, (LPGUID));
 704 DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetAttributes, (HANDLE, PHIDD_ATTRIBUTES));
 705 DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetPreparsedData, (HANDLE, PHIDP_PREPARSED_DATA *));
 706 DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_FreePreparsedData, (PHIDP_PREPARSED_DATA));
 707 DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetManufacturerString, (HANDLE, PVOID, ULONG));
 708 DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetProductString, (HANDLE, PVOID, ULONG));
 709 DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetSerialNumberString, (HANDLE, PVOID, ULONG));
 710 DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetIndexedString, (HANDLE, ULONG, PVOID, ULONG));
 711 DLL_DECLARE_FUNC(WINAPI, LONG, HidP_GetCaps, (PHIDP_PREPARSED_DATA, PHIDP_CAPS));
 712 DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_SetNumInputBuffers, (HANDLE, ULONG));
 713 DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_GetPhysicalDescriptor, (HANDLE, PVOID, ULONG));
 714 DLL_DECLARE_FUNC(WINAPI, BOOL, HidD_FlushQueue, (HANDLE));
 715 DLL_DECLARE_FUNC(WINAPI, BOOL, HidP_GetValueCaps, (HIDP_REPORT_TYPE, PHIDP_VALUE_CAPS, PULONG, PHIDP_PREPARSED_DATA));