typedef void * WDC_DEVICE_HANDLE;

typedef DWORD WDC_DRV_OPEN_OPTIONS;

typedef DWORD WDC_ADDR_SIZE;

typedef DWORD WDC_SLEEP_OPTIONS;

typedef DWORD WDC_DBG_OPTIONS;

• Opens and stores a handle to WinDriver's kernel module and initializes the WDC library according to the open options passed to it.
This function should be called once before calling any other WDC API.

DWORD DLLCALLCONV WDC_DriverOpen(
    WDC_DRV_OPEN_OPTIONS openOptions,
    const CHAR *sLicense);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Closes the WDC WinDriver handle (acquired and stored by a previous call to WDC_DriverOpen [B.3.2]) and un-initializes the WDC library.

Every WDC_DriverOpen call should have a matching WDC_DriverClose call, which should be issued when you no longer need to use the WDC library.

DWORD DLLCALLCONV WDC_DriverClose(void);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Scans the PCI bus for all devices with the specified vendor and device ID combination and returns information regarding the matching devices that were found and their locations. The function performs the scan by iterating through all possible PCI buses on the host platform, then through all possible PCI slots, and then through all possible PCI functions.

DWORD DLLCALLCONV WDC_PciScanDevices(
    DWORD dwVendorId,
    DWORD dwDeviceId,
    WDC_PCI_SCAN_RESULT *pPciScanResult);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Scans the PCI bus for all devices with the specified vendor and device ID combination and returns information regarding the matching devices that were found and their locations. The function performs the scan by topology – i.e., for each located bridge the function scans the connected devices and functions reported by the bridge, and only then proceeds to scan the next bridge.

DWORD DLLCALLCONV WDC_PciScanDevicesByTopology(
    DWORD dwVendorId,
    DWORD dwDeviceId,
    WDC_PCI_SCAN_RESULT *pPciScanResult);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Scans the PCI bus for all devices with the specified vendor and device ID combination that have been registered to work with WinDriver, and returns information regarding the matching devices that were found and their locations. The function performs the scan by iterating through all possible PCI buses on the host platform, then through all possible PCI slots, and then through all possible PCI functions.

DWORD DLLCALLCONV WDC_PciScanRegisteredDevices(
    DWORD dwVendorId,
    DWORD dwDeviceId,
    WDC_PCI_SCAN_RESULT *pPciScanResult);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Scans the PCMCIA bus for all devices with the specified manufacturer and device ID combination and returns information regarding the matching devices that were found and their locations.

DWORD DLLCALLCONV WDC_PcmciaScanDevices(
    WORD wManufacturerId,
    WORD wDeviceId,
    WDC_PCMCIA_SCAN_RESULT *pPcmciaScanResult);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Retrieves a PCI device's resources information (memory and I/O ranges and interrupt information).

DWORD DLLCALLCONV WDC_PciGetDeviceInfo(
    WD_PCI_CARD_INFO *pDeviceInfo);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Retrieves a PCMCIA device's resources information (memory and I/O ranges and interrupt information).

DWORD DLLCALLCONV WDC_PcmciaGetDeviceInfo(
    WD_PCMCIA_CARD_INFO *pDeviceInfo);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Allocates and initializes a WDC PCI device structure, registers the device with WinDriver, and returns a handle to the device.

Among the operations performed by this function:

• Verifies that a non-shareable memory or I/O resource on the device has not already been registered exclusively.

• Maps the physical memory ranges found on the device both to kernel-mode and user-mode address space, and stores the mapped addresses in the allocated device structure for future use.

• Saves device resources information required for supporting the communication with the device. For example, the function saves the Interrupt Request (IRQ) number and the interrupt type, as well as retrieves and saves an interrupt handle, and this information is later used when the user calls functions to handle the device's interrupts.

• If the caller selects to use a Kernel PlugIn driver to communicate with the device, the function opens a handle to this driver and stores it for future use.

DWORD DLLCALLCONV WDC_PciDeviceOpen(
    WDC_DEVICE_HANDLE *phDev,
    const WD_PCI_CARD_INFO *pDeviceInfo,
    const PVOID pDevCtx,
    PVOID reserved,
    const CHAR *pcKPDriverName,
    PVOID pKPOpenData);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Allocates and initializes a WDC PCMCIA device structure, registers the device with WinDriver, and returns a handle to the device.

Among the operations performed by this function:

• Verifies that a non-shareable memory or I/O resource on the device has not already been registered exclusively.

• Maps the device's physical memory ranges device both to kernel-mode and user-mode address space, and stores the mapped addresses in the allocated device structure for future use.

• Saves device resources information required for supporting the communication with the device. For example, the function saves the Interrupt Request (IRQ) number and the interrupt type, as well as retrieves and saves an interrupt handle, and this information is later used when the user calls functions to handle the device's interrupts.

• If the caller selects to use a Kernel PlugIn driver to communicate with the device, the function opens a handle to this driver and stores it for future use.

DWORD DLLCALLCONV WDC_PcmciaDeviceOpen(
    WDC_DEVICE_HANDLE *phDev,
    const WD_PCMCIA_CARD_INFO *pDeviceInfo,
    const PVOID pDevCtx,
    PVOID reserved,
    const CHAR *pcKPDriverName,
    PVOID pKPOpenData);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Allocates and initializes a WDC ISA device structure, registers the device with WinDriver, and returns a handle to the device.

Among the operations performed by this function:

• Verifies that a non-shareable memory or I/O resource on the device has not already been registered exclusively.

• Maps the device's physical memory ranges device both to kernel-mode and user-mode address space, and stores the mapped addresses in the allocated device structure for future use.

• Saves device resources information required for supporting the communication with the device. For example, the function saves the Interrupt Request (IRQ) number and the interrupt type, as well as retrieves and saves an interrupt handle, and this information is later used when the user calls functions to handle the device's interrupts.

• If the caller selects to use a Kernel PlugIn driver to communicate with the device, the function opens a handle to this driver and stores it for future use.

DWORD DLLCALLCONV WDC_IsaDeviceOpen(
    WDC_DEVICE_HANDLE *phDev,
    const WD_CARD *pDeviceInfo,
    const PVOID pDevCtx,
    PVOID reserved,
    const CHAR *pcKPDriverName,
    PVOID pKPOpenData);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Un-initializes a WDC PCI device structure and frees the memory allocated for it.

DWORD DLLCALLCONV WDC_PciDeviceClose(WDC_DEVICE_HANDLE hDev);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Un-initializes a WDC PCMCIA device structure and frees the memory allocated for it.

DWORD DLLCALLCONV WDC_PcmciaDeviceClose(WDC_DEVICE_HANDLE hDev);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Un-initializes a WDC ISA device structure and frees the memory allocated for it.

DWORD DLLCALLCONV WDC_IsaDeviceClose(WDC_DEVICE_HANDLE hDev);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Sets a list of transfer cleanup commands to be performed for the specified card on any of the following occasions:

DWORD WDC_CardCleanupSetup(
    WDC_DEVICE_HANDLE hDev,
    WD_TRANSFER *Cmd,
    DWORD dwCmds,
    BOOL bForceCleanup);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Opens a handle to a Kernel PlugIn driver.

DWORD DLLCALLCONV WDC_KernelPlugInOpen(
    WDC_DEVICE_HANDLE hDev,
    const CHAR *pcKPDriverName,
    PVOID pKPOpenData);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Sends a message from a user-mode application to a Kernel PlugIn driver. The function passes a message ID from the application to the Kernel PlugIn's KP_Call [B.6.4] function, which should be implemented to handle the specified message ID, and returns the result from the Kernel PlugIn to the user-mode application.

DWORD DLLCALLCONV WDC_CallKerPlug(
    WDC_DEVICE_HANDLE hDev,
    DWORD dwMsg,
    PVOID pData,
    PDWORD pdwResult);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• WDC_ReadMem8/16/32/64 reads 1 byte (8 bits) / 2 bytes (16 bits) / 4 bytes (32 bits) / 8 bytes (64 bits), respectively, from a specified memory address. The address is read directly in the calling context (user mode / kernel mode).

BYTE WDC_ReadMem8(addr, off);
WORD WDC_ReadMem16(addr, off);
UINT32 WDC_ReadMem32(addr, off);
UINT64 WDC_ReadMem64(addr, off);

Note: The WDC_ReadMemXXX APIs are implemented as macros. The prototypes above use functions declaration syntax to emphasize the expected return values. Returns the data that was read from the specified address.

• WDC_WriteMem8/16/32/64 writes 1 byte (8 bits) / 2 bytes (16 bits) / 4 bytes (32 bits) / 8 bytes (64 bits), respectively, to a specified memory address. The address is written to directly in the calling context (user mode / kernel mode).

void WDC_WriteMem8(addr, off, val);
void WDC_WriteMem16(addr, off, val);
void WDC_WriteMem32(addr, off, val);
void WDC_WriteMem64(addr, off, val);

Note: The WDC_WriteMemXXX APIs are implemented as macros. The prototypes above use functions declaration syntax to emphasize the expected return values.

None

• WDC_ReadAddr8/16/32/64 reads 1 byte (8 bits) / 2 bytes (16 bits) / 4 bytes (32 bits) / 8 bytes (64 bits), respectively, from a specified memory or I/O address.

DWORD DLLCALLCONV WDC_ReadAddr8(WDC_DEVICE_HANDLE hDev,
    DWORD dwAddrSpace, KPTR dwOffset, BYTE *val);

DWORD DLLCALLCONV WDC_ReadAddr16(WDC_DEVICE_HANDLE hDev,
    DWORD dwAddrSpace, KPTR dwOffset, WORD *val);

DWORD DLLCALLCONV WDC_ReadAddr32(WDC_DEVICE_HANDLE hDev,
    DWORD dwAddrSpace, KPTR dwOffset, UINT32 *val);

DWORD DLLCALLCONV WDC_ReadAddr64(WDC_DEVICE_HANDLE hDev,
    DWORD dwAddrSpace, KPTR dwOffset, UINT64 *val);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• WDC_WriteAddr8/16/32/64 writes 1 byte (8 bits) / 2 bytes (16 bits) / 4 bytes (32 bits) / 8 bytes (64 bits), respectively, to a specified memory or I/O address.

DWORD DLLCALLCONV WDC_WriteAddr8(WDC_DEVICE_HANDLE hDev,
    DWORD dwAddrSpace, KPTR dwOffset, BYTE val)

DWORD DLLCALLCONV WDC_WriteAddr16(WDC_DEVICE_HANDLE hDev,
    DWORD dwAddrSpace, KPTR dwOffset, WORD val);

DWORD DLLCALLCONV WDC_WriteAddr32(WDC_DEVICE_HANDLE hDev,
    DWORD dwAddrSpace, KPTR dwOffset, UINT32 val);

DWORD DLLCALLCONV WDC_WriteAddr64(WDC_DEVICE_HANDLE hDev,
    DWORD dwAddrSpace, KPTR dwOffset, UINT64 val);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Reads a block of data from the device.

DWORD DLLCALLCONV WDC_ReadAddrBlock(
    WDC_DEVICE_HANDLE hDev,
    DWORD dwAddrSpace,
    KPTR dwOffset,
    DWORD dwBytes,
    PVOID pData,
    WDC_ADDR_MODE mode,
    WDC_ADDR_RW_OPTIONS options);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Writes a block of data to the device.

DWORD DLLCALLCONV WDC_WriteAddrBlock(
    WDC_DEVICE_HANDLE hDev,
    DWORD dwAddrSpace,
    KPTR dwOffset,
    DWORD dwBytes,
    PVOID pData,
    WDC_ADDR_MODE mode,
    WDC_ADDR_RW_OPTIONS options);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Performs a group of memory and/or I/O read/write transfers.

DWORD DLLCALLCONV WDC_MultiTransfer(
    WD_TRANSFER *pTrans,
    DWORD dwNumTrans);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Checks if the specified memory or I/O address space is active – i.e., if its size is not zero.

BOOL DLLCALLCONV WDC_AddrSpaceIsActive(
    WDC_DEVICE_HANDLE hDev,
    DWORD dwAddrSpace);

Returns TRUE if the specified address space is active; otherwise returns FALSE.

• Reads data from a specified offset in a PCI device's configuration space or a PCI Express device's extended configuration space.
The device is identified by its location on the PCI bus. Access to the PCI Express extended configuration space is supported on target platforms that support such access (e.g., Windows and Linux). On such platforms, all references to 'PCI' in the description below also include PCI Express.

DWORD DLLCALLCONV WDC_PciReadCfgBySlot(
    WD_PCI_SLOT *pPciSlot,
    DWORD dwOffset,
    PVOID pData,
    DWORD dwBytes);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Write data to a specified offset in a PCI device's configuration space or a PCI Express device's extended configuration space.
The device is identified by its location on the PCI bus. Access to the PCI Express extended configuration space is supported on target platforms that support such access (e.g., Windows and Linux). On such platforms, all references to 'PCI' in the description below also include PCI Express.

DWORD DLLCALLCONV WDC_PciWriteCfgBySlot(
    WD_PCI_SLOT *pPciSlot,
    DWORD dwOffset,
    PVOID pData,
    DWORD dwBytes);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Reads data from a specified offset in a PCI device's configuration space or a PCI Express device's extended configuration space. Access to the PCI Express extended configuration space is supported on target platforms that support such access (e.g., Windows and Linux). On such platforms, all references to 'PCI' in the description below also include PCI Express.

DWORD DLLCALLCONV WDC_PciReadCfg(
    WDC_DEVICE_HANDLE hDev,
    DWORD dwOffset,
    PVOID pData,
    DWORD dwBytes);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Writes data to a specified offset in a PCI device's configuration space or a PCI Express device's extended configuration space. Access to the PCI Express extended configuration space is supported on target platforms that support such access (e.g., Windows and Linux). On such platforms, all references to 'PCI' in the description below also include PCI Express.

DWORD DLLCALLCONV WDC_PciWriteCfg(
    WDC_DEVICE_HANDLE hDev,
    DWORD dwOffset,
    PVOID pData,
    DWORD dwBytes);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• WDC_PciReadCfgBySlot8/16/32/64 reads 1 byte (8 bits) / 2 bytes (16 bits) / 4 bytes (32 bits) / 8 bytes (64 bits), respectively, from a specified offset in a PCI device's configuration space or a PCI Express device's extended configuration space.
The device is identified by its location on the PCI bus. Access to the PCI Express extended configuration space is supported on target platforms that support such access (e.g., Windows and Linux). On such platforms, all references to 'PCI' in the description below also include PCI Express.

DWORD DLLCALLCONV WDC_PciReadCfgRegBySlot8(
    WD_PCI_SLOT *pPciSlot, DWORD dwOffset, BYTE *val);

DWORD DLLCALLCONV WDC_PciReadCfgReg1BySlot6(
    WD_PCI_SLOT *pPciSlot, DWORD dwOffset, WORD *val);

DWORD DLLCALLCONV WDC_PciReadCfgReg32BySlot(
    WD_PCI_SLOT *pPciSlot, DWORD dwOffset, UINT32 *val);

DWORD DLLCALLCONV WDC_PciReadCfgReg64BySlot(
    WD_PCI_SLOT *pPciSlot, DWORD dwOffset, UINT64 *val);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• WDC_PciWriteCfgBySlot8/16/32/64 writes 1 byte (8 bits) / 2 bytes (16 bits) / 4 bytes (32 bits) / 8 bytes (64 bits), respectively, to a specified offset in a PCI device's configuration space or a PCI Express device's extended configuration space.
The device is identified by its location on the PCI bus. Access to the PCI Express extended configuration space is supported on target platforms that support such access (e.g., Windows and Linux). On such platforms, all references to 'PCI' in the description below also include PCI Express.

DWORD DLLCALLCONV WDC_PciWriteCfgRegBySlot8(
    WD_PCI_SLOT *pPciSlot, DWORD dwOffset, BYTE val);

DWORD DLLCALLCONV WDC_PciWriteCfgRegBySlot16(
    WD_PCI_SLOT *pPciSlot, DWORD dwOffset, WORD val);

DWORD DLLCALLCONV WDC_PciWriteCfgRegBySlot32(
    WD_PCI_SLOT *pPciSlot, DWORD dwOffset, UINT32 val);

DWORD DLLCALLCONV WDC_PciWriteCfgRegBySlot64(
    WD_PCI_SLOT *pPciSlot, DWORD dwOffset, UINT64 val);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• WDC_PciReadCfg8/16/32/64 reads 1 byte (8 bits) / 2 bytes (16 bits) / 4 bytes (32 bits) / 8 bytes (64 bits), respectively, from a specified offset in a PCI device's configuration space or a PCI Express device's extended configuration space . Access to the PCI Express extended configuration space is supported on target platforms that support such access (e.g., Windows and Linux). On such platforms, all references to 'PCI' in the description below also include PCI Express.

DWORD DLLCALLCONV WDC_PciReadCfgReg8(WDC_DEVICE_HANDLE hDev,
    DWORD dwOffset, BYTE *val);

DWORD DLLCALLCONV WDC_PciReadCfgReg16(WDC_DEVICE_HANDLE hDev,
    DWORD dwOffset, WORD *val);

DWORD DLLCALLCONV WDC_PciReadCfgReg32(WDC_DEVICE_HANDLE hDev,
    DWORD dwOffset, UINT32 *val);

DWORD DLLCALLCONV WDC_PciReadCfgReg64(WDC_DEVICE_HANDLE hDev,
    DWORD dwOffset, UINT64 *val);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• WDC_PciWriteCfg8/16/32/64 writes 1 byte (8 bits) / 2 bytes (16 bits) / 4 bytes (32 bits) / 8 bytes (64 bits), respectively, to a specified offset in a PCI device's configuration space or a PCI Express device's extended configuration space. Access to the PCI Express extended configuration space is supported on target platforms that support such access (e.g., Windows and Linux). On such platforms, all references to 'PCI' in the description below also include PCI Express.

DWORD DLLCALLCONV WDC_PciWriteCfgReg8(WDC_DEVICE_HANDLE hDev,
    DWORD dwOffset, BYTE val);

DWORD DLLCALLCONV WDC_PciWriteCfgReg16(WDC_DEVICE_HANDLE hDev,
    DWORD dwOffset, WORD val);

DWORD DLLCALLCONV WDC_PciWriteCfgReg32(WDC_DEVICE_HANDLE hDev,
    DWORD dwOffset, UINT32 val);

DWORD DLLCALLCONV WDC_PciWriteCfgReg64(WDC_DEVICE_HANDLE hDev,
    DWORD dwOffset, UINT64 val);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Reads data from a specified offset in a PCMCIA device's attribute space.

DWORD DLLCALLCONV WDC_PcmciaReadAttribSpace(
    WDC_DEVICE_HANDLE hDev,
    DWORD dwOffset,
    PVOID pData,
    DWORD dwBytes);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Writes data to a specified offset in a PCMCIA device's attribute space.

DWORD DLLCALLCONV WDC_PcmciaWriteAttribSpace(
    WDC_DEVICE_HANDLE hDev,
    DWORD dwOffset,
    PVOID pData,
    DWORD dwBytes);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Modifies the settings of the PCMCIA bus controller's memory window.

DWORD DLLCALLCONV WDC_PcmciaSetWindow(
    WDC_DEVICE_HANDLE hDev,
    WD_PCMCIA_ACC_SPEED speed,
    WD_PCMCIA_ACC_WIDTH width,
    DWORD dwCardBase);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Modifies the power level of the PCMCIA bus controller's Voltage Power Pin (Vpp).

DWORD DLLCALLCONV WDC_PcmciaSetVpp(
    WDC_DEVICE_HANDLE hDev,
    WD_PCMCIA_VPP vpp);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Allocates a contiguous 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.

DWORD DLLCALLCONV WDC_DMAContigBufLock(
    WDC_DEVICE_HANDLE hDev,
    PVOID *ppBuf,
    DWORD dwOptions,
    DWORD dwDMABufSize,
    WD_DMA **ppDma);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Locks a pre-allocated user-mode memory buffer for DMA and returns the corresponding physical mappings of the locked DMA pages. On Windows 7/Vista/Server 2008/Server 2003/XP/2000 the function also returns a kernel-mode mapping of the buffer.

DWORD DLLCALLCONV WDC_DMASGBufLock(
    WDC_DEVICE_HANDLE hDev,
    PVOID pBuf,
    DWORD dwOptions,
    DWORD dwDMABufSize,
    WD_DMA **ppDma);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Unlocks and frees the memory allocated for a DMA buffer by a previous call to WDC_DMAContigBufLock [B.3.39] or WDC_DMASGBufLock [B.3.40].

DWORD DLLCALLCONV WDC_DMABufUnlock(WD_DMA *pDma);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Synchronizes the cache of all CPUs with the DMA buffer, by flushing the data from the CPU caches.

NOTE: This function should be called before performing a DMA transfer (see Remarks below).

DWORD DLLCALLCONV WDC_DMASyncCpu(WD_DMA *pDma);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Synchronizes the I/O caches with the DMA buffer, by flushing the data from the I/O caches and updating the CPU caches. NOTE: This function should be called after performing a DMA transfer (see Remarks below).

DWORD DLLCALLCONV WDC_DMASyncIo(WD_DMA *pDma);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Allocates a memory buffer that can be shared between the user mode and the kernel mode ("shared buffer").
• Returns user-mode and kernel-mode virtual address space mappings of the allocated buffer.

DWORD DLLCALLCONV WDC_SharedBufferAlloc(
    PVOID *ppUserAddr,
    KPTR *ppKernelAddr,
    DWORD dwBufSize,
    DWORD dwOptions,
    HANDLE *phBuf);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Frees a shared buffer that was allocated by a previous call to WDC_SharedBufferAlloc [B.3.44].

#define WDC_SharedBufferFree(hBuf)

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Enables interrupt handling for the device.
On Linux and Windows Vista and higher, when attempting to enable interrupts for a PCI device that supports Extended Message-Signaled Interrupts (MSI-X) or Message-Signaled Interrupts (MSI) (and was installed with a relevant INF file – on Windows Vista and higher [9.2.6.1]), the function first tries to enable MSI-X or MSI; if this fails, or if the target OS does not support MSI/MSI-X, the function attempts to enable legacy level-sensitive interrupts (if supported by the device). For other types of hardware (PCI with no MSI/MSI-X support / PCMCIA / ISA), the function attempts to enable the legay interrupt type supported by the device (Level Sensitive / Edge Triggered) – see further information in section 9.2.

• If the caller selects to handle the interrupts in the kernel, using a Kernel PlugIn driver, the Kernel PlugIn KP_IntAtIrql [B.6.8] (legacy interrupts) or KP_IntAtIrqlMSI [B.6.10] (MSI-MSI-X) function, which runs at high Interrupt Request (IRQ) level, will be invoked immediately when an an interrupt is received.

• The function can receive transfer commands information, which will be performed by WinDriver at the kernel, at high IRQ level, when an interrupt is received (see further information in section 9.2.5). If a Kernel PlugIn driver is used to handle the interrupts, any transfer commands set by the caller will be executed by WinDriver after the Kernel PlugIn KP_IntAtDpc or KP_IntAtDpcMSI function completes its execution.
When handling level-sensitive interrupts (such as legacy PCI interrupts) from the user mode, without a Kernel PlugIn driver, you must prepare and pass to the function transfer commands for acknowledging the interrupt. When using a Kernel PlugIn driver, the information for acknowledging the interrupts should be implemented in the Kernel PlugIn KP_IntAtIrql function [B.6.8], so the transfer commands in the call to WDC_IntEnable are not required (although they can still be used).

• The function receives a user-mode interrupt handler routine, which will be called by WinDriver after the kernel-mode interrupt processing is completed.
If the interrupts are handled using a Kernel PlugIn driver, the return value of the Kernel PlugIn deferred interrupt handler function – KP_IntAtDpc  [B.6.9] (legacy interrupts) or KP_IntAtDpcMSI  [B.6.11] (MSI-MSI-X) – will determine how many times (if at all) the user-mode interrupt handler will be called (provided KP_IntAtDpc or KP_IntAtDpcMSI itself is executed – which is determined by the return value of the Kernel PlugIn KP_IntAtIrql [B.6.8] or KP_IntAtIrqlMSI [B.6.10] function).

DWORD DLLCALLCONV WDC_IntEnable(
    WDC_DEVICE_HANDLE hDev,
    WD_TRANSFER *pTransCmds,
    DWORD dwNumCmds,
    DWORD dwOptions,
    INT_HANDLER funcIntHandler,
    PVOID pData,
    BOOL fUseKP);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Disables interrupt interrupt handling for the device, pursuant to a previous call to WDC_IntEnable [B.3.46].

DWORD DLLCALLCONV WDC_IntDisable(WDC_DEVICE_HANDLE hDev);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Checks if a device's interrupts are currently enabled.

BOOL DLLCALLCONV WDC_IntIsEnabled(WDC_DEVICE_HANDLE hDev);

Returns TRUE if the device's interrupts are enabled; otherwise returns FALSE.

• Registers the application to receive Plug-and-Play and power management events notifications for the device.

DWORD DLLCALLCONV WDC_EventRegister(
    WDC_DEVICE_HANDLE hDev,
    DWORD dwActions,
    EVENT_HANDLER funcEventHandler,
    PVOID pData,
    BOOL fUseKP);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Un-registers an application from a receiving Plug-and-Play and power management notifications for a device, pursuant to a previous call to WDC_EventRegister [B.3.49].

DWORD DLLCALLCONV WDC_EventUnregister(WDC_DEVICE_HANDLE hDev);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Checks if the application is currently registered to receive Plug-and-Play and power management notifications for the device.

BOOL DLLCALLCONV WDC_EventIsRegistered(WDC_DEVICE_HANDLE hDev);

Returns TRUE if the application is currently registered to receive Plug-and-Play and power management notifications for the device; otherwise returns FALSE.

• Sets debug options for the WDC library – see the description of WDC_DBG_OPTIONS [B.3.1.8] for details regarding the possible debug options to set.

• This function is typically called at the beginning of the application, after the call to WDC_DriverOpen [B.3.2], and can be re-called at any time while the WDC library is in use (i.e., WDC_DriverClose [B.3.3] has not been called) in order to change the debug settings.

• Until the function is called, the WDC library uses the default debug options – see WDC_DEBG_DEFAULT [B.3.1.8].

When the function is recalled, it performs any required cleanup for the previous debug settings and sets the default debug options before attempting to set the new options specified by the caller.

DWORD DLLCALLCONV WDC_SetDebugOptions(
    WDC_DBG_OPTIONS dbgOptions,
    const CHAR *sDbgFile);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Displays debug error messages according to the WDC debug options – see WDC_DBG_OPTIONS [B.3.1.8] and WDC_SetDebugOptions [B.3.52].

void DLLCALLCONV WDC_Err(
    const CHAR *format
    [, argument] ...);

None

• Displays debug trace messages according to the WDC debug options – see WDC_DBG_OPTIONS [B.3.1.8] and WDC_SetDebugOptions [B.3.52].

void DLLCALLCONV WDC_Trace(
    const CHAR *format
    [, argument] ...);

None

• Returns a handle to WinDriver's kernel module, which is required by the basic WD_xxx WinDriver PCI/PCMCIA/ISA API, described in the WinDriver PCI Low-Level API Reference (see Remarks below).

HANDLE DLLCALLCONV WDC_GetWDHandle(void);

Returns a handle to WinDriver's kernel module, or INVALID_HANDLE_VALUE in case of a failure

• Returns the device's user context information.

PVOID DLLCALLCONV WDC_GetDevContext(WDC_DEVICE_HANDLE hDev);

Returns a pointer to the device's user context, or NULL if not context has been set.

• Returns the device's bus type: WD_BUS_PCI, WD_BUS_PCMCIA, WD_BUS_ISA or WD_BUS_UNKNOWN.

WD_BUS_TYPE DLLCALLCONV WDC_GetBusType(WDC_DEVICE_HANDLE hDev);

Returns the device's bus type [B.5.1].

• Delays execution for the specified duration of time (in microseconds).
By default the function performs a busy sleep (consumes CPU cycles).

DWORD DLLCALLCONV WDC_Sleep(
    DWORD dwMicroSecs,
    WDC_SLEEP_OPTIONS options);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].

• Returns the version number of the WinDriver kernel module used by the WDC library.

DWORD DLLCALLCONV WDC_Version(
    CHAR *sVersion,
    DWORD *pdwVersion);

Returns WD_STATUS_SUCCESS(0) on success, or an appropriate error code otherwise [B.9].