S_MISC = 0x100,
    S_LICENSE = 0x200,
    S_ISAPNP = 0x400,
    S_PCMCIA = 0x800,
    S_KER_PLUG = 0x10000,
    S_CARD_REG = 0x2000,
    S_KER_DRV = 0x4000,
    S_USB = 0x8000,
} 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
} DEBUG_COMMAND;

typedef struct 
{
    DWORD dwCmd;     // DEBUG_COMMAND: DEBUG_STATUS, DEBUG_SET_FILTER, DEBUG_SET_BUFFER, DEBUG_CLEAR_BUFFER
    // used for DEBUG_SET_FILTER
    DWORD dwLevel;   // DEBUG_LEVEL: D_ERROR, D_WARN..., or D_OFF to turn debugging off
    DWORD dwSection; // DEBUG_SECTION: for all sections in driver: S_ALL
                     // for partial sections: S_IO, S_MEM...
    DWORD dwLevelMessageBox; // DEBUG_LEVEL to print in a message box
    // used for DEBUG_SET_BUFFER
    DWORD dwBufferSize; // size of buffer in kernel
} WD_DEBUG;

typedef struct 
{
    PCHAR pcBuffer;  // buffer to receive debug messages
    DWORD dwSize;    // size of buffer in bytes
} WD_DEBUG_DUMP;

typedef struct 
{
    DWORD hKernelPlugIn;
    PCHAR pcDriverName;
    PCHAR pcDriverPath; // if NULL the driver will be searched in the windows system directory 
    PVOID pOpenData;
} WD_KERNEL_PLUGIN;

#define WD_KERNEL_DRIVER_PLUGIN_HANDLE 0xffff0000

static DWORD WinDriverGlobalDW;

#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    // file & pipe
    #define FILE_WRITE_ACCESS 2    // file & pipe
#endif

// Device type 
#define WD_TYPE 38200

#define WD_CTL_CODE(wFuncNum) ((DWORD) CTL_CODE( WD_TYPE, wFuncNum, METHOD_NEITHER, FILE_ANY_ACCESS))

// WinDriver function IOCTL calls.  For details on the WinDriver functions,
// see the WinDriver manual or included help files.

#define IOCTL_WD_DMA_LOCK             WD_CTL_CODE(0x901)
#define IOCTL_WD_DMA_UNLOCK           WD_CTL_CODE(0x902)
#define IOCTL_WD_TRANSFER             WD_CTL_CODE(0x903)
#define IOCTL_WD_MULTI_TRANSFER       WD_CTL_CODE(0x904)
#define IOCTL_WD_INT_ENABLE_V30       WD_CTL_CODE(0x907)
#define IOCTL_WD_INT_DISABLE_V30      WD_CTL_CODE(0x908)
#define IOCTL_WD_INT_COUNT_V30        WD_CTL_CODE(0x909)
#define IOCTL_WD_INT_WAIT_V30         WD_CTL_CODE(0x90a)
#define IOCTL_WD_CARD_REGISTER_V30    WD_CTL_CODE(0x90c)
#define IOCTL_WD_CARD_UNREGISTER_V30  WD_CTL_CODE(0x90d)
#define IOCTL_WD_PCI_SCAN_CARDS       WD_CTL_CODE(0x90e)
#define IOCTL_WD_PCI_GET_CARD_INFO    WD_CTL_CODE(0x90f)
#define IOCTL_WD_VERSION              WD_CTL_CODE(0x910)
#define IOCTL_WD_DEBUG_V30            WD_CTL_CODE(0x911)
#define IOCTL_WD_LICENSE              WD_CTL_CODE(0x912)
#define IOCTL_WD_PCI_CONFIG_DUMP      WD_CTL_CODE(0x91a)
#define IOCTL_WD_KERNEL_PLUGIN_OPEN   WD_CTL_CODE(0x91b)
#define IOCTL_WD_KERNEL_PLUGIN_CLOSE  WD_CTL_CODE(0x91c)
#define IOCTL_WD_KERNEL_PLUGIN_CALL   WD_CTL_CODE(0x91d)
#define IOCTL_WD_INT_ENABLE           WD_CTL_CODE(0x91e)
#define IOCTL_WD_INT_DISABLE          WD_CTL_CODE(0x91f)
#define IOCTL_WD_INT_COUNT            WD_CTL_CODE(0x920)
#define IOCTL_WD_INT_WAIT_V42         WD_CTL_CODE(0x921)
#define IOCTL_WD_ISAPNP_SCAN_CARDS    WD_CTL_CODE(0x924)
#define IOCTL_WD_ISAPNP_GET_CARD_INFO_V40 WD_CTL_CODE(0x925)
#define IOCTL_WD_ISAPNP_CONFIG_DUMP   WD_CTL_CODE(0x926)
#define IOCTL_WD_SLEEP                WD_CTL_CODE(0x927)
#define IOCTL_WD_DEBUG                WD_CTL_CODE(0x928)
#define IOCTL_WD_DEBUG_DUMP           WD_CTL_CODE(0x929)
#define IOCTL_WD_CARD_REGISTER_V40    WD_CTL_CODE(0x92a)
#define IOCTL_WD_CARD_UNREGISTER      WD_CTL_CODE(0x92b)
#define IOCTL_WD_CARD_REGISTER_V41    WD_CTL_CODE(0x92c)
#define IOCTL_WD_ISAPNP_GET_CARD_INFO WD_CTL_CODE(0x92d)
#define IOCTL_WD_PCMCIA_SCAN_CARDS    WD_CTL_CODE(0x92f)
#define IOCTL_WD_PCMCIA_GET_CARD_INFO WD_CTL_CODE(0x930)
#define IOCTL_WD_PCMCIA_CONFIG_DUMP   WD_CTL_CODE(0x931)
#define IOCTL_WD_CARD_REGISTER_V42    WD_CTL_CODE(0x939)
#define IOCTL_WD_CARD_REGISTER        WD_CTL_CODE(0x948)
#define IOCTL_WD_INT_WAIT             WD_CTL_CODE(0x94b)

#if defined(UNIX)
    typedef struct { DWORD dwHeader; PVOID pData; DWORD dwSize; } WD_IOCTL_HEADER;
    enum { WD_IOCTL_HEADER_CODE = 0xa410b413 };
#endif

#if defined(__KERNEL__)
    HANDLE __cdecl WD_Open();
    void __cdecl WD_Close(HANDLE hWD);
    ULONG __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
    #if defined(UNIX)
        static inline ULONG WD_FUNCTION( DWORD wFuncNum, HANDLE h,
                PVOID pParam, DWORD dwSize, BOOL fWait)
        {
            WD_IOCTL_HEADER ioctl_hdr;
            ioctl_hdr.dwHeader = WD_IOCTL_HEADER_CODE;
            ioctl_hdr.pData = pParam;
            ioctl_hdr.dwSize = dwSize;
            #if defined(VXWORKS)
                return (ULONG) ioctl((int)(h), wFuncNum, (int)&ioctl_hdr);
            #elif defined(LINUX) || defined(SOLARIS)
                return (ULONG) ioctl((int)(h), wFuncNum, &ioctl_hdr);
            #endif
        }
        #if defined(VXWORKS)
            #define WINDRIVER_DEV "/windrvr"
        #else
            #define WINDRIVER_DEV "/dev/windrvr"
        #endif /* VXWORKS */
        
        #if defined(VXWORKS)
            #define WD_Open()\
                ((HANDLE) open(WINDRIVER_DEV, O_RDWR, 0644))
        #else
            #define WD_Open()\
                ((HANDLE)open( WINDRIVER_DEV, O_RDWR))
        #endif /* VXWORKS */
            
        #define WD_Close(h)\
            close((int) (h))
    
    #elif defined(WINCE) && defined(_WIN32_WCE_EMULATION)
        HANDLE WINAPI WCE_EMU_WD_Open();
        void WINAPI WCE_EMU_WD_Close(HANDLE hWD);
        BOOL WINAPI WCE_EMU_WD_FUNCTION(DWORD wFuncNum, HANDLE h, PVOID pParam, DWORD dwSize);
        #define WD_Open() WCE_EMU_WD_Open()
        #define WD_Close(h) WCE_EMU_WD_Close(h)
        #define WD_FUNCTION(wFuncNum, h, pParam, dwSize, fWait) WCE_EMU_WD_FUNCTION(wFuncNum, h, pParam, dwSize)
    #elif defined(WIN32) || defined(WINCE)
        #define WD_Close(h)\
            CloseHandle(h)
        #if defined(WINCE)
            void WINAPI SetProcPermissions(DWORD dwPermissions);
            #define WD_Open()\
                (SetProcPermissions(0xFFFF), CreateFile(\
                    TEXT("WDR1:"),\
                    GENERIC_READ,\
                    FILE_SHARE_READ | FILE_SHARE_WRITE,\
                    NULL, OPEN_EXISTING, 0, NULL))
            #define WD_FUNCTION(wFuncNum, h, pParam, dwSize, fWait)\
                ((DWORD) DeviceIoControl(h, wFuncNum, pParam, dwSize, NULL, 0,\
                    &WinDriverGlobalDW, NULL))
        #elif defined(WIN32)
            #define WD_Open()\
                CreateFile(\
                    TEXT("\\\\.\\WINDRVR"),\
                    GENERIC_READ,\
                    FILE_SHARE_READ | FILE_SHARE_WRITE,\
                    NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL)  
            static DWORD WD_FUNCTION(DWORD wFuncNum, HANDLE h,
                PVOID pParam, DWORD dwSize, BOOL fWait)
            {
                HANDLE hWD = fWait ? WD_Open() : h;
                DWORD rc;
                if (hWD==INVALID_HANDLE_VALUE)
                    return (DWORD) -1;
                rc = (DWORD) DeviceIoControl(hWD, (DWORD) wFuncNum, (PVOID) pParam,
                    (DWORD) dwSize, NULL, 0, &WinDriverGlobalDW, NULL);
                if (fWait)
                    WD_Close(hWD);
                return rc;
            }
        #endif
    #endif
#endif

#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_DebugV30(h,Debug)\
    WD_FUNCTION(IOCTL_WD_DEBUG_V30, h, NULL, Debug, 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_DMALock(h,pDma)\
    WD_FUNCTION(IOCTL_WD_DMA_LOCK, h, pDma, sizeof (WD_DMA), FALSE)
#define WD_DMAUnlock(h,pDma)\
    WD_FUNCTION(IOCTL_WD_DMA_UNLOCK, h, pDma, sizeof (WD_DMA), FALSE)
#define WD_IntEnableV30(h,pInterrupt)\
    WD_FUNCTION(IOCTL_WD_INT_ENABLE_V30, h, pInterrupt, sizeof (WD_INTERRUPT_V30), FALSE)
#define WD_IntDisableV30(h,pInterrupt)\
    WD_FUNCTION(IOCTL_WD_INT_DISABLE_V30, h, pInterrupt, sizeof (WD_INTERRUPT_V30), FALSE)
#define WD_IntCountV30(h,pInterrupt)\
    WD_FUNCTION(IOCTL_WD_INT_COUNT_V30, h, pInterrupt, sizeof (WD_INTERRUPT_V30), FALSE)
#define WD_IntWaitV30(h,pInterrupt)\
    WD_FUNCTION(IOCTL_WD_INT_WAIT_V30, h, pInterrupt, sizeof (WD_INTERRUPT_V30), FALSE)
#define WD_CardRegisterV30(h,pCard)\
    WD_FUNCTION(IOCTL_WD_CARD_REGISTER_V30, h, pCard, sizeof (WD_CARD_REGISTER_V30), FALSE)
#define WD_CardUnregisterV30(h,pCard)\
    WD_FUNCTION(IOCTL_WD_CARD_UNREGISTER_V30, h, pCard, sizeof (WD_CARD_REGISTER_V30), FALSE)
#define WD_CardRegisterV40(h,pCard)\
    WD_FUNCTION(IOCTL_WD_CARD_REGISTER_V40, h, pCard, sizeof (WD_CARD_REGISTER), FALSE)
#define WD_CardRegisterV41(h,pCard)\
    WD_FUNCTION(IOCTL_WD_CARD_REGISTER_V41, h, pCard, sizeof (WD_CARD_REGISTER), FALSE)
#define WD_CardRegisterV42(h,pCard)\
    WD_FUNCTION(IOCTL_WD_CARD_REGISTER_V42, h, pCard, sizeof (WD_CARD_REGISTER), 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_PciScanCards(h,pPciScan)\
    WD_FUNCTION(IOCTL_WD_PCI_SCAN_CARDS, h, pPciScan, sizeof (WD_PCI_SCAN_CARDS), 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_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_V42(h,pInterrupt)\
    WD_FUNCTION(IOCTL_WD_INT_WAIT, 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_IsapnpScanCards(h,pIsapnpScan)\
    WD_FUNCTION(IOCTL_WD_ISAPNP_SCAN_CARDS, h, pIsapnpScan, sizeof (WD_ISAPNP_SCAN_CARDS), FALSE)
#define WD_IsapnpGetCardInfo(h,pIsapnpCard)\
    WD_FUNCTION(IOCTL_WD_ISAPNP_GET_CARD_INFO, h, pIsapnpCard, sizeof (WD_ISAPNP_CARD_INFO), FALSE)
#define WD_IsapnpConfigDump(h,pIsapnpConfigDump)\
    WD_FUNCTION(IOCTL_WD_ISAPNP_CONFIG_DUMP, h, pIsapnpConfigDump, sizeof (WD_ISAPNP_CONFIG_DUMP), FALSE)
#define WD_PcmciaScanCards(h,pPcmciaScan)\
    WD_FUNCTION(IOCTL_WD_PCMCIA_SCAN_CARDS, h, pPcmciaScan, sizeof (WD_PCMCIA_SCAN_CARDS), FALSE)
#define WD_PcmciaGetCardInfo(h,pPcmciaCard)\
    WD_FUNCTION(IOCTL_WD_PCMCIA_GET_CARD_INFO, h, pPcmciaCard, sizeof (WD_PCMCIA_CARD_INFO), FALSE)
#define WD_PcmciaConfigDump(h,pPcmciaConfigDump)\
    WD_FUNCTION(IOCTL_WD_PCMCIA_CONFIG_DUMP, h, pPcmciaConfigDump, sizeof (WD_PCMCIA_CONFIG_DUMP), FALSE)
#define WD_Sleep(h,pSleep)\
    WD_FUNCTION(IOCTL_WD_SLEEP, h, pSleep, sizeof (WD_SLEEP), FALSE)

#ifdef __cplusplus
}
#endif

#include "windrvr_usb.h"

#endif