#include "wd_ver.h"
#include <windows.h>
#include <winioctl.h>
#include <stdarg.h>
#include <inttypes.h>
#include "windrvr_usb.h"

Go to the source code of this file.

Data Structures
struct	WD_DMA_PAGE

struct	WD_DMA

struct	WD_KERNEL_BUFFER

struct	WD_TRANSFER

struct	WD_KERNEL_PLUGIN_CALL

struct	WD_INTERRUPT

struct	WD_VERSION

struct	WD_LICENSE

struct	WD_BUS

struct	WD_ITEMS

union	WD_ITEMS::I

struct	WD_ITEMS::I::Mem
	ITEM_MEMORY. More...

struct	WD_ITEMS::I::IO
	ITEM_IO. More...

struct	WD_ITEMS::I::Int
	ITEM_INTERRUPT. More...

struct	WD_CARD

struct	WD_CARD_REGISTER

struct	WD_IPC_PROCESS

struct	WD_IPC_REGISTER

struct	WD_IPC_SCAN_PROCS

struct	WD_IPC_SEND

struct	WD_CARD_CLEANUP

struct	WD_PCI_SLOT

struct	WD_PCI_ID

struct	WD_PCI_SCAN_CARDS

struct	WD_PLATFORM_SCAN_DEVICES

struct	WD_PCI_CAP

struct	WD_PCI_SCAN_CAPS

struct	WD_PCI_SRIOV

struct	WD_PCI_CARD_INFO

struct	WD_PLATFORM_CARD_INFO

struct	WD_PCI_CONFIG_DUMP

struct	WD_SLEEP

struct	WD_DEBUG

struct	WD_DEBUG_DUMP

struct	WD_DEBUG_ADD

struct	WD_KERNEL_PLUGIN

struct	WD_GET_DEVICE_PROPERTY

struct	WD_EVENT

union	WD_EVENT::u

struct	WD_EVENT::u::Pci

struct	WD_EVENT::u::Usb

struct	WD_EVENT::u::Ipc

struct	WD_USAGE

struct	WD_OS_INFO

Macros
#define	DLLCALLCONV

#define	_In_

#define	_Inout_

#define	_Out_

#define	_Outptr_

#define	WD_DRIVER_NAME_PREFIX ""

#define	__FUNCTION__ __func__

#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

#define	WD_DRIVER_NAME WD_DriverName(NULL)
	Get driver name.

#define	WD_PROD_NAME "WinDriver"

#define	WD_CPU_SPEC " X86"

#define	WD_DATA_MODEL " 32bit"

#define	WD_VER_STR_SUFFIX ""

#define	WD_VER_STR

#define	WIN32

#define	stricmp _stricmp

#define	va_copy(ap2, ap1) (ap2)=(ap1)

#define	WINAPI

#define	PRI64 "I64"
	formatting for printing a 64bit variable

#define	KPRI ""
	formatting for printing a kernel pointer

#define	UPRI "l"

#define	DMA_BIT_MASK(n) (((n) == 64) ? ~0ULL : ((1ULL<<(n))-1))

#define	DMA_ADDRESS_WIDTH_MASK 0x7f000000

#define	DMA_OPTIONS_ALL

#define	DMA_DIRECTION_MASK DMA_TO_FROM_DEVICE

#define	DMA_READ_FROM_DEVICE DMA_FROM_DEVICE
	Macros for backward compatibility.

#define	DMA_WRITE_TO_DEVICE DMA_TO_DEVICE

#define	DMA_OPTIONS_ADDRESS_WIDTH_SHIFT

#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

#define	WD_LICENSE_LENGTH 3072

#define	WD_PROCESS_NAME_LENGTH 128

#define	DEBUG_USER_BUF_LEN 2048

#define	WD_IPC_ALL_MSG (WD_IPC_UNICAST_MSG \| WD_IPC_MULTICAST_MSG)

#define	WDU_USE_SHARED_OBJECT_HANDLE 0x1000000

#define	WDU_DONT_INSERT_LICENSE 0x2000000

#define	WD_ACTIONS_POWER

#define	WD_ACTIONS_ALL (WD_ACTIONS_POWER \| WD_INSERT \| WD_REMOVE)

#define	BZERO(buf) memset(&(buf), 0, sizeof(buf))

#define	INVALID_HANDLE_VALUE ((HANDLE)(-1))

#define	CTL_CODE(DeviceType, Function, Method, Access)

#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

#define	WD_TYPE 38200
	Device type.

#define	FUNC_MASK 0x0

#define	WD_CTL_CODE(wFuncNum)

#define	WD_CTL_DECODE_FUNC(IoControlCode) ((IoControlCode >> 2) & 0xfff)

#define	WD_CTL_DECODE_TYPE(IoControlCode) DEVICE_TYPE_FROM_CTL_CODE(IoControlCode)

#define	WD_CTL_IS_64BIT_AWARE(IoControlCode) (WD_CTL_DECODE_FUNC(IoControlCode) & FUNC_MASK)

#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)

#define	REGKEY_BUFSIZE 256

#define	OS_CAN_NOT_DETECT_TEXT "OS CAN NOT DETECT"

#define	INSTALLATION_TYPE_NOT_DETECT_TEXT "unknown"

#define	WD_CloseLocal(h) CloseHandle(h)

#define	WD_UStreamRead(hFile, pBuffer, dwNumberOfBytesToRead, dwNumberOfBytesRead)

#define	WD_UStreamWrite(hFile, pBuffer, dwNumberOfBytesToWrite, dwNumberOfBytesWritten)

#define	WD_OpenLocal()

#define	WD_OpenStreamLocal(read, sync)

#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

#define	SIZE_OF_WD_DMA(pDma)

#define	SIZE_OF_WD_EVENT(pEvent)

#define	WD_Debug(h, pDebug) WD_FUNCTION(IOCTL_WD_DEBUG, h, pDebug, sizeof(WD_DEBUG), FALSE)
	Sets debugging level for collecting debug messages.

#define	WD_DebugDump(h, pDebugDump)
	Retrieves debug messages buffer.

#define	WD_DebugAdd(h, pDebugAdd) WD_FUNCTION(IOCTL_WD_DEBUG_ADD, h, pDebugAdd, sizeof(WD_DEBUG_ADD), FALSE)
	Sends debug messages to the debug log.

#define	WD_Transfer(h, pTransfer) WD_FUNCTION(IOCTL_WD_TRANSFER, h, pTransfer, sizeof(WD_TRANSFER), FALSE)
	Executes a single read/write instruction to an I/O port or to a memory address.

#define	WD_MultiTransfer(h, pTransferArray, dwNumTransfers)
	Executes multiple read/write instructions to I/O ports and/or memory addresses.

#define	WD_KernelBufLock(h, pKerBuf)
	Allocates a contiguous or non-contiguous non-paged kernel buffer, and maps it to user address space.

#define	WD_KernelBufUnlock(h, pKerBuf)
	Frees kernel buffer.

#define	WD_DMALock(h, pDma) WD_FUNCTION(IOCTL_WD_DMA_LOCK, h, pDma, SIZE_OF_WD_DMA(pDma), FALSE)
	Enables contiguous-buffer or Scatter/Gather DMA.

#define	WD_DMAUnlock(h, pDma) WD_FUNCTION(IOCTL_WD_DMA_UNLOCK, h, pDma, SIZE_OF_WD_DMA(pDma), FALSE)
	Unlocks a DMA buffer.

#define	WD_DMATransactionInit(h, pDma)
	Initializes the transaction, allocates a DMA buffer, locks it in physical memory, and returns mappings of the allocated buffer to physical address space and to user-mode and kernel virtual address spaces.

#define	WD_DMATransactionExecute(h, pDma)
	Begins the execution of a specified DMA transaction.

#define	WD_DMATransferCompletedAndCheck(h, pDma)
	Notifies WinDriver that a device's DMA transfer operation is completed.

#define	WD_DMATransactionRelease(h, pDma)
	Terminates a specified DMA transaction without deleting the associated WD_DMA transaction structure.

#define	WD_DMATransactionUninit(h, pDma) WD_FUNCTION(IOCTL_WD_DMA_UNLOCK, h, pDma, SIZE_OF_WD_DMA(pDma), FALSE)
	Unlocks and frees the memory allocated for a DMA buffer transaction by a previous call to WD_DMATransactionInit()

#define	WD_DMASyncCpu(h, pDma) WD_FUNCTION(IOCTL_WD_DMA_SYNC_CPU, h, pDma, SIZE_OF_WD_DMA(pDma), FALSE)
	Synchronizes the cache of all CPUs with the DMA buffer, by flushing the data from the CPU caches.

#define	WD_DMASyncIo(h, pDma) WD_FUNCTION(IOCTL_WD_DMA_SYNC_IO, h, pDma, SIZE_OF_WD_DMA(pDma), FALSE)
	Synchronizes the I/O caches with the DMA buffer, by flushing the data from the I/O caches and updating the CPU caches.

#define	WD_CardRegister(h, pCard)
	Card registration function.

#define	WD_CardUnregister(h, pCard)
	Unregisters a device and frees the resources allocated to it.

#define	WD_IpcRegister(h, pIpcRegister)
	Registers an application with WinDriver IPC.

#define	WD_IpcUnRegister(h, pProcInfo)
	This function unregisters the user application from WinDriver IPC.

#define	WD_IpcScanProcs(h, pIpcScanProcs)
	Scans and returns information of all WinDriver IPC registered processes that share the application process groupID.

#define	WD_IpcSend(h, pIpcSend) WD_FUNCTION(IOCTL_WD_IPC_SEND, h, pIpcSend, sizeof(WD_IPC_SEND), FALSE)
	Sends a message to other processes, depending on the content of the pIpcSend struct.

#define	WD_SharedIntEnable(h, pIpcRegister)
	Enables the shared interrupts mechanism of WinDriver.

#define	WD_SharedIntDisable(h) WD_FUNCTION(IOCTL_WD_IPC_SHARED_INT_DISABLE, h, 0, 0, FALSE)
	Disables the Shared Interrupts mechanism of WinDriver for all processes.

#define	WD_PciSriovEnable(h, pPciSRIOV)
	Enables SR-IOV for a supported device.

#define	WD_PciSriovDisable(h, pPciSRIOV)
	Disables SR-IOV for a supported device and removes all the assigned VFs.

#define	WD_PciSriovGetNumVFs(h, pPciSRIOV)
	Gets the number of virtual functions assigned to a supported device.

#define	WD_CardCleanupSetup(h, pCardCleanup)
	Sets a list of transfer cleanup commands to be performed for the specified card on any of the following occasions: The application exits abnormally.

#define	WD_PciScanCards(h, pPciScan)
	Detects PCI devices installed on the PCI bus, which conform to the input criteria (vendor ID and/or card ID), and returns the number and location (bus, slot and function) of the detected devices.

#define	WD_PciScanCaps(h, pPciScanCaps)
	Scans the specified PCI capabilities group of the given PCI slot for the specified capability (or for all capabilities).

#define	WD_PciGetCardInfo(h, pPciCard)
	Retrieves PCI device's resource information (i.e., Memory ranges, I/O ranges, Interrupt lines).

#define	WD_PciConfigDump(h, pPciConfigDump)
	Reads/writes from/to the PCI configuration space of a selected PCI card or the extended configuration space of a selected PCI Express card.

#define	WD_PciResetCard(h, pPciSlot)
	Reset the PCI function without affecting other functions on the device.

#define	WD_Version(h, pVerInfo) WD_FUNCTION(IOCTL_WD_VERSION, h, pVerInfo, sizeof(WD_VERSION), FALSE)
	Returns the version number of the WinDriver kernel module currently running.

#define	WD_License(h, pLicense) WD_FUNCTION(IOCTL_WD_LICENSE, h, pLicense, sizeof(WD_LICENSE), FALSE)
	Transfers the license string to the WinDriver kernel module When using the high-level WDC library APIs, described in the WinDriver PCI Manual, the license registration is done via the WDC_DriverOpen() function, so you do not need to call WD_License() directly.

#define	WD_KernelPlugInOpen(h, pKernelPlugIn)
	Obtain a valid handle to the Kernel PlugIn.

#define	WD_KernelPlugInClose(h, pKernelPlugIn)
	Closes the WinDriver Kernel PlugIn handle obtained from WD_KernelPlugInOpen()

#define	WD_KernelPlugInCall(h, pKernelPlugInCall)
	Calls a routine in the Kernel PlugIn to be executed.

#define	WD_IntEnable(h, pInterrupt) WD_FUNCTION(IOCTL_WD_INT_ENABLE, h, pInterrupt, sizeof(WD_INTERRUPT), FALSE)
	Registers an interrupt service routine (ISR) to be called upon interrupt.

#define	WD_IntDisable(h, pInterrupt)
	Disables interrupt processing.

#define	WD_IntCount(h, pInterrupt) WD_FUNCTION(IOCTL_WD_INT_COUNT, h, pInterrupt, sizeof(WD_INTERRUPT), FALSE)
	Retrieves the interrupts count since the call to WD_IntEnable()

#define	WD_IntWait(h, pInterrupt) WD_FUNCTION(IOCTL_WD_INT_WAIT, h, pInterrupt, sizeof(WD_INTERRUPT), TRUE)
	Waits for an interrupt.

#define	WD_Sleep(h, pSleep) WD_FUNCTION(IOCTL_WD_SLEEP, h, pSleep, sizeof(WD_SLEEP), FALSE)
	Delays execution for a specific duration of time.

#define	WD_EventRegister(h, pEvent)

#define	WD_EventUnregister(h, pEvent)

#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)

#define	WD_GetDeviceProperty(h, pGetDevProperty)

#define	WD_USetInterface(h, pSetIfc)

#define	WD_UResetPipe(h, pResetPipe)

#define	WD_UTransfer(h, pTrans) WD_FUNCTION(IOCTL_WDU_TRANSFER, h, pTrans, sizeof(WDU_TRANSFER), TRUE);

#define	WD_UHaltTransfer(h, pHaltTrans)

#define	WD_UWakeup(h, pWakeup) WD_FUNCTION(IOCTL_WDU_WAKEUP, h, pWakeup, sizeof(WDU_WAKEUP), FALSE);

#define	WD_USelectiveSuspend(h, pSelectiveSuspend)

#define	WD_UResetDevice(h, pResetDevice)

#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)

#define	__ALIGN_DOWN(val, alignment) ( (val) & ~((alignment) - 1) )

#define	__ALIGN_UP(val, alignment) ( ((val) + (alignment) - 1) & ~((alignment) - 1) )

#define	MIN(a, b) ((a) > (b) ? (b) : (a))

#define	MAX(a, b) ((a) > (b) ? (a) : (b))

#define	SAFE_STRING(s) ((s) ? (s) : "")

#define	UNUSED_VAR(x) (void)x

Typedefs
typedef unsigned __int64	UINT64

typedef unsigned char	BYTE

typedef unsigned short int	WORD

typedef unsigned int	UINT32

typedef UINT32	KPTR

typedef size_t	UPTR

typedef UINT64	DMA_ADDR

typedef UINT64	PHYS_ADDR

typedef struct WD_DMA_PAGE	WD_DMA_PAGE_V80

typedef void(DLLCALLCONV *	DMA_TRANSACTION_CALLBACK) (PVOID pData)

typedef struct WD_DMA	WD_DMA_V80

typedef struct WD_KERNEL_BUFFER	WD_KERNEL_BUFFER_V121

typedef struct WD_TRANSFER	WD_TRANSFER_V61

typedef struct WD_KERNEL_PLUGIN_CALL	WD_KERNEL_PLUGIN_CALL_V40

typedef struct WD_INTERRUPT	WD_INTERRUPT_V91

typedef struct WD_VERSION	WD_VERSION_V30

typedef struct WD_LICENSE	WD_LICENSE_V122

typedef DWORD	WD_BUS_TYPE

typedef struct WD_BUS	WD_BUS_V30

typedef struct WD_ITEMS	WD_ITEMS_V118

typedef struct WD_CARD	WD_CARD_V118

typedef struct WD_CARD_REGISTER	WD_CARD_REGISTER_V118

typedef struct WD_IPC_PROCESS	WD_IPC_PROCESS_V121

typedef struct WD_IPC_REGISTER	WD_IPC_REGISTER_V121

typedef struct WD_IPC_SCAN_PROCS	WD_IPC_SCAN_PROCS_V121

typedef struct WD_IPC_SEND	WD_IPC_SEND_V121

typedef struct WD_PCI_SCAN_CARDS	WD_PCI_SCAN_CARDS_V124

typedef struct WD_PCI_SCAN_CAPS	WD_PCI_SCAN_CAPS_V118

typedef struct WD_PCI_SRIOV	WD_PCI_SRIOV_V122

typedef struct WD_PCI_CARD_INFO	WD_PCI_CARD_INFO_V118

typedef struct WD_PCI_CONFIG_DUMP	WD_PCI_CONFIG_DUMP_V30

typedef struct WD_SLEEP	WD_SLEEP_V40

typedef struct WD_DEBUG	WD_DEBUG_V40

typedef struct WD_DEBUG_DUMP	WD_DEBUG_DUMP_V40

typedef struct WD_DEBUG_ADD	WD_DEBUG_ADD_V503

typedef struct WD_KERNEL_PLUGIN	WD_KERNEL_PLUGIN_V40

typedef DWORD	WD_EVENT_TYPE

typedef struct WD_EVENT	WD_EVENT_V121

Enumerations
enum	WD_TRANSFER_CMD { 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 }
	IN WD_TRANSFER_CMD and WD_Transfer() DWORD stands for 32 bits and QWORD is 64 bit. More...

enum	{ WD_DMA_PAGES = 256 }

enum	WD_DMA_OPTIONS { 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 }

enum	{ WD_MATCH_EXCLUDE = 0x1 }

enum	WD_KER_BUF_OPTION { KER_BUF_ALLOC_NON_CONTIG = 0x0001 , KER_BUF_ALLOC_CONTIG = 0x0002 , KER_BUF_ALLOC_CACHED = 0x0004 , KER_BUF_GET_EXISTING_BUF = 0x0008 }

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 }

enum	WD_INTERRUPT_WAIT_RESULT { INTERRUPT_RECEIVED = 0 , INTERRUPT_STOPPED , INTERRUPT_INTERRUPTED }

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 }

enum	ITEM_TYPE { ITEM_NONE = 0 , ITEM_INTERRUPT = 1 , ITEM_MEMORY = 2 , ITEM_IO = 3 , ITEM_BUS = 5 }

enum	WD_ITEM_MEM_OPTIONS { WD_ITEM_MEM_DO_NOT_MAP_KERNEL = 0x1 , WD_ITEM_MEM_ALLOW_CACHE = 0x2 , WD_ITEM_MEM_USER_MAP = 0x4 }

enum	{ WD_CARD_ITEMS = 128 }

enum	{ WD_IPC_MAX_PROCS = 0x40 }

enum	{ WD_IPC_UID_UNICAST = 0x1 , WD_IPC_SUBGROUP_MULTICAST = 0x2 , WD_IPC_MULTICAST = 0x4 }

enum	{ WD_FORCE_CLEANUP = 0x1 }

enum	{ WD_PCI_CARDS = 256 }

enum	{ WD_PLATFORM_CARDS = 32 }

enum	{ WD_DEVICE_NAME_LENGTH = 256 }

enum	WD_PCI_SCAN_OPTIONS { WD_PCI_SCAN_DEFAULT = 0x0 , WD_PCI_SCAN_BY_TOPOLOGY = 0x1 , WD_PCI_SCAN_REGISTERED = 0x2 , WD_PCI_SCAN_INCLUDE_DOMAINS = 0x4 }

enum	{ WD_PCI_MAX_CAPS = 50 }

enum	{ WD_PCI_CAP_ID_ALL = 0x0 }

enum	WD_PCI_SCAN_CAPS_OPTIONS { WD_PCI_SCAN_CAPS_BASIC = 0x1 , WD_PCI_SCAN_CAPS_EXTENDED = 0x2 }

enum	PCI_ACCESS_RESULT { PCI_ACCESS_OK = 0 , PCI_ACCESS_ERROR = 1 , PCI_BAD_BUS = 2 , PCI_BAD_SLOT = 3 }

enum	{ SLEEP_BUSY = 0 , SLEEP_NON_BUSY = 1 }

enum	DEBUG_LEVEL { D_OFF = 0 , D_ERROR = 1 , D_WARN = 2 , D_INFO = 3 , D_TRACE = 4 }

enum	DEBUG_SECTION { 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 }

enum	DEBUG_COMMAND { 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 }

enum	WD_GET_DEVICE_PROPERTY_OPTION { WD_DEVICE_PCI = 0x1 , WD_DEVICE_USB = 0x2 }
	IOCTL Structures. More...

enum	WD_ERROR_CODES { 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 , WD_USBD_STATUS_SUCCESS = 0x00000000L , WD_USBD_STATUS_PENDING = 0x40000000L , WD_USBD_STATUS_ERROR = (int)0x80000000L , WD_USBD_STATUS_HALTED = (int)0xC0000000L , 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 , WD_USBD_STATUS_XACT_ERROR = (int)0xC0000011L , WD_USBD_STATUS_BABBLE_DETECTED = (int)0xC0000012L , WD_USBD_STATUS_DATA_BUFFER_ERROR = (int)0xC0000013L , WD_USBD_STATUS_CANCELED = (int)0xC0010000L , WD_USBD_STATUS_ENDPOINT_HALTED = (int)0xC0000030L , 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 , 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 }

enum	WD_EVENT_ACTION { 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 }

enum	WD_EVENT_OPTION { WD_ACKNOWLEDGE = 0x1 , WD_ACCEPT_CONTROL = 0x2 }

enum	{ WD_EVENT_TYPE_UNKNOWN = 0 , WD_EVENT_TYPE_PCI = 1 , WD_EVENT_TYPE_USB = 3 , WD_EVENT_TYPE_IPC = 4 }

enum	{ WD_USB_HARD_RESET = 1 , WD_USB_CYCLE_PORT = 2 }

Functions
const char *DLLCALLCONV	WD_DriverName (const char *sName)
	Sets the name of the WinDriver kernel module, which will be used by the calling application.

WD_OS_INFO DLLCALLCONV	get_os_type (void)
	Retrieves the type of the operating system in section.

DWORD DLLCALLCONV	check_secureBoot_enabled (void)
	Checks whether the Secure Boot feature is enabled on the system.

Data Structures

Macros

Typedefs

Enumerations

Functions