windrvr_usb.h

Go to the documentation of this file.

/* @JUNGO_COPYRIGHT@ */
 
/* @JUNGO_COPYRIGHT_GPL@ */
 
/* @JUNGO_COPYRIGHT_GPL_OTHER_OS@ */
 
#if !defined(_WINDRVR_USB_H_)
#define _WINDRVR_USB_H_
 
/* Use it to pad struct size to 64 bit, when using 32 on 64 bit application */
#ifndef PAD_TO_64
#if defined (i386) && defined(x86_64)
#define PAD_TO_64(pName) DWORD dwPad_##pName;
#else
#define PAD_TO_64(pName)
#endif
#endif
 
#if defined (i386) && defined(x86_64)
#define PAD_TO_64_PTR_ARR(pName,size) PVOID ptPad_##pName[size];
#else
#define PAD_TO_64_PTR_ARR(pName, size)
#endif
 
#if defined(LINUX)
    #if !defined(__P_TYPES__)
        #define __P_TYPES__
        #include <wd_types.h>
        typedef void VOID;
        typedef unsigned char UCHAR;
        typedef unsigned short USHORT;
        typedef unsigned int UINT;
        typedef unsigned long ULONG;
        typedef u32 BOOL;
        typedef void *PVOID;
        typedef unsigned char *PBYTE;
        typedef char CHAR;
        typedef char *PCHAR;
        typedef unsigned short *PWORD;
        typedef u32 DWORD, *PDWORD;
        typedef int PRCHANDLE;
        typedef PVOID HANDLE;
        typedef long LONG;
    #endif
    #if !defined(TRUE)
        #define TRUE 1
    #endif
    #if !defined(FALSE)
        #define FALSE 0
    #endif
#endif
 
typedef enum {
    PIPE_TYPE_CONTROL     = 0,
    PIPE_TYPE_ISOCHRONOUS = 1,
    PIPE_TYPE_BULK        = 2,
    PIPE_TYPE_INTERRUPT   = 3
} USB_PIPE_TYPE;
 
#define WD_USB_MAX_PIPE_NUMBER 32
#define WD_USB_MAX_ENDPOINTS WD_USB_MAX_PIPE_NUMBER
#define WD_USB_MAX_INTERFACES 30
#define WD_USB_MAX_ALT_SETTINGS 255
 
typedef enum {
    WDU_DIR_IN     = 1,
    WDU_DIR_OUT    = 2,
    WDU_DIR_IN_OUT = 3
} WDU_DIR;
 
/* USB TRANSFER options */
enum {
    USB_ISOCH_RESET = 0x10,
    USB_ISOCH_FULL_PACKETS_ONLY = 0x20,
    /* Windows only, ignored on other OS: */
    USB_ABORT_PIPE = 0x40,
    USB_ISOCH_NOASAP = 0x80,
    USB_BULK_INT_URB_SIZE_OVERRIDE_128K = 0x100, /* Force a 128KB maximum
                                                    URB size */
    /* All OS */
    USB_STREAM_OVERWRITE_BUFFER_WHEN_FULL = 0x200,
 
    /* The following flags are no longer used beginning with v6.0: */
    USB_TRANSFER_HALT = 0x1,
    USB_SHORT_TRANSFER = 0x2,
    USB_FULL_TRANSFER = 0x4,
    USB_ISOCH_ASAP = 0x8
};
 
typedef PVOID WDU_REGISTER_DEVICES_HANDLE;
 
/* Descriptor types */
#define WDU_DEVICE_DESC_TYPE       0x01
#define WDU_CONFIG_DESC_TYPE       0x02
#define WDU_STRING_DESC_STRING     0x03
#define WDU_INTERFACE_DESC_TYPE    0x04
#define WDU_ENDPOINT_DESC_TYPE     0x05
 
/* Endpoint descriptor fields */
#define WDU_ENDPOINT_TYPE_MASK 0x03
#define WDU_ENDPOINT_DIRECTION_MASK 0x80
#define WDU_ENDPOINT_ADDRESS_MASK 0x0f
/* test direction bit in the bEndpointAddress field of an endpoint
 * descriptor. */
#define WDU_ENDPOINT_DIRECTION_OUT(addr) \
    (!((addr) & WDU_ENDPOINT_DIRECTION_MASK))
#define WDU_ENDPOINT_DIRECTION_IN(addr) \
    ((addr) & WDU_ENDPOINT_DIRECTION_MASK)
#define WDU_GET_MAX_PACKET_SIZE(x) \
    ((USHORT) (((x) & 0x7ff) * (1 + (((x) & 0x1800) >> 11))))
 
#ifndef LINUX
typedef enum {
    USB_DIR_IN     = 1,
    USB_DIR_OUT    = 2,
    USB_DIR_IN_OUT = 3
} USB_DIR;
#endif
 
typedef struct
{
    DWORD dwNumber; 
    DWORD dwMaximumPacketSize; 
    DWORD type;            
    DWORD direction;       
    DWORD dwInterval;      
} WDU_PIPE_INFO;
 
typedef struct
{
    UCHAR bLength; 
    UCHAR bDescriptorType; 
    UCHAR bInterfaceNumber; 
    UCHAR bAlternateSetting; 
    UCHAR bNumEndpoints; 
    UCHAR bInterfaceClass; 
    UCHAR bInterfaceSubClass; 
    UCHAR bInterfaceProtocol; 
    UCHAR iInterface; 
} WDU_INTERFACE_DESCRIPTOR;
 
typedef struct
{
    UCHAR bLength; 
    UCHAR bDescriptorType; 
    UCHAR bEndpointAddress; 
    UCHAR bmAttributes; 
    USHORT wMaxPacketSize; 
    UCHAR bInterval; 
} WDU_ENDPOINT_DESCRIPTOR;
 
typedef struct
{
    UCHAR bLength; 
    UCHAR bDescriptorType; 
    USHORT wTotalLength; 
    UCHAR bNumInterfaces; 
    UCHAR bConfigurationValue; 
    UCHAR iConfiguration; 
    UCHAR bmAttributes; 
    UCHAR MaxPower; 
} WDU_CONFIGURATION_DESCRIPTOR;
 
typedef struct
{
    UCHAR bLength; 
    UCHAR bDescriptorType; 
    USHORT bcdUSB; 
    UCHAR bDeviceClass; 
    UCHAR bDeviceSubClass; 
    UCHAR bDeviceProtocol; 
    UCHAR bMaxPacketSize0; 
    USHORT idVendor; 
    USHORT idProduct; 
    USHORT bcdDevice; 
    UCHAR iManufacturer; 
    UCHAR iProduct; 
    UCHAR iSerialNumber; 
    UCHAR bNumConfigurations; 
} WDU_DEVICE_DESCRIPTOR;
 
typedef struct
{
    WDU_INTERFACE_DESCRIPTOR Descriptor; 
    PAD_TO_64(Descriptor)
    WDU_ENDPOINT_DESCRIPTOR *pEndpointDescriptors; 
    PAD_TO_64(pEndpointDescriptors)
    WDU_PIPE_INFO *pPipes; 
    PAD_TO_64(pPipes)
} WDU_ALTERNATE_SETTING;
 
typedef struct
{
    WDU_ALTERNATE_SETTING *pAlternateSettings; 
    PAD_TO_64(pAlternateSettings)
    DWORD dwNumAltSettings; 
    PAD_TO_64(dwNumAltSettings)
    WDU_ALTERNATE_SETTING *pActiveAltSetting; 
    PAD_TO_64(pActiveAltSetting)
} WDU_INTERFACE;
 
typedef struct
{
    WDU_CONFIGURATION_DESCRIPTOR Descriptor; 
    DWORD dwNumInterfaces; 
    WDU_INTERFACE *pInterfaces; 
    PAD_TO_64(pInterfaces)
} WDU_CONFIGURATION;
 
typedef struct {
    WDU_DEVICE_DESCRIPTOR Descriptor; 
    WDU_PIPE_INFO Pipe0; 
    WDU_CONFIGURATION *pConfigs; 
    PAD_TO_64(pConfigs)
    WDU_CONFIGURATION *pActiveConfig; 
    PAD_TO_64(pActiveConfig)
    WDU_INTERFACE *pActiveInterface[WD_USB_MAX_INTERFACES]; 
    PAD_TO_64_PTR_ARR(pActiveInterface, WD_USB_MAX_INTERFACES)
} WDU_DEVICE;
 
/* Note: Any devices found matching this table will be controlled */
typedef struct
{
    USHORT wVendorId; 
    USHORT wProductId; 
    UCHAR  bDeviceClass; 
    UCHAR  bDeviceSubClass; 
    UCHAR  bInterfaceClass; 
    UCHAR  bInterfaceSubClass; 
    UCHAR  bInterfaceProtocol; 
} WDU_MATCH_TABLE;
 
typedef struct
{
    DWORD dwUniqueID;
    PAD_TO_64(dwUniqueID)
    PVOID pBuf;
    PAD_TO_64(pBuf)
    DWORD dwBytes;
    DWORD dwOptions;
} WDU_GET_DEVICE_DATA;
 
/* these enum values can be used as dwProperty values, see structure
 * WD_GET_DEVICE_PROPERTY below. */
typedef enum
{
    WdDevicePropertyDeviceDescription, 
    WdDevicePropertyHardwareID, 
    WdDevicePropertyCompatibleIDs, 
    WdDevicePropertyBootConfiguration, 
    WdDevicePropertyBootConfigurationTranslated, 
    WdDevicePropertyClassName, 
    WdDevicePropertyClassGuid, 
    WdDevicePropertyDriverKeyName, 
    WdDevicePropertyManufacturer, 
    WdDevicePropertyFriendlyName, 
    WdDevicePropertyLocationInformation, 
    WdDevicePropertyPhysicalDeviceObjectName, 
    WdDevicePropertyBusTypeGuid, 
    WdDevicePropertyLegacyBusType, 
    WdDevicePropertyBusNumber, 
    WdDevicePropertyEnumeratorName, 
    WdDevicePropertyAddress, 
    WdDevicePropertyUINumber, 
    WdDevicePropertyInstallState, 
    WdDevicePropertyRemovalPolicy 
} WD_DEVICE_REGISTRY_PROPERTY;
 
typedef struct
{
    DWORD dwUniqueID;
    DWORD dwInterfaceNum;
    DWORD dwAlternateSetting;
    DWORD dwOptions;
} WDU_SET_INTERFACE;
 
typedef struct
{
    DWORD dwUniqueID;
    DWORD dwPipeNum;
    DWORD dwOptions;
    PAD_TO_64(dwOptions)
} WDU_RESET_PIPE;
 
typedef enum {
    WDU_WAKEUP_ENABLE = 0x1,
    WDU_WAKEUP_DISABLE = 0x2
} WDU_WAKEUP_OPTIONS;
 
typedef enum {
    WDU_SELECTIVE_SUSPEND_SUBMIT = 0x1,
    WDU_SELECTIVE_SUSPEND_CANCEL = 0x2,
} WDU_SELECTIVE_SUSPEND_OPTIONS;
 
typedef struct
{
    DWORD dwUniqueID;
    DWORD dwPipeNum;
    DWORD dwOptions;
    PAD_TO_64(dwOptions)
} WDU_HALT_TRANSFER;
 
typedef struct
{
    DWORD dwUniqueID;
    DWORD dwOptions;
} WDU_WAKEUP;
 
typedef struct
{
    DWORD dwUniqueID;
    DWORD dwOptions;
} WDU_SELECTIVE_SUSPEND;
 
typedef struct
{
    DWORD dwUniqueID;
    DWORD dwOptions;
} WDU_RESET_DEVICE;
 
typedef struct
{
    DWORD dwUniqueID;
    DWORD dwPipeNum; 
    DWORD fRead; 
    DWORD dwOptions; 
    PVOID pBuffer;   
    PAD_TO_64(pBuffer)
    DWORD dwBufferSize; 
    DWORD dwBytesTransferred; 
    UCHAR SetupPacket[8]; 
    DWORD dwTimeout; 
    PAD_TO_64(dwTimeout)
} WDU_TRANSFER;
 
typedef struct
{
    DWORD dwUniqueID;
    UCHAR bType;
    UCHAR bIndex;
    USHORT wLength;
    PVOID pBuffer;
    PAD_TO_64(pBuffer)
    USHORT wLanguage;
} WDU_GET_DESCRIPTOR;
 
typedef struct
{
    DWORD dwUniqueID;
    DWORD dwOptions;
    DWORD dwPipeNum;
    DWORD dwBufferSize;
    DWORD dwRxSize;
    BOOL  fBlocking;
    DWORD dwRxTxTimeout;
    DWORD dwReserved;
} WDU_STREAM;
 
typedef struct
{
    DWORD dwUniqueID;
    DWORD dwOptions;
    BOOL  fIsRunning;
    DWORD dwLastError;
    DWORD dwBytesInBuffer;
    DWORD dwReserved;
} WDU_STREAM_STATUS;
 
#endif /* _WINDRVR_USB_H_ */