windrvr.h

Go to the documentation of this file.

/* @JUNGO_COPYRIGHT@ */
 
/*
 * W i n D r i v e r
 * =================
 *
 * FOR DETAILS ON THE WinDriver FUNCTIONS, PLEASE SEE THE WinDriver MANUAL
 * OR INCLUDED HELP FILES.
 *
 * This file may not be distributed, it may only be used for development
 * or evaluation purposes. The only exception is distribution to Linux.
 * For details refer to \WinDriver\docs\license.txt.
 *
 * Web site: https://www.jungo.com
 * Email:    [email protected]
 */
#ifndef _WINDRVR_H_
#define _WINDRVR_H_
 
#if defined(__cplusplus)
    extern "C" {
#endif
 
#include "wd_ver.h"
 
#if defined(WIN32) && !defined(__MINGW32__)
    #define DLLCALLCONV __stdcall
    #if !defined(_SAL_VERSION)
            #include <sal.h>
    #endif
#else
    #define DLLCALLCONV
 
    /* the following macros are part of SAL annotations macros in Windows and
     are used in prototype of API functions, therefore, must be defined in
     Unix as well */
    #define _In_
    #define _Inout_
    #define _Out_
    #define _Outptr_
#endif
 
#if defined(WIN32)
    #define WD_DRIVER_NAME_PREFIX "\\\\.\\"
#elif defined(LINUX)
    #define WD_DRIVER_NAME_PREFIX "/dev/"
#else
    #define WD_DRIVER_NAME_PREFIX ""
#endif
 
#if !defined(WIN32)
    #define __FUNCTION__ __func__
#endif
 
#define WD_DEFAULT_DRIVER_NAME_BASE "windrvr" WD_VER_ITOA
#define WD_DEFAULT_DRIVER_NAME \
    WD_DRIVER_NAME_PREFIX WD_DEFAULT_DRIVER_NAME_BASE
 
#define WD_MAX_DRIVER_NAME_LENGTH 128
#define WD_MAX_KP_NAME_LENGTH 128
#define WD_VERSION_STR_LENGTH 128
 
#if defined(WD_DRIVER_NAME_CHANGE)
    const char* DLLCALLCONV WD_DriverName(const char *sName);
    #define WD_DRIVER_NAME WD_DriverName(NULL)
#else
    #define WD_DRIVER_NAME WD_DEFAULT_DRIVER_NAME
#endif
 
#if defined (LOCAL_DEMO)
#define WD_PROD_NAME "WinDriver (Local Demo)"
#else
#define WD_PROD_NAME "WinDriver"
#endif
 
#if defined(x86_64)
#define KERNEL_64BIT
#elif defined(ARM64)
#define KERNEL_64BIT
#elif defined(ARM)
#elif defined(x86)
#else
#error No platform is defined. Please define either x86, x86_64, ARM or ARM64.
#endif
#if (defined(x86_64) && defined (ARM64)) || \
    (defined(x86_64) && defined (ARM)) || \
    (defined(x86_64) && defined (x86)) || \
    (defined(ARM64) && defined (x86)) || \
    (defined(ARM64) && defined (ARM)) || \
    (defined(x86) && defined(ARM)) 
#error Cannot have more than one platform defined in a WinDriver compilation.
#endif
 
 
#if defined(x86_64)
    #define WD_CPU_SPEC " x86_64"
#elif defined(ARM)
    #define WD_CPU_SPEC " ARM"
#elif defined(ARM64)
    #define WD_CPU_SPEC " ARM64"
#else
    #define WD_CPU_SPEC " X86"
#endif
 
#if defined(WINNT)
    #define WD_FILE_FORMAT " sys"
#elif defined (APPLE)
    #define WD_FILE_FORMAT " kext"
#elif defined (LINUX)
    #define WD_FILE_FORMAT " ko"
#endif
 
#if defined(KERNEL_64BIT)
    #define WD_DATA_MODEL " 64bit"
#else
    #define WD_DATA_MODEL " 32bit"
#endif
 
#if defined(__KERNEL__) && defined(WINNT)
    #if (NTDDI_VERSION >= NTDDI_WIN10_VB)
        #define WD_VER_STR_SUFFIX ""
    #else
        #define WD_VER_STR_SUFFIX " for Windows 10 (Build 18632 and Lower)"
    #endif
#else
    #define WD_VER_STR_SUFFIX ""
#endif
 
#define WD_VER_STR  WD_PROD_NAME " v" WD_VERSION_STR \
    " Jungo Connectivity (c) 1997 - " COPYRIGHTS_YEAR_STR \
        " Build Date: " __DATE__ \
    WD_CPU_SPEC WD_DATA_MODEL WD_FILE_FORMAT WD_VER_STR_SUFFIX
 
#if !defined(POSIX) && defined(LINUX)
    #define POSIX
#endif
 
#if !defined(UNIX) && defined(POSIX)
    #define UNIX
#endif
 
#if !defined(WIN32) && defined(WINNT)
    #define WIN32
#endif
 
#if !defined(WIN32) && !defined(UNIX) && !defined(APPLE)
    #define WIN32
#endif
 
#if defined(_KERNEL_MODE) && !defined(KERNEL)
    #define KERNEL
#endif
 
#if defined(KERNEL) && !defined(__KERNEL__)
    #define __KERNEL__
#endif
 
#if defined(_KERNEL) && !defined(__KERNEL__)
    #define __KERNEL__
#endif
 
#if defined( __KERNEL__) && !defined(_KERNEL)
    #define _KERNEL
#endif
 
#if defined(LINUX) && defined(__x86_64__) && !defined(__KERNEL__)
    /* This fixes binary compatibility with older version of GLIBC
     * (64bit only) */
    __asm__(".symver memcpy,memcpy@GLIBC_2.2.5");
#endif
 
#if defined(UNIX)
 
 
    #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;
        #if !defined (APPLE_USB)
            typedef unsigned long ULONG;
        #endif
        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 PVOID HANDLE;
    #endif
    #if !defined(__KERNEL__)
        #include <string.h>
        #include <ctype.h>
        #include <stdlib.h>
    #endif
    #ifndef TRUE
        #define TRUE 1
    #endif
    #ifndef FALSE
        #define FALSE 0
    #endif
    #define __cdecl
    #define WINAPI
 
    #if defined(__KERNEL__)
        #if defined(LINUX)
            /* For _IO macros and for mapping Linux status codes
             * to WD status codes */
            #include <asm-generic/ioctl.h>
            #include <asm-generic/errno.h>
        #endif
    #else
        #include <unistd.h>
        #if defined(LINUX)
            #include <sys/ioctl.h> /* for BSD ioctl() */
            #include <sys/mman.h>
        #endif
        #include <sys/types.h>
        #include <sys/stat.h>
        #include <fcntl.h>
    #endif
        typedef unsigned long long UINT64;
    #if defined(APPLE)
        #include <libkern/OSTypes.h>
        #include <libkern/OSAtomic.h>
        typedef UInt16 UINT16;
        typedef UInt8 UINT8;
        typedef UInt8 u8;
        typedef UInt16 u16;
        typedef UInt32 u32;
        #include <IOKit/IOTypes.h>
        #if defined(__KERNEL__)
            typedef struct OSObject* FILEHANDLE;
            typedef UInt32 PRCHANDLE;
        #else
            #include <IOKit/IOKitLib.h>
        #endif
        enum {
            kWinDriverMethodSyncIoctl = 0,
            kWinDriverNumOfMethods,
        };
        #if !defined(__KERNEL__)
             #include <string.h>
             #include <ctype.h>
        #endif
     #ifndef TRUE
         #define TRUE true
     #endif
     #ifndef FALSE
         #define FALSE false
     #endif
     #define __cdecl
     #define WINAPI
     #ifdef __LP64__
         #define PTR2INT(value) ((UInt64)(value))
     #else
         #define PTR2INT(value) ((UInt32)(value))
     #endif
     #define MAC_UC_MAGIC_MASK 0xFF0000FF
     #define MAC_UC_MAGIC_NUM  0x7E000041
     #define MAC_UC_64BIT_APP  0x100
#endif
 
#elif defined(WIN32)
    #if defined(__KERNEL__)
        #if !defined (CMAKE_WD_BUILD)
            int sprintf(char *buffer, const char *format, ...);
        #endif
    #else
        #include <windows.h>
        #include <winioctl.h>
    #endif
    #define stricmp _stricmp
    typedef unsigned __int64 UINT64;
#endif
 
#if !defined(__KERNEL__)
    #include <stdarg.h>
    #if !defined(va_copy) && !defined(__va_copy)
        #define va_copy(ap2,ap1) (ap2)=(ap1)
    #endif
    #if !defined(va_copy) && defined(__va_copy)
        #define va_copy __va_copy
    #endif
#endif
 
#ifndef WINAPI
    #define WINAPI
#endif
 
#if !defined(_WINDEF_)
    typedef unsigned char BYTE;
    typedef unsigned short int WORD;
#endif
 
#if !defined(_BASETSD_H_)
    typedef unsigned int UINT32;
#endif
 
#ifndef __KERNEL__
/* Include inttypes.h for portable printf format specifiers 
 * (PRId64, PRIx32, etc.). It does not define a macro named PRI64 */
#include <inttypes.h>
#endif
 
#if defined(UNIX)
    #define PRI64       "ll"
#elif defined(WIN32)
    #define PRI64       "I64"
#endif
 
#if defined(KERNEL_64BIT)
    #define KPRI PRI64
    #if defined(WIN32)
        #if defined(i386)
        #define UPRI "z"
        #else
        #define UPRI KPRI
        #endif
    #else
        #define UPRI "l"
    #endif
#else
    #define KPRI ""
    #define UPRI "l"
#endif
 
/*
 * The KPTR is guaranteed to be the same size as a kernel-mode pointer
 * The UPTR is guaranteed to be the same size as a user-mode pointer
 */
#if defined(KERNEL_64BIT)
    typedef UINT64 KPTR;
#else
    typedef UINT32 KPTR;
#endif
 
#if defined(UNIX)
    typedef unsigned long UPTR;
#else
    typedef size_t UPTR;
#endif
 
typedef UINT64 DMA_ADDR;
typedef UINT64 PHYS_ADDR;
 
#include "windrvr_usb.h"
 
typedef enum
{
    CMD_NONE = 0,       
    CMD_END = 1,        
    CMD_MASK = 2,       
    RP_BYTE = 10,       
    RP_WORD = 11,       
    RP_DWORD = 12,      
    WP_BYTE = 13,       
    WP_WORD = 14,       
    WP_DWORD = 15,      
    RP_QWORD = 16,      
    WP_QWORD = 17,      
    RP_SBYTE = 20,      
    RP_SWORD = 21,      
    RP_SDWORD = 22,     
    WP_SBYTE = 23,      
    WP_SWORD = 24,      
    WP_SDWORD = 25,     
    RP_SQWORD = 26,     
    WP_SQWORD = 27,     
    RM_BYTE = 30,       
    RM_WORD = 31,       
    RM_DWORD = 32,      
    WM_BYTE = 33,       
    WM_WORD = 34,       
    WM_DWORD = 35,      
    RM_QWORD = 36,      
    WM_QWORD = 37,      
    RM_SBYTE = 40,      
    RM_SWORD = 41,      
    RM_SDWORD = 42,     
    WM_SBYTE = 43,      
    WM_SWORD = 44,      
    WM_SDWORD = 45,     
    RM_SQWORD = 46,     
    WM_SQWORD = 47      
} WD_TRANSFER_CMD;
 
enum { WD_DMA_PAGES = 256 };
 
#ifndef DMA_BIT_MASK
    #define DMA_BIT_MASK(n) (((n) == 64) ? ~0ULL : ((1ULL<<(n))-1))
#endif
 
typedef enum {
    DMA_KERNEL_BUFFER_ALLOC = 0x1, 
    DMA_KBUF_BELOW_16M = 0x2, 
    DMA_LARGE_BUFFER = 0x4, 
    DMA_ALLOW_CACHE = 0x8,  
    DMA_KERNEL_ONLY_MAP = 0x10, 
    DMA_FROM_DEVICE = 0x20, 
    DMA_TO_DEVICE = 0x40, 
    DMA_TO_FROM_DEVICE = (DMA_FROM_DEVICE | DMA_TO_DEVICE), 
    DMA_ALLOW_64BIT_ADDRESS = 0x80, 
    DMA_ALLOW_NO_HCARD = 0x100, 
    DMA_GET_EXISTING_BUF = 0x200, 
    DMA_RESERVED_MEM = 0x400,
 
    DMA_KBUF_ALLOC_SPECIFY_ADDRESS_WIDTH = 0x800, 
     DMA_GET_PREALLOCATED_BUFFERS_ONLY = 0x1000, 
     DMA_TRANSACTION = 0x2000, 
     DMA_GPUDIRECT = 0x4000, 
     DMA_DISABLE_MERGE_ADJACENT_PAGES = 0x8000, 
     DMA_OVERRIDE_CMA_VALIDATION = 0x10000, 
     DMA_P2PDMA = 0x20000, 
} WD_DMA_OPTIONS;
 
#define DMA_ADDRESS_WIDTH_MASK 0x7f000000
 
#define DMA_OPTIONS_ALL \
    (DMA_KERNEL_BUFFER_ALLOC | DMA_KBUF_BELOW_16M | DMA_LARGE_BUFFER \
    | DMA_ALLOW_CACHE | DMA_KERNEL_ONLY_MAP | DMA_FROM_DEVICE | DMA_TO_DEVICE \
    | DMA_ALLOW_64BIT_ADDRESS | DMA_ALLOW_NO_HCARD | DMA_GET_EXISTING_BUF \
    | DMA_RESERVED_MEM | DMA_KBUF_ALLOC_SPECIFY_ADDRESS_WIDTH \
    | DMA_ADDRESS_WIDTH_MASK)
 
#define DMA_DIRECTION_MASK DMA_TO_FROM_DEVICE
 
#define DMA_READ_FROM_DEVICE DMA_FROM_DEVICE
#define DMA_WRITE_TO_DEVICE DMA_TO_DEVICE
 
#define DMA_OPTIONS_ADDRESS_WIDTH_SHIFT 24 
 
enum {
    WD_MATCH_EXCLUDE = 0x1 
};
 
#ifndef PAD_TO_64
/* Use it to pad struct size to 64 bit, when using 32 on 64 bit applications */
#if defined (i386) && defined(KERNEL_64BIT)
    #define PAD_TO_64(pName) DWORD dwPad_##pName;
#else
    #define PAD_TO_64(pName)
#endif
#endif
 
typedef struct
{
    DMA_ADDR pPhysicalAddr; 
    DWORD dwBytes;          
    PAD_TO_64(dwBytes)
} WD_DMA_PAGE, WD_DMA_PAGE_V80;
 
typedef void (DLLCALLCONV * DMA_TRANSACTION_CALLBACK)(PVOID pData);
 
typedef struct
{
    DWORD hDma;        
    PAD_TO_64(hDma)
 
    PVOID pUserAddr;   
    PAD_TO_64(pUserAddr)
 
    KPTR  pKernelAddr; 
    DWORD dwBytes;     
    DWORD dwOptions;   
    DWORD dwPages;     
    DWORD hCard;       
#if defined(LINUX)
    union {
        struct {
#endif /* defined(LINUX) */
            /* Windows: The following 6 parameters are used for DMA transaction only */
            DMA_TRANSACTION_CALLBACK DMATransactionCallback;
            PAD_TO_64(DMATransactionCallback)
 
            PVOID DMATransactionCallbackCtx;
            PAD_TO_64(DMATransactionCallbackCtx)
 
            DWORD dwAlignment; 
            DWORD dwMaxTransferSize;     
            DWORD dwTransferElementSize; 
            DWORD dwBytesTransferred;    
#if defined(LINUX)
        };
 
        struct {
            DWORD hP2pProviderCard;        
            PAD_TO_64(hP2pProviderCard)
        };
    };
#endif /* defined(LINUX) */
    WD_DMA_PAGE Page[WD_DMA_PAGES];
} WD_DMA, WD_DMA_V80;
 
typedef enum {
    /* KER_BUF_ALLOC_NON_CONTIG and KER_BUF_GET_EXISTING_BUF options are valid
     * only as part of "WinDriver for Server" API and require
     * "WinDriver for Server" license.
     * @note "WinDriver for Server" APIs are included in WinDriver evaluation
     * version. */
    KER_BUF_ALLOC_NON_CONTIG = 0x0001,
    KER_BUF_ALLOC_CONTIG     = 0x0002,
    KER_BUF_ALLOC_CACHED     = 0x0004,
    KER_BUF_GET_EXISTING_BUF = 0x0008,
} WD_KER_BUF_OPTION;
 
typedef struct
{
    DWORD hKerBuf;    
    DWORD dwOptions;  
    UINT64 qwBytes;   
    KPTR pKernelAddr; 
    UPTR pUserAddr;   
    PAD_TO_64(pUserAddr)
} WD_KERNEL_BUFFER, WD_KERNEL_BUFFER_V121;
 
enum { MAX_TRANSFER_COMMANDS = 1024 };
 
typedef struct
{
    KPTR  pPort;       
    DWORD cmdTrans;    
    PAD_TO_64(cmdTrans)
 
    /*  Parameters used for string transfers: */
    UINT64 u64Bytes;     
    DWORD fAutoinc;    
    DWORD dwOptions;   
    union
    {
        BYTE Byte;     
        WORD Word;     
        UINT32 Dword;  
        UINT64 Qword;  
        PVOID pBuffer; 
    } Data;
} WD_TRANSFER, WD_TRANSFER_V61;
 
enum {
    INTERRUPT_LATCHED = 0x00,             
    INTERRUPT_LEVEL_SENSITIVE = 0x01,     
    INTERRUPT_CMD_COPY = 0x02,            
    INTERRUPT_EDGE_SENSITIVE = 0x04,      
    INTERRUPT_CMD_RETURN_VALUE = 0x08,    
    INTERRUPT_MESSAGE = 0x10,             
    INTERRUPT_MESSAGE_X = 0x20,           
    INTERRUPT_DONT_GET_MSI_MESSAGE = 0x40 
};
 
typedef struct
{
    DWORD hKernelPlugIn;
    DWORD dwMessage;
    PVOID pData;
    PAD_TO_64(pData)
    DWORD dwResult;
    PAD_TO_64(dwResult)
} WD_KERNEL_PLUGIN_CALL, WD_KERNEL_PLUGIN_CALL_V40;
 
typedef enum {
    INTERRUPT_RECEIVED = 0, 
    INTERRUPT_STOPPED,      
    INTERRUPT_INTERRUPTED   
} WD_INTERRUPT_WAIT_RESULT;
 
typedef struct
{
    DWORD hInterrupt;    
    DWORD dwOptions;     
    WD_TRANSFER *Cmd;    
    PAD_TO_64(Cmd)
    DWORD dwCmds;        
    PAD_TO_64(dwCmds)
 
    /* For WD_IntEnable(): */
    WD_KERNEL_PLUGIN_CALL kpCall; 
    DWORD fEnableOk;     
    /* For WD_IntWait() and WD_IntCount(): */
    DWORD dwCounter;     
    DWORD dwLost;        
    DWORD fStopped;      
    DWORD dwLastMessage; 
    DWORD dwEnabledIntType; 
} WD_INTERRUPT, WD_INTERRUPT_V91;
 
#define WD_ENABLED_INT_TYPE_MASK 0x3f
#define WD_ENABLED_INT_TYPE_GET_ENABLED_INT_TYPE_BITS(dwEnabledIntType) \
    (dwEnabledIntType & WD_ENABLED_INT_TYPE_MASK)
#define WD_ENABLED_INT_TYPE_NUM_VECTORS_POSITION_BITS 20
 
typedef struct
{
    DWORD dwVer;
    CHAR cVer[WD_VERSION_STR_LENGTH];
} WD_VERSION, WD_VERSION_V30;
 
#define WD_LICENSE_LENGTH 3072
typedef struct
{
    CHAR cLicense[WD_LICENSE_LENGTH]; 
} WD_LICENSE, WD_LICENSE_V122;
 
enum
{
    WD_BUS_USB = (int)0xfffffffe,   
    WD_BUS_UNKNOWN = 0,             
    WD_BUS_ISA = 1,                 
    WD_BUS_EISA = 2,                
    WD_BUS_PCI = 5,                 
    WD_BUS_PLATFORM = 6,             
};
typedef DWORD WD_BUS_TYPE;
 
typedef struct
{
    WD_BUS_TYPE dwBusType;  
    DWORD dwDomainNum;      
    DWORD dwBusNum;         
    DWORD dwSlotFunc;       
} WD_BUS, WD_BUS_V30;
 
typedef enum
{
    ITEM_NONE         = 0,
    ITEM_INTERRUPT    = 1, 
    ITEM_MEMORY       = 2, 
    ITEM_IO           = 3, 
    ITEM_BUS          = 5  
} ITEM_TYPE;
 
typedef enum
{
    WD_ITEM_MEM_DO_NOT_MAP_KERNEL = 0x1,
    WD_ITEM_MEM_ALLOW_CACHE =      0x2, 
    WD_ITEM_MEM_USER_MAP =         0x4, 
    WD_ITEM_MEM_P2P_MAP =          0x8, 
} WD_ITEM_MEM_OPTIONS;
 
#define WD_ITEM_MEM_P2P_2MB_BLOCKS_COUNT_MASK 0xFFFFFF00
#define WD_ITEM_MEM_P2P_2MB_BLOCKS_COUNT_SHIFT 8
#define WD_ITEM_MEM_P2P_2MB_BLOCKS_COUNT_GET_SIZE(dwOptions) \
    (((dwOptions) & WD_ITEM_MEM_P2P_2MB_BLOCKS_COUNT_MASK) >> \
    WD_ITEM_MEM_P2P_2MB_BLOCKS_COUNT_SHIFT)
#define WD_ITEM_MEM_P2P_2MB_BLOCKS_COUNT_SET_SIZE(dwOptions, size) \
    ((dwOptions) = ((dwOptions) & ~WD_ITEM_MEM_P2P_2MB_BLOCKS_COUNT_MASK) | \
    (((size) << WD_ITEM_MEM_P2P_2MB_BLOCKS_COUNT_SHIFT)))
 
#define WD_ITEM_MEM_P2P_ENABLE(memItem, size, offset) \
    do { \
        (memItem).dwOptions |= WD_ITEM_MEM_P2P_MAP; \
        WD_ITEM_MEM_P2P_2MB_BLOCKS_COUNT_SET_SIZE((memItem).dwOptions, size); \
        (memItem).pReserved = (KPTR)offset; \
    } while (0)
 
typedef struct
{
    DWORD item;         
    DWORD fNotSharable;
    union I
    {
        struct Mem
        {
            PHYS_ADDR pPhysicalAddr; 
            UINT64 qwBytes;          
            KPTR pTransAddr;         
            UPTR pUserDirectAddr;    
            PAD_TO_64(pUserDirectAddr)
            DWORD dwBar;             
            DWORD dwOptions;         
            KPTR pReserved;          
        } Mem;
 
        struct IO
        {
            KPTR  pAddr;    
            DWORD dwBytes;  
            DWORD dwBar;    
        } IO;
 
        struct Int
        {
            DWORD dwInterrupt;  
            DWORD dwOptions;    
            DWORD hInterrupt;   
            DWORD dwReserved1;  
            KPTR  pReserved2;   
        } Int;
        WD_BUS Bus; 
    } I;
} WD_ITEMS, WD_ITEMS_V118;
 
enum { WD_CARD_ITEMS = 128 };
 
typedef struct
{
    DWORD dwItems;
    PAD_TO_64(dwItems)
    WD_ITEMS Item[WD_CARD_ITEMS];
} WD_CARD, WD_CARD_V118;
 
typedef struct
{
    WD_CARD Card;           
    DWORD fCheckLockOnly;   
    DWORD hCard;            
    DWORD dwOptions;        
    CHAR cName[32];         
    CHAR cDescription[100]; 
} WD_CARD_REGISTER, WD_CARD_REGISTER_V118;
 
#define WD_PROCESS_NAME_LENGTH 128
typedef struct
{
    CHAR  cProcessName[WD_PROCESS_NAME_LENGTH];
    DWORD dwSubGroupID; 
    DWORD dwGroupID;  
    DWORD hIpc;       
} WD_IPC_PROCESS, WD_IPC_PROCESS_V121;
 
typedef struct
{
    WD_IPC_PROCESS procInfo;
    DWORD          dwOptions;  
} WD_IPC_REGISTER, WD_IPC_REGISTER_V121;
 
enum { WD_IPC_MAX_PROCS = 0x40 };
 
typedef struct
{
    DWORD          hIpc;       
    DWORD          dwNumProcs; 
    WD_IPC_PROCESS procInfo[WD_IPC_MAX_PROCS];
} WD_IPC_SCAN_PROCS, WD_IPC_SCAN_PROCS_V121;
 
enum
{
    WD_IPC_UID_UNICAST = 0x1,
    WD_IPC_SUBGROUP_MULTICAST = 0x2,
    WD_IPC_MULTICAST = 0x4,
};
 
typedef struct
{
    DWORD hIpc;           
    DWORD dwOptions;      
    DWORD  dwRecipientID; 
    DWORD  dwMsgID;
    UINT64 qwMsgData;
} WD_IPC_SEND, WD_IPC_SEND_V121;
 
typedef struct
{
    DWORD hCard;            
    PAD_TO_64(hCard)
    WD_TRANSFER *Cmd;       
    PAD_TO_64(Cmd)
    DWORD dwCmds;           
    DWORD dwOptions;        
} WD_CARD_CLEANUP;
 
enum { WD_FORCE_CLEANUP = 0x1 };
 
enum { WD_PCI_CARDS = 256 }; 
typedef struct
{
    DWORD dwDomain; 
    DWORD dwBus; 
    DWORD dwSlot; 
    DWORD dwFunction; 
} WD_PCI_SLOT;
 
typedef struct
{
    DWORD dwVendorId;
    DWORD dwDeviceId;
} WD_PCI_ID;
 
typedef struct
{
    WD_PCI_ID searchId;     
    DWORD dwCards;          
    WD_PCI_ID cardId[WD_PCI_CARDS];     
    WD_PCI_SLOT cardSlot[WD_PCI_CARDS]; 
    DWORD dwOptions;        
} WD_PCI_SCAN_CARDS, WD_PCI_SCAN_CARDS_V124;
 
enum {WD_PLATFORM_CARDS = 32};
enum {WD_DEVICE_NAME_LENGTH = 256};
 
typedef struct
{
    CHAR pcSearchName[WD_DEVICE_NAME_LENGTH];  
    PHYS_ADDR pSearchAddr; 
    DWORD dwCards;          
    CHAR pcDeviceNames[WD_PLATFORM_CARDS][WD_DEVICE_NAME_LENGTH]; 
    KPTR pAddresses[WD_PLATFORM_CARDS]; 
} WD_PLATFORM_SCAN_DEVICES;
 
typedef enum {
    WD_PCI_SCAN_DEFAULT = 0x0,
    WD_PCI_SCAN_BY_TOPOLOGY = 0x1,
    WD_PCI_SCAN_REGISTERED = 0x2,
    WD_PCI_SCAN_INCLUDE_DOMAINS = 0x4,
} WD_PCI_SCAN_OPTIONS;
 
enum { WD_PCI_MAX_CAPS = 50 };
 
enum { WD_PCI_CAP_ID_ALL = 0x0 };
 
typedef struct
{
    DWORD dwCapId;      
    DWORD dwCapOffset;  
} WD_PCI_CAP;
 
typedef enum {
    WD_PCI_SCAN_CAPS_BASIC = 0x1,   
    WD_PCI_SCAN_CAPS_EXTENDED = 0x2 
} WD_PCI_SCAN_CAPS_OPTIONS;
 
typedef struct
{
    WD_PCI_SLOT pciSlot;   
    DWORD       dwCapId;   
    DWORD       dwOptions; 
    DWORD       dwNumCaps; 
    WD_PCI_CAP  pciCaps[WD_PCI_MAX_CAPS]; 
} WD_PCI_SCAN_CAPS, WD_PCI_SCAN_CAPS_V118;
 
typedef struct
{
    WD_PCI_SLOT pciSlot;    
    DWORD       dwNumVFs;   
} WD_PCI_SRIOV, WD_PCI_SRIOV_V122;
 
typedef struct
{
    WD_PCI_SLOT pciSlot;    
    WD_CARD Card;           
} WD_PCI_CARD_INFO, WD_PCI_CARD_INFO_V118;
 
typedef struct 
{
    PHYS_ADDR pPhysicalAddr;    
    CHAR pcDeviceName[WD_DEVICE_NAME_LENGTH]; 
    WD_CARD Card;                             
} WD_PLATFORM_CARD_INFO;
 
typedef enum
{
    PCI_ACCESS_OK = 0,
    PCI_ACCESS_ERROR = 1,
    PCI_BAD_BUS = 2,
    PCI_BAD_SLOT = 3
} PCI_ACCESS_RESULT;
 
typedef struct
{
    WD_PCI_SLOT pciSlot;    
    PVOID       pBuffer;    
    PAD_TO_64(pBuffer)
 
    DWORD       dwOffset;   
    DWORD       dwBytes;    
    DWORD       fIsRead;    
    DWORD       dwResult;   
} WD_PCI_CONFIG_DUMP, WD_PCI_CONFIG_DUMP_V30;
 
enum { SLEEP_BUSY = 0, SLEEP_NON_BUSY = 1 };
typedef struct
{
    DWORD dwMicroSeconds; 
    DWORD dwOptions;      
} WD_SLEEP, WD_SLEEP_V40;
 
typedef enum
{
    D_OFF       = 0,
    D_ERROR     = 1,
    D_WARN      = 2,
    D_INFO      = 3,
    D_TRACE     = 4
} DEBUG_LEVEL;
 
typedef enum
{
    S_ALL       = (int)0xffffffff,
    S_IO        = 0x00000008,
    S_MEM       = 0x00000010,
    S_INT       = 0x00000020,
    S_PCI       = 0x00000040,
    S_DMA       = 0x00000080,
    S_MISC      = 0x00000100,
    S_LICENSE   = 0x00000200,
    S_PNP       = 0x00001000,
    S_CARD_REG  = 0x00002000,
    S_KER_DRV   = 0x00004000,
    S_USB       = 0x00008000,
    S_KER_PLUG  = 0x00010000,
    S_EVENT     = 0x00020000,
    S_IPC       = 0x00040000,
    S_KER_BUF   = 0x00080000,
    S_PLATFORM  = 0x00100000,
    S_P2PDMA    = 0x00200000,
} DEBUG_SECTION;
 
typedef enum
{
    DEBUG_STATUS = 1,
    DEBUG_SET_FILTER = 2,
    DEBUG_SET_BUFFER = 3,
    DEBUG_CLEAR_BUFFER = 4,
    DEBUG_DUMP_SEC_ON = 5,
    DEBUG_DUMP_SEC_OFF = 6,
    KERNEL_DEBUGGER_ON = 7,
    KERNEL_DEBUGGER_OFF = 8,
    DEBUG_DUMP_CLOCK_ON = 9,
    DEBUG_DUMP_CLOCK_OFF = 10,
    DEBUG_CLOCK_RESET = 11
} DEBUG_COMMAND;
 
typedef struct
{
    DWORD dwCmd;     
    /* used for DEBUG_SET_FILTER */
    DWORD dwLevel;   
    DWORD dwSection; 
    DWORD dwLevelMessageBox; 
    /* used for DEBUG_SET_BUFFER */
    DWORD dwBufferSize; 
} WD_DEBUG, WD_DEBUG_V40;
 
#define DEBUG_USER_BUF_LEN 2048
typedef struct
{
    CHAR cBuffer[DEBUG_USER_BUF_LEN]; 
} WD_DEBUG_DUMP, WD_DEBUG_DUMP_V40;
 
typedef struct
{
    CHAR pcBuffer[256];
    DWORD dwLevel;
    DWORD dwSection;
} WD_DEBUG_ADD, WD_DEBUG_ADD_V503;
 
typedef struct
{
    DWORD hKernelPlugIn;
    CHAR cDriverName[WD_MAX_KP_NAME_LENGTH];
    CHAR cDriverPath[WD_MAX_KP_NAME_LENGTH]; 
    PAD_TO_64(hKernelPlugIn) /* 64 bit app has a 4 byte hole here */
    PVOID pOpenData;
    PAD_TO_64(pOpenData)
} WD_KERNEL_PLUGIN, WD_KERNEL_PLUGIN_V40;
 
typedef enum
{
    WD_DEVICE_PCI = 0x1,
    WD_DEVICE_USB = 0x2
} WD_GET_DEVICE_PROPERTY_OPTION;
 
typedef struct
{
    union
    {
        HANDLE hDevice;
        DWORD dwUniqueID;
    } h;
    PAD_TO_64(hDevice)
    PVOID pBuf;
    PAD_TO_64(pBuf)
    DWORD dwBytes;
    DWORD dwProperty;
    DWORD dwOptions; 
    PAD_TO_64(dwOptions)
} WD_GET_DEVICE_PROPERTY;
 
typedef enum {
    WD_STATUS_SUCCESS = 0, 
    WD_STATUS_INVALID_WD_HANDLE = (int)0xffffffff, 
    WD_WINDRIVER_STATUS_ERROR = 0x20000000L, 
    WD_INVALID_HANDLE = 0x20000001L, 
    WD_INVALID_PIPE_NUMBER = 0x20000002L, 
    WD_READ_WRITE_CONFLICT = 0x20000003L, 
    WD_ZERO_PACKET_SIZE = 0x20000004L, 
    WD_INSUFFICIENT_RESOURCES = 0x20000005L, 
    WD_UNKNOWN_PIPE_TYPE = 0x20000006L, 
    WD_SYSTEM_INTERNAL_ERROR = 0x20000007L, 
    WD_DATA_MISMATCH = 0x20000008L, 
    WD_NO_LICENSE = 0x20000009L, 
    WD_NOT_IMPLEMENTED = 0x2000000aL, 
    WD_KERPLUG_FAILURE = 0x2000000bL, 
    WD_FAILED_ENABLING_INTERRUPT = 0x2000000cL, 
    WD_INTERRUPT_NOT_ENABLED = 0x2000000dL, 
    WD_RESOURCE_OVERLAP = 0x2000000eL, 
    WD_DEVICE_NOT_FOUND = 0x2000000fL, 
    WD_WRONG_UNIQUE_ID = 0x20000010L, 
    WD_OPERATION_ALREADY_DONE = 0x20000011L, 
    WD_USB_DESCRIPTOR_ERROR = 0x20000012L, 
    WD_SET_CONFIGURATION_FAILED = 0x20000013L, 
    WD_CANT_OBTAIN_PDO = 0x20000014L, 
    WD_TIME_OUT_EXPIRED = 0x20000015L, 
    WD_IRP_CANCELED = 0x20000016L, 
    WD_FAILED_USER_MAPPING = 0x20000017L, 
    WD_FAILED_KERNEL_MAPPING = 0x20000018L, 
    WD_NO_RESOURCES_ON_DEVICE = 0x20000019L, 
    WD_NO_EVENTS = 0x2000001aL, 
    WD_INVALID_PARAMETER = 0x2000001bL, 
    WD_INCORRECT_VERSION = 0x2000001cL, 
    WD_TRY_AGAIN = 0x2000001dL, 
    WD_WINDRIVER_NOT_FOUND = 0x2000001eL, 
    WD_INVALID_IOCTL = 0x2000001fL, 
    WD_OPERATION_FAILED = 0x20000020L, 
    WD_INVALID_32BIT_APP = 0x20000021L, 
    WD_TOO_MANY_HANDLES = 0x20000022L, 
    WD_NO_DEVICE_OBJECT = 0x20000023L, 
    WD_MORE_PROCESSING_REQUIRED = (int)0xC0000016L, 
    /* The following status codes are returned by USBD:
     USBD status types: */
    WD_USBD_STATUS_SUCCESS = 0x00000000L, 
    WD_USBD_STATUS_PENDING = 0x40000000L, 
    WD_USBD_STATUS_ERROR = (int)0x80000000L, 
    WD_USBD_STATUS_HALTED = (int)0xC0000000L, 
    /* USBD status codes: */
    /* @note The following status codes are comprised of one of the status
    * types above and an error code [i.e. 0xXYYYYYYYL - where: X = status type;
    * YYYYYYY = error code].
    * The same error codes may also appear with one of the other status types
    * as well. */
 
    /* HC (Host Controller) status codes.
    @note These status codes use the WD_USBD_STATUS_HALTED status type]: */
    WD_USBD_STATUS_CRC = (int)0xC0000001L, 
    WD_USBD_STATUS_BTSTUFF = (int)0xC0000002L, 
    WD_USBD_STATUS_DATA_TOGGLE_MISMATCH = (int)0xC0000003L, 
    WD_USBD_STATUS_STALL_PID = (int)0xC0000004L, 
    WD_USBD_STATUS_DEV_NOT_RESPONDING = (int)0xC0000005L, 
    WD_USBD_STATUS_PID_CHECK_FAILURE = (int)0xC0000006L, 
    WD_USBD_STATUS_UNEXPECTED_PID = (int)0xC0000007L, 
    WD_USBD_STATUS_DATA_OVERRUN = (int)0xC0000008L, 
    WD_USBD_STATUS_DATA_UNDERRUN = (int)0xC0000009L, 
    WD_USBD_STATUS_RESERVED1 = (int)0xC000000AL, 
    WD_USBD_STATUS_RESERVED2 = (int)0xC000000BL, 
    WD_USBD_STATUS_BUFFER_OVERRUN = (int)0xC000000CL, 
    WD_USBD_STATUS_BUFFER_UNDERRUN = (int)0xC000000DL, 
    WD_USBD_STATUS_NOT_ACCESSED = (int)0xC000000FL, 
    WD_USBD_STATUS_FIFO = (int)0xC0000010L, 
#if defined(WIN32)
    WD_USBD_STATUS_XACT_ERROR = (int)0xC0000011L, 
    WD_USBD_STATUS_BABBLE_DETECTED = (int)0xC0000012L, 
    WD_USBD_STATUS_DATA_BUFFER_ERROR = (int)0xC0000013L, 
#endif
 
    WD_USBD_STATUS_CANCELED = (int)0xC0010000L, 
    WD_USBD_STATUS_ENDPOINT_HALTED = (int)0xC0000030L,
 
    /* Software status codes
    @note The following status codes have only the error bit set: */
    WD_USBD_STATUS_NO_MEMORY = (int)0x80000100L, 
    WD_USBD_STATUS_INVALID_URB_FUNCTION = (int)0x80000200L, 
    WD_USBD_STATUS_INVALID_PARAMETER = (int)0x80000300L, 
    WD_USBD_STATUS_ERROR_BUSY = (int)0x80000400L,
 
    WD_USBD_STATUS_REQUEST_FAILED = (int)0x80000500L,
    WD_USBD_STATUS_INVALID_PIPE_HANDLE = (int)0x80000600L,
 
    WD_USBD_STATUS_NO_BANDWIDTH = (int)0x80000700L,
 
    WD_USBD_STATUS_INTERNAL_HC_ERROR = (int)0x80000800L,
 
    WD_USBD_STATUS_ERROR_SHORT_TRANSFER = (int)0x80000900L,
 
    WD_USBD_STATUS_BAD_START_FRAME = (int)0xC0000A00L,
 
    WD_USBD_STATUS_ISOCH_REQUEST_FAILED = (int)0xC0000B00L,
 
    WD_USBD_STATUS_FRAME_CONTROL_OWNED = (int)0xC0000C00L,
 
    WD_USBD_STATUS_FRAME_CONTROL_NOT_OWNED = (int)0xC0000D00L
 
#if defined(WIN32)
    ,
    /* Additional USB 2.0 software error codes added for USB 2.0: */
    WD_USBD_STATUS_NOT_SUPPORTED = (int)0xC0000E00L,
    WD_USBD_STATUS_INAVLID_CONFIGURATION_DESCRIPTOR = (int)0xC0000F00L, 
    WD_USBD_STATUS_INSUFFICIENT_RESOURCES = (int)0xC0001000L,  
    WD_USBD_STATUS_SET_CONFIG_FAILED = (int)0xC0002000L,  
    WD_USBD_STATUS_BUFFER_TOO_SMALL = (int)0xC0003000L,  
    WD_USBD_STATUS_INTERFACE_NOT_FOUND = (int)0xC0004000L,  
    WD_USBD_STATUS_INAVLID_PIPE_FLAGS = (int)0xC0005000L,  
    WD_USBD_STATUS_TIMEOUT = (int)0xC0006000L,  
    WD_USBD_STATUS_DEVICE_GONE = (int)0xC0007000L,  
    WD_USBD_STATUS_STATUS_NOT_MAPPED = (int)0xC0008000L,  
    WD_USBD_STATUS_ISO_NOT_ACCESSED_BY_HW = (int)0xC0020000L,
    WD_USBD_STATUS_ISO_TD_ERROR = (int)0xC0030000L,
    WD_USBD_STATUS_ISO_NA_LATE_USBPORT = (int)0xC0040000L,
    WD_USBD_STATUS_ISO_NOT_ACCESSED_LATE = (int)0xC0050000L
#endif
} WD_ERROR_CODES;
 
typedef enum
{
    WD_INSERT                  = 0x1,
    WD_REMOVE                  = 0x2,
    WD_OBSOLETE                = 0x8,  
    WD_POWER_CHANGED_D0        = 0x10, 
    WD_POWER_CHANGED_D1        = 0x20,
    WD_POWER_CHANGED_D2        = 0x40,
    WD_POWER_CHANGED_D3        = 0x80,
    WD_POWER_SYSTEM_WORKING    = 0x100,
    WD_POWER_SYSTEM_SLEEPING1  = 0x200,
    WD_POWER_SYSTEM_SLEEPING2  = 0x400,
    WD_POWER_SYSTEM_SLEEPING3  = 0x800,
    WD_POWER_SYSTEM_HIBERNATE  = 0x1000,
    WD_POWER_SYSTEM_SHUTDOWN   = 0x2000,
    WD_IPC_UNICAST_MSG         = 0x4000,
    WD_IPC_MULTICAST_MSG       = 0x8000,
} WD_EVENT_ACTION;
 
#define WD_IPC_ALL_MSG (WD_IPC_UNICAST_MSG | WD_IPC_MULTICAST_MSG)
 
typedef enum
{
    WD_ACKNOWLEDGE              = 0x1,
    WD_ACCEPT_CONTROL           = 0x2
} WD_EVENT_OPTION;
 
#define WDU_USE_SHARED_OBJECT_HANDLE 0x1000000
#define WDU_DONT_INSERT_LICENSE      0x2000000
 
#define WD_ACTIONS_POWER (WD_POWER_CHANGED_D0 | WD_POWER_CHANGED_D1 | \
    WD_POWER_CHANGED_D2 | WD_POWER_CHANGED_D3 | WD_POWER_SYSTEM_WORKING | \
    WD_POWER_SYSTEM_SLEEPING1 | WD_POWER_SYSTEM_SLEEPING3 | \
    WD_POWER_SYSTEM_HIBERNATE | WD_POWER_SYSTEM_SHUTDOWN)
#define WD_ACTIONS_ALL (WD_ACTIONS_POWER | WD_INSERT | WD_REMOVE)
 
enum
{
    WD_EVENT_TYPE_UNKNOWN = 0,
    WD_EVENT_TYPE_PCI     = 1,
    WD_EVENT_TYPE_USB     = 3,
    WD_EVENT_TYPE_IPC     = 4,
};
typedef DWORD WD_EVENT_TYPE;
 
typedef struct
{
    DWORD hEvent;
    DWORD dwEventType;      
    DWORD dwAction;         
    DWORD dwEventId;
    DWORD hKernelPlugIn;
    DWORD dwOptions;        
    union u
    {
        struct Pci
        {
            WD_PCI_ID cardId;
            WD_PCI_SLOT pciSlot;
        } Pci;
        struct Usb
        {
            DWORD dwUniqueID;
        } Usb;
        struct Ipc
        {
            DWORD hIpc;        
            DWORD dwSubGroupID; 
            DWORD dwGroupID;
 
            DWORD dwSenderUID;
            DWORD dwMsgID;
            PAD_TO_64(dwMsgID)
            UINT64 qwMsgData;
        } Ipc;
    } u;
 
    DWORD dwNumMatchTables;
    WDU_MATCH_TABLE matchTables[1];
} WD_EVENT, WD_EVENT_V121;
 
typedef struct
{
    DWORD applications_num;
    DWORD devices_num;
} WD_USAGE;
 
enum
{
    WD_USB_HARD_RESET = 1,
    WD_USB_CYCLE_PORT = 2
};
 
#ifndef BZERO
    #define BZERO(buf) memset(&(buf), 0, sizeof(buf))
#endif
 
#ifndef INVALID_HANDLE_VALUE
    #define INVALID_HANDLE_VALUE ((HANDLE)(-1))
#endif
 
#ifndef CTL_CODE
    #define CTL_CODE(DeviceType, Function, Method, Access) ( \
        ((DeviceType)<<16) | ((Access)<<14) | ((Function)<<2) | (Method) \
    )
 
    #define METHOD_BUFFERED   0
    #define METHOD_IN_DIRECT  1
    #define METHOD_OUT_DIRECT 2
    #define METHOD_NEITHER    3
    #define FILE_ANY_ACCESS   0
    #define FILE_READ_ACCESS  1    
    #define FILE_WRITE_ACCESS 2    
#endif
 
#if defined(LINUX) && defined(KERNEL_64BIT)
    #define WD_TYPE 0
    #define WD_CTL_CODE(wFuncNum) \
        _IOC(_IOC_READ|_IOC_WRITE, WD_TYPE, wFuncNum, 0)
    #define WD_CTL_DECODE_FUNC(IoControlCode) _IOC_NR(IoControlCode)
    #define WD_CTL_DECODE_TYPE(IoControlCode) _IOC_TYPE(IoControlCode)
#elif defined(UNIX)
    #define WD_TYPE 0
    #define WD_CTL_CODE(wFuncNum) (wFuncNum)
    #define WD_CTL_DECODE_FUNC(IoControlCode) (IoControlCode)
    #define WD_CTL_DECODE_TYPE(IoControlCode) (WD_TYPE)
#else
    #define WD_TYPE 38200
    #if defined(KERNEL_64BIT)
        #define FUNC_MASK 0x400
    #else
        #define FUNC_MASK 0x0
    #endif
    #define WD_CTL_CODE(wFuncNum) CTL_CODE(WD_TYPE, (wFuncNum | FUNC_MASK), \
        METHOD_NEITHER, FILE_ANY_ACCESS)
    #define WD_CTL_DECODE_FUNC(IoControlCode) ((IoControlCode >> 2) & 0xfff)
    #define WD_CTL_DECODE_TYPE(IoControlCode) \
        DEVICE_TYPE_FROM_CTL_CODE(IoControlCode)
#endif
 
#if defined(LINUX)
    #define WD_CTL_IS_64BIT_AWARE(IoControlCode) \
        (_IOC_DIR(IoControlCode) & (_IOC_READ|_IOC_WRITE))
#elif defined(UNIX)
    #define WD_CTL_IS_64BIT_AWARE(IoControlCode) TRUE
#else
    #define WD_CTL_IS_64BIT_AWARE(IoControlCode) \
        (WD_CTL_DECODE_FUNC(IoControlCode) & FUNC_MASK)
#endif
 
/* WinDriver function IOCTL calls. For details on the WinDriver functions, */
/* see the WinDriver manual or included help files. */
 
#define IOCTL_WD_KERNEL_BUF_LOCK                    WD_CTL_CODE(0x901)
#define IOCTL_WD_KERNEL_BUF_UNLOCK                  WD_CTL_CODE(0x902)
#define IOCTL_WD_DMA_LOCK                           WD_CTL_CODE(0x903)
#define IOCTL_WD_DMA_UNLOCK                         WD_CTL_CODE(0x904)
#define IOCTL_WD_DMA_SYNC_CPU                       WD_CTL_CODE(0x905)
#define IOCTL_WD_DMA_SYNC_IO                        WD_CTL_CODE(0x906)
#define IOCTL_WD_DMA_TRANSACTION_INIT               WD_CTL_CODE(0x907)
#define IOCTL_WD_DMA_TRANSACTION_EXECUTE            WD_CTL_CODE(0x908)
#define IOCTL_WD_DMA_TRANSFER_COMPLETED_AND_CHECK   WD_CTL_CODE(0x909)
#define IOCTL_WD_DMA_TRANSACTION_RELEASE            WD_CTL_CODE(0x90a)
#define IOCTL_WD_TRANSFER                           WD_CTL_CODE(0x90b)
#define IOCTL_WD_MULTI_TRANSFER                     WD_CTL_CODE(0x90c)
#define IOCTL_WD_PCI_SCAN_CARDS                     WD_CTL_CODE(0x90d)
#define IOCTL_WD_PCI_GET_CARD_INFO                  WD_CTL_CODE(0x90e)
#define IOCTL_WD_PCI_SCAN_CAPS                      WD_CTL_CODE(0x90f)
#define IOCTL_WD_PCI_CONFIG_DUMP                    WD_CTL_CODE(0x910)
#define IOCTL_WD_VERSION                            WD_CTL_CODE(0x911)
#define IOCTL_WD_KERNEL_PLUGIN_OPEN                 WD_CTL_CODE(0x912)
#define IOCTL_WD_KERNEL_PLUGIN_CLOSE                WD_CTL_CODE(0x913)
#define IOCTL_WD_KERNEL_PLUGIN_CALL                 WD_CTL_CODE(0x914)
#define IOCTL_WD_INT_ENABLE                         WD_CTL_CODE(0x915)
#define IOCTL_WD_INT_DISABLE                        WD_CTL_CODE(0x916)
#define IOCTL_WD_INT_COUNT                          WD_CTL_CODE(0x917)
#define IOCTL_WD_INT_WAIT                           WD_CTL_CODE(0x918)
#define IOCTL_WD_SLEEP                              WD_CTL_CODE(0x919)
#define IOCTL_WD_DEBUG                              WD_CTL_CODE(0x91a)
#define IOCTL_WD_DEBUG_DUMP                         WD_CTL_CODE(0x91b)
#define IOCTL_WD_DEBUG_ADD                          WD_CTL_CODE(0x91c)
#define IOCTL_WD_CARD_REGISTER                      WD_CTL_CODE(0x91d)
#define IOCTL_WD_CARD_UNREGISTER                    WD_CTL_CODE(0x91e)
#define IOCTL_WD_CARD_CLEANUP_SETUP                 WD_CTL_CODE(0x91f)
#define IOCTL_WD_GET_DEVICE_PROPERTY                WD_CTL_CODE(0x920)
#define IOCTL_WD_EVENT_REGISTER                     WD_CTL_CODE(0x921)
#define IOCTL_WD_EVENT_UNREGISTER                   WD_CTL_CODE(0x922)
#define IOCTL_WD_EVENT_PULL                         WD_CTL_CODE(0x923)
#define IOCTL_WD_EVENT_SEND                         WD_CTL_CODE(0x924)
#define IOCTL_WDU_GET_DEVICE_DATA                   WD_CTL_CODE(0x925)
#define IOCTL_WDU_WAKEUP                            WD_CTL_CODE(0x926)
#define IOCTL_WDU_SET_INTERFACE                     WD_CTL_CODE(0x927)
#define IOCTL_WDU_RESET_PIPE                        WD_CTL_CODE(0x928)
#define IOCTL_WDU_TRANSFER                          WD_CTL_CODE(0x929)
#define IOCTL_WDU_HALT_TRANSFER                     WD_CTL_CODE(0x92a)
#define IOCTL_WDU_RESET_DEVICE                      WD_CTL_CODE(0x92b)
#define IOCTL_WDU_STREAM_OPEN                       WD_CTL_CODE(0x92c)
#define IOCTL_WDU_STREAM_CLOSE                      WD_CTL_CODE(0x92d)
#define IOCTL_WDU_STREAM_START                      WD_CTL_CODE(0x92e)
#define IOCTL_WDU_STREAM_STOP                       WD_CTL_CODE(0x92f)
#define IOCTL_WDU_STREAM_FLUSH                      WD_CTL_CODE(0x930)
#define IOCTL_WDU_STREAM_GET_STATUS                 WD_CTL_CODE(0x931)
#define IOCTL_WDU_SELECTIVE_SUSPEND                 WD_CTL_CODE(0x932)
#define IOCTL_WD_IPC_REGISTER                       WD_CTL_CODE(0x933)
#define IOCTL_WD_IPC_UNREGISTER                     WD_CTL_CODE(0x934)
#define IOCTL_WD_IPC_SCAN_PROCS                     WD_CTL_CODE(0x935)
#define IOCTL_WD_IPC_SEND                           WD_CTL_CODE(0x936)
#define IOCTL_WD_PCI_SRIOV_ENABLE                   WD_CTL_CODE(0x937)
#define IOCTL_WD_PCI_SRIOV_DISABLE                  WD_CTL_CODE(0x938)
#define IOCTL_WD_PCI_SRIOV_GET_NUMVFS               WD_CTL_CODE(0x939)
#define IOCTL_WD_IPC_SHARED_INT_ENABLE              WD_CTL_CODE(0x93a)
#define IOCTL_WD_IPC_SHARED_INT_DISABLE             WD_CTL_CODE(0x93b)
#define IOCTL_WD_USAGE                              WD_CTL_CODE(0x93c)
#define IOCTL_WD_LICENSE                            WD_CTL_CODE(0x93d)
#define IOCTL_WD_PCI_RESET_CARD                     WD_CTL_CODE(0x945)
#define IOCTL_WD_PLATFORM_GET_DEVICE_INFO           WD_CTL_CODE(0x946)
#define IOCTL_WD_PLATFORM_SCAN_DEVICES              WD_CTL_CODE(0x947)
 
#if defined(UNIX)
    typedef struct
    {
        DWORD dwHeader;
        DWORD dwSize;
        PVOID pData;
        PAD_TO_64(pData)
    } WD_IOCTL_HEADER;
 
    #define WD_IOCTL_HEADER_CODE 0xa410b413UL
#endif
 
#if defined(__KERNEL__)
    HANDLE __cdecl WD_Open(void);
    void __cdecl WD_Close(HANDLE hWD);
    DWORD __cdecl KP_DeviceIoControl(DWORD dwFuncNum, HANDLE h, PVOID pParam,
        DWORD dwSize);
    #define WD_FUNCTION(wFuncNum, h, pParam, dwSize, fWait) \
        KP_DeviceIoControl((DWORD)wFuncNum, h, (PVOID)pParam, (DWORD)dwSize)
#else
    #define REGKEY_BUFSIZE 256
    #define OS_CAN_NOT_DETECT_TEXT "OS CAN NOT DETECT"
    #define INSTALLATION_TYPE_NOT_DETECT_TEXT "unknown"
    typedef struct
    {
        CHAR cProdName[REGKEY_BUFSIZE];
        CHAR cInstallationType[REGKEY_BUFSIZE];
        #ifdef WIN32
            CHAR cCurrentVersion[REGKEY_BUFSIZE];
            CHAR cBuild[REGKEY_BUFSIZE];
            CHAR cCsdVersion[REGKEY_BUFSIZE];
            DWORD dwMajorVersion;
            DWORD dwMinorVersion;
        #else
            CHAR cRelease[REGKEY_BUFSIZE];
            CHAR cReleaseVersion[REGKEY_BUFSIZE];
        #endif
   } WD_OS_INFO;
 
    WD_OS_INFO DLLCALLCONV get_os_type(void);
 
    DWORD DLLCALLCONV check_secureBoot_enabled(void);
    #if defined(APPLE)
        DWORD WD_FUNCTION_LOCAL(int wFuncNum, HANDLE h,
            PVOID pParam, DWORD dwSize, BOOL fWait);
 
        HANDLE WD_OpenLocal(void);
 
        void WD_CloseLocal(HANDLE h);
 
        #define WD_OpenStreamLocal(read,sync) INVALID_HANDLE_VALUE
 
        #define WD_UStreamRead(hFile, pBuffer, dwNumberOfBytesToRead, \
            dwNumberOfBytesRead)\
            WD_NOT_IMPLEMENTED
 
        #define WD_UStreamWrite(hFile, pBuffer, dwNumberOfBytesToWrite, \
            dwNumberOfBytesWritten)\
            WD_NOT_IMPLEMENTED
 
        #if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 120000
            #define IO_MASTER_PORT IOMainPort
        #else
            #define IO_MASTER_PORT IOMasterPort
        #endif
 
    #elif defined(UNIX)
        static inline ULONG WD_FUNCTION_LOCAL(int wFuncNum, HANDLE h,
            PVOID pParam, DWORD dwSize, BOOL fWait)
        {
            WD_IOCTL_HEADER ioctl_hdr;
 
            BZERO(ioctl_hdr);
            ioctl_hdr.dwHeader = WD_IOCTL_HEADER_CODE;
            ioctl_hdr.dwSize = dwSize;
            ioctl_hdr.pData = pParam;
            (void)fWait;
            #if defined(LINUX)
                return (ULONG)ioctl((int)(long)h, wFuncNum, &ioctl_hdr);
            #endif
        }
 
            #define WD_OpenLocal()\
                ((HANDLE)(long)open(WD_DRIVER_NAME, O_RDWR | O_SYNC))
            #define WD_OpenStreamLocal(read,sync) \
                ((HANDLE)(long)open(WD_DRIVER_NAME, \
                    ((read) ? O_RDONLY : O_WRONLY) | \
                    ((sync) ? O_SYNC : O_NONBLOCK)))
 
        #define WD_CloseLocal(h) close((int)(long)(h))
 
        #define WD_UStreamRead(hFile, pBuffer, dwNumberOfBytesToRead, \
            dwNumberOfBytesRead)\
            WD_NOT_IMPLEMENTED
 
        #define WD_UStreamWrite(hFile, pBuffer, dwNumberOfBytesToWrite, \
            dwNumberOfBytesWritten)\
            WD_NOT_IMPLEMENTED
 
    #elif defined(WIN32)
        #define WD_CloseLocal(h) CloseHandle(h)
 
        #define WD_UStreamRead(hFile, pBuffer, dwNumberOfBytesToRead, \
            dwNumberOfBytesRead)\
            ReadFile(hFile, pBuffer, dwNumberOfBytesToRead, \
                dwNumberOfBytesRead, NULL) ? WD_STATUS_SUCCESS : \
                WD_OPERATION_FAILED
 
        #define WD_UStreamWrite(hFile, pBuffer, dwNumberOfBytesToWrite, \
            dwNumberOfBytesWritten)\
            WriteFile(hFile, pBuffer, dwNumberOfBytesToWrite, \
                dwNumberOfBytesWritten, NULL) ? WD_STATUS_SUCCESS : \
                WD_OPERATION_FAILED
 
        #if defined(WIN32)
            #define WD_OpenLocal()\
                CreateFileA(\
                    WD_DRIVER_NAME,\
                    GENERIC_READ,\
                    FILE_SHARE_READ | FILE_SHARE_WRITE,\
                    NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL)
 
            #define WD_OpenStreamLocal(read,sync) \
                CreateFileA(\
                    WD_DRIVER_NAME,\
                    (read) ? GENERIC_READ : GENERIC_WRITE,\
                    FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, \
                    (sync) ? 0 : FILE_FLAG_OVERLAPPED, NULL)
 
            static DWORD WD_FUNCTION_LOCAL(int wFuncNum, HANDLE h, PVOID pParam,
                DWORD dwSize, BOOL fWait)
            {
                DWORD dwTmp;
                HANDLE hWD = fWait ? WD_OpenLocal() : h;
                DWORD rc = WD_WINDRIVER_STATUS_ERROR;
 
                if (hWD == INVALID_HANDLE_VALUE)
                    return (DWORD)WD_STATUS_INVALID_WD_HANDLE;
        
                DeviceIoControl(hWD, (DWORD)wFuncNum, pParam, dwSize, &rc,
                    sizeof(DWORD), &dwTmp, NULL);
 
                if (fWait)
                    WD_CloseLocal(hWD);
 
                return rc;
            }
        #endif
    #endif
 
    #define WD_FUNCTION WD_FUNCTION_LOCAL
    #define WD_Close WD_CloseLocal
    #define WD_Open WD_OpenLocal
    #define WD_StreamOpen WD_OpenStreamLocal
    #define WD_StreamClose WD_CloseLocal
#endif
 
#define SIZE_OF_WD_DMA(pDma) \
    ((DWORD)(sizeof(WD_DMA) + ((pDma)->dwPages <= WD_DMA_PAGES ? \
        0 : ((pDma)->dwPages - WD_DMA_PAGES) * sizeof(WD_DMA_PAGE))))
#define SIZE_OF_WD_EVENT(pEvent) \
    ((DWORD)(sizeof(WD_EVENT) + ((pEvent)->dwNumMatchTables > 0 ? \
    sizeof(WDU_MATCH_TABLE) * ((pEvent)->dwNumMatchTables - 1) : 0)))
 
#define WD_Debug(h,pDebug)\
    WD_FUNCTION(IOCTL_WD_DEBUG, h, pDebug, sizeof(WD_DEBUG), FALSE)
 
#define WD_DebugDump(h,pDebugDump)\
    WD_FUNCTION(IOCTL_WD_DEBUG_DUMP, h, pDebugDump, sizeof(WD_DEBUG_DUMP), \
        FALSE)
 
#define WD_DebugAdd(h, pDebugAdd)\
    WD_FUNCTION(IOCTL_WD_DEBUG_ADD, h, pDebugAdd, sizeof(WD_DEBUG_ADD), FALSE)
 
#define WD_Transfer(h,pTransfer)\
    WD_FUNCTION(IOCTL_WD_TRANSFER, h, pTransfer, sizeof(WD_TRANSFER), FALSE)
 
#define WD_MultiTransfer(h, pTransferArray, dwNumTransfers) \
    WD_FUNCTION(IOCTL_WD_MULTI_TRANSFER, h, pTransferArray, \
        sizeof(WD_TRANSFER) * (dwNumTransfers), FALSE)
 
#define WD_KernelBufLock(h, pKerBuf)\
    WD_FUNCTION(IOCTL_WD_KERNEL_BUF_LOCK, h, pKerBuf, \
        sizeof(WD_KERNEL_BUFFER), FALSE)
 
#define WD_KernelBufUnlock(h, pKerBuf)\
    WD_FUNCTION(IOCTL_WD_KERNEL_BUF_UNLOCK, h, pKerBuf, \
        sizeof(WD_KERNEL_BUFFER), FALSE)
 
#define WD_DMALock(h,pDma)\
    WD_FUNCTION(IOCTL_WD_DMA_LOCK, h, pDma, SIZE_OF_WD_DMA(pDma), FALSE)
 
#define WD_DMAUnlock(h,pDma)\
    WD_FUNCTION(IOCTL_WD_DMA_UNLOCK, h, pDma, SIZE_OF_WD_DMA(pDma), FALSE)
 
#define WD_DMATransactionInit(h,pDma)\
    WD_FUNCTION(IOCTL_WD_DMA_TRANSACTION_INIT, h, pDma, SIZE_OF_WD_DMA(pDma), \
        FALSE)
 
#define WD_DMATransactionExecute(h,pDma)\
    WD_FUNCTION(IOCTL_WD_DMA_TRANSACTION_EXECUTE, h, pDma, \
        SIZE_OF_WD_DMA(pDma), FALSE)
 
#define WD_DMATransferCompletedAndCheck(h,pDma)\
    WD_FUNCTION(IOCTL_WD_DMA_TRANSFER_COMPLETED_AND_CHECK, h, pDma, \
        SIZE_OF_WD_DMA(pDma), FALSE)
 
#define WD_DMATransactionRelease(h,pDma)\
    WD_FUNCTION(IOCTL_WD_DMA_TRANSACTION_RELEASE, h, pDma, \
        SIZE_OF_WD_DMA(pDma), FALSE)
 
#define WD_DMATransactionUninit(h,pDma)\
    WD_FUNCTION(IOCTL_WD_DMA_UNLOCK, h, pDma, SIZE_OF_WD_DMA(pDma), FALSE)
 
#define WD_DMASyncCpu(h,pDma)\
    WD_FUNCTION(IOCTL_WD_DMA_SYNC_CPU, h, pDma, SIZE_OF_WD_DMA(pDma), FALSE)
 
#define WD_DMASyncIo(h,pDma)\
    WD_FUNCTION(IOCTL_WD_DMA_SYNC_IO, h, pDma, SIZE_OF_WD_DMA(pDma), FALSE)
 
#define WD_CardRegister(h,pCard)\
    WD_FUNCTION(IOCTL_WD_CARD_REGISTER, h, pCard, sizeof(WD_CARD_REGISTER),\
        FALSE)
 
#define WD_CardUnregister(h,pCard)\
    WD_FUNCTION(IOCTL_WD_CARD_UNREGISTER, h, pCard, sizeof(WD_CARD_REGISTER),\
        FALSE)
 
#define WD_IpcRegister(h, pIpcRegister) \
    WD_FUNCTION(IOCTL_WD_IPC_REGISTER, h, pIpcRegister, \
        sizeof(WD_IPC_REGISTER), FALSE)
 
#define WD_IpcUnRegister(h, pProcInfo) \
    WD_FUNCTION(IOCTL_WD_IPC_UNREGISTER, h, pProcInfo, sizeof(WD_IPC_PROCESS), \
        FALSE)
 
#define WD_IpcScanProcs(h, pIpcScanProcs) \
    WD_FUNCTION(IOCTL_WD_IPC_SCAN_PROCS, h, pIpcScanProcs, \
        sizeof(WD_IPC_SCAN_PROCS), FALSE)
 
#define WD_IpcSend(h, pIpcSend) \
    WD_FUNCTION(IOCTL_WD_IPC_SEND, h, pIpcSend, sizeof(WD_IPC_SEND), FALSE)
 
#define WD_SharedIntEnable(h, pIpcRegister) \
    WD_FUNCTION(IOCTL_WD_IPC_SHARED_INT_ENABLE, h, pIpcRegister, \
        sizeof(WD_IPC_REGISTER), FALSE)
 
#define WD_SharedIntDisable(h) \
    WD_FUNCTION(IOCTL_WD_IPC_SHARED_INT_DISABLE, h, 0, 0, FALSE)
 
#define WD_PciSriovEnable(h,pPciSRIOV) \
    WD_FUNCTION(IOCTL_WD_PCI_SRIOV_ENABLE, h, pPciSRIOV, \
        sizeof(WD_PCI_SRIOV), FALSE)
 
#define WD_PciSriovDisable(h,pPciSRIOV) \
    WD_FUNCTION(IOCTL_WD_PCI_SRIOV_DISABLE, h, pPciSRIOV, \
        sizeof(WD_PCI_SRIOV), FALSE)
 
#define WD_PciSriovGetNumVFs(h,pPciSRIOV) \
    WD_FUNCTION(IOCTL_WD_PCI_SRIOV_GET_NUMVFS, h, pPciSRIOV, \
        sizeof(WD_PCI_SRIOV), FALSE)
 
#define WD_CardCleanupSetup(h,pCardCleanup)\
    WD_FUNCTION(IOCTL_WD_CARD_CLEANUP_SETUP, h, pCardCleanup, \
        sizeof(WD_CARD_CLEANUP), FALSE)
 
#define WD_PciScanCards(h,pPciScan)\
    WD_FUNCTION(IOCTL_WD_PCI_SCAN_CARDS, h, pPciScan,\
        sizeof(WD_PCI_SCAN_CARDS), FALSE)
 
#define WD_PciScanCaps(h,pPciScanCaps) \
    WD_FUNCTION(IOCTL_WD_PCI_SCAN_CAPS, h, pPciScanCaps, \
        sizeof(WD_PCI_SCAN_CAPS), FALSE)
 
#define WD_PciGetCardInfo(h,pPciCard)\
    WD_FUNCTION(IOCTL_WD_PCI_GET_CARD_INFO, h, pPciCard, \
        sizeof(WD_PCI_CARD_INFO), FALSE)
 
#define WD_PciConfigDump(h,pPciConfigDump)\
    WD_FUNCTION(IOCTL_WD_PCI_CONFIG_DUMP, h, pPciConfigDump, \
        sizeof(WD_PCI_CONFIG_DUMP), FALSE)
 
#define WD_PciResetCard(h,pPciSlot)\
    WD_FUNCTION(IOCTL_WD_PCI_RESET_CARD, h, pPciSlot, sizeof(WD_PCI_SLOT), \
        FALSE)
 
#if defined(LINUX)
#define WD_PlatformGetCardInfo(h,pCard)\
    WD_FUNCTION(IOCTL_WD_PLATFORM_GET_DEVICE_INFO, h, pCard, \
        sizeof(WD_PLATFORM_CARD_INFO), FALSE)
 
#define WD_PlatformScanDevices(h,pPlatformScan)\
    WD_FUNCTION(IOCTL_WD_PLATFORM_SCAN_DEVICES, h, pPlatformScan, \
        sizeof(WD_PLATFORM_SCAN_DEVICES), FALSE)
#endif /* defined(LINUX) */
 
#define WD_Version(h,pVerInfo)\
    WD_FUNCTION(IOCTL_WD_VERSION, h, pVerInfo, sizeof(WD_VERSION), FALSE)
 
#define WD_License(h,pLicense)\
    WD_FUNCTION(IOCTL_WD_LICENSE, h, pLicense, sizeof(WD_LICENSE), FALSE)
 
#define WD_KernelPlugInOpen(h,pKernelPlugIn)\
    WD_FUNCTION(IOCTL_WD_KERNEL_PLUGIN_OPEN, h, pKernelPlugIn, \
        sizeof(WD_KERNEL_PLUGIN), FALSE)
 
#define WD_KernelPlugInClose(h,pKernelPlugIn)\
    WD_FUNCTION(IOCTL_WD_KERNEL_PLUGIN_CLOSE, h, pKernelPlugIn, \
        sizeof(WD_KERNEL_PLUGIN), FALSE)
 
#define WD_KernelPlugInCall(h,pKernelPlugInCall)\
    WD_FUNCTION(IOCTL_WD_KERNEL_PLUGIN_CALL, h, pKernelPlugInCall, \
        sizeof(WD_KERNEL_PLUGIN_CALL), FALSE)
 
#define WD_IntEnable(h,pInterrupt)\
    WD_FUNCTION(IOCTL_WD_INT_ENABLE, h, pInterrupt, sizeof(WD_INTERRUPT), FALSE)
 
#define WD_IntDisable(h,pInterrupt)\
    WD_FUNCTION(IOCTL_WD_INT_DISABLE, h, pInterrupt, sizeof(WD_INTERRUPT), \
        FALSE)
 
#define WD_IntCount(h,pInterrupt)\
    WD_FUNCTION(IOCTL_WD_INT_COUNT, h, pInterrupt, sizeof(WD_INTERRUPT), FALSE)
 
#define WD_IntWait(h,pInterrupt)\
    WD_FUNCTION(IOCTL_WD_INT_WAIT, h, pInterrupt, sizeof(WD_INTERRUPT), TRUE)
 
#define WD_Sleep(h,pSleep)\
    WD_FUNCTION(IOCTL_WD_SLEEP, h, pSleep, sizeof(WD_SLEEP), FALSE)
 
 
#define WD_EventRegister(h, pEvent) \
    WD_FUNCTION(IOCTL_WD_EVENT_REGISTER, h, pEvent, SIZE_OF_WD_EVENT(pEvent), \
        FALSE)
#define WD_EventUnregister(h, pEvent) \
    WD_FUNCTION(IOCTL_WD_EVENT_UNREGISTER, h, pEvent, \
        SIZE_OF_WD_EVENT(pEvent), FALSE)
#define WD_EventPull(h,pEvent) \
    WD_FUNCTION(IOCTL_WD_EVENT_PULL, h, pEvent, SIZE_OF_WD_EVENT(pEvent), FALSE)
#define WD_EventSend(h,pEvent) \
    WD_FUNCTION(IOCTL_WD_EVENT_SEND, h, pEvent, SIZE_OF_WD_EVENT(pEvent), FALSE)
#define WD_Usage(h, pStop) \
    WD_FUNCTION(IOCTL_WD_USAGE, h, pStop, sizeof(WD_USAGE), FALSE)
 
#define WD_UGetDeviceData(h, pGetDevData) \
    WD_FUNCTION(IOCTL_WDU_GET_DEVICE_DATA, h, pGetDevData, \
        sizeof(WDU_GET_DEVICE_DATA), FALSE);
#define WD_GetDeviceProperty(h, pGetDevProperty) \
    WD_FUNCTION(IOCTL_WD_GET_DEVICE_PROPERTY, h, pGetDevProperty, \
        sizeof(WD_GET_DEVICE_PROPERTY), FALSE);
#define WD_USetInterface(h, pSetIfc) \
    WD_FUNCTION(IOCTL_WDU_SET_INTERFACE, h, pSetIfc, \
        sizeof(WDU_SET_INTERFACE), FALSE);
#define WD_UResetPipe(h, pResetPipe) \
    WD_FUNCTION(IOCTL_WDU_RESET_PIPE, h, pResetPipe, sizeof(WDU_RESET_PIPE), \
        FALSE);
#define WD_UTransfer(h, pTrans) \
    WD_FUNCTION(IOCTL_WDU_TRANSFER, h, pTrans, sizeof(WDU_TRANSFER), TRUE);
#define WD_UHaltTransfer(h, pHaltTrans) \
    WD_FUNCTION(IOCTL_WDU_HALT_TRANSFER, h, pHaltTrans, \
        sizeof(WDU_HALT_TRANSFER), FALSE);
#define WD_UWakeup(h, pWakeup) \
    WD_FUNCTION(IOCTL_WDU_WAKEUP, h, pWakeup, sizeof(WDU_WAKEUP), FALSE);
#define WD_USelectiveSuspend(h, pSelectiveSuspend) \
    WD_FUNCTION(IOCTL_WDU_SELECTIVE_SUSPEND, h, pSelectiveSuspend, \
        sizeof(WDU_SELECTIVE_SUSPEND), FALSE);
#define WD_UResetDevice(h, pResetDevice) \
    WD_FUNCTION(IOCTL_WDU_RESET_DEVICE, h, pResetDevice, \
        sizeof(WDU_RESET_DEVICE), FALSE);
#define WD_UStreamOpen(h, pStream) \
    WD_FUNCTION(IOCTL_WDU_STREAM_OPEN, h, pStream, sizeof(WDU_STREAM), FALSE);
#define WD_UStreamClose(h, pStream) \
    WD_FUNCTION(IOCTL_WDU_STREAM_CLOSE, h, pStream, sizeof(WDU_STREAM), FALSE);
#define WD_UStreamStart(h, pStream) \
    WD_FUNCTION(IOCTL_WDU_STREAM_START, h, pStream, sizeof(WDU_STREAM), FALSE);
#define WD_UStreamStop(h, pStream) \
    WD_FUNCTION(IOCTL_WDU_STREAM_STOP, h, pStream, sizeof(WDU_STREAM), FALSE);
#define WD_UStreamFlush(h, pStream) \
    WD_FUNCTION(IOCTL_WDU_STREAM_FLUSH, h, pStream, sizeof(WDU_STREAM), FALSE);
#define WD_UStreamGetStatus(h, pStreamStatus) \
    WD_FUNCTION(IOCTL_WDU_STREAM_GET_STATUS, h, pStreamStatus, \
        sizeof(WDU_STREAM_STATUS), FALSE);
 
#define __ALIGN_DOWN(val,alignment) ( (val) & ~((alignment) - 1) )
#define __ALIGN_UP(val,alignment) \
    ( ((val) + (alignment) - 1) & ~((alignment) - 1) )
 
#ifdef WDLOG
    #include "wd_log.h"
#endif
 
#ifndef MIN
    #define MIN(a,b) ((a) > (b) ? (b) : (a))
#endif
#ifndef MAX
    #define MAX(a,b) ((a) > (b) ? (a) : (b))
#endif
#define SAFE_STRING(s) ((s) ? (s) : "")
 
#define UNUSED_VAR(x) (void)x
 
#ifdef __cplusplus
}
#endif
 
#endif /* _WINDRVR_H_ */