wdc_lib.h

Go to the documentation of this file.

/* @JUNGO_COPYRIGHT@ */
 
#ifndef _WDC_LIB_H_
#define _WDC_LIB_H_
 
/*********************************************************************
*  File: wdc_lib.h - Shared WD card (WDC) library header.            *
*                    This file defines the WDC library's high-level  *
*                    interface                                       *
**********************************************************************/
 
#if defined(__KERNEL__)
    #include "kpstdlib.h"
#endif
#include "windrvr.h"
#include "windrvr_int_thread.h"
#include "windrvr_events.h"
#include "bits.h"
#include "pci_regs.h"
 
#ifdef __cplusplus
    extern "C" {
#endif
/**************************************************************
  General definitions
 **************************************************************/
 
#define MAX_NAME 128
#define MAX_DESC 128
#define MAX_NAME_DISPLAY 22
 
typedef void *WDC_DEVICE_HANDLE;
 
#ifndef __KERNEL__
typedef struct {
    DWORD       dwNumDevices;             
    WD_PCI_ID   deviceId[WD_PCI_CARDS];   
    WD_PCI_SLOT deviceSlot[WD_PCI_CARDS]; 
} WDC_PCI_SCAN_RESULT;
 
#if defined(PLATFORM_API)
typedef struct {
    DWORD dwNumDevices; 
    CHAR pcDeviceNames[WD_PLATFORM_CARDS][WD_DEVICE_NAME_LENGTH]; 
    PHYS_ADDR pDeviceAddresses[WD_PLATFORM_CARDS]; 
} WDC_PLATFORM_SCAN_RESULT;
#endif /* defined(PLATFORM_API) */
 
#endif /* __KERNEL__ */
 
typedef struct {
    DWORD      dwNumCaps; 
    WD_PCI_CAP pciCaps[WD_PCI_MAX_CAPS]; 
} WDC_PCI_SCAN_CAPS_RESULT;
 
/* Driver open options */
/* Basic driver open flags */
#define WDC_DRV_OPEN_CHECK_VER 0x1 
#define WDC_DRV_OPEN_REG_LIC   0x2 
#define WDC_DRV_OPEN_AGENT_DEFAULT_WAIT 0x10 
#define WDC_DRV_OPEN_AGENT_LONG_WAIT 0x20    
#define WDC_DRV_OPEN_AGENT_INFINITE_WAIT 0x40 
/* Convenient driver open options */
#define WDC_DRV_OPEN_BASIC     0x0 
#define WDC_DRV_OPEN_KP WDC_DRV_OPEN_BASIC 
#define WDC_DRV_OPEN_ALL (WDC_DRV_OPEN_CHECK_VER | WDC_DRV_OPEN_REG_LIC | WDC_DRV_OPEN_AGENT_DEFAULT_WAIT)
#if defined(__KERNEL__)
    #define WDC_DRV_OPEN_DEFAULT WDC_DRV_OPEN_KP
#else
    #define WDC_DRV_OPEN_DEFAULT WDC_DRV_OPEN_CHECK_VER | WDC_DRV_OPEN_REG_LIC
#endif
typedef DWORD WDC_DRV_OPEN_OPTIONS;
 
/* Debug information display options */
#define WDC_DBG_OUT_DBM     0x1  
#define WDC_DBG_OUT_FILE    0x2  
#define WDC_DBG_LEVEL_ERR   0x10 
#define WDC_DBG_LEVEL_TRACE 0x20 
#define WDC_DBG_NONE        0x100 
#define WDC_DBG_DEFAULT     (WDC_DBG_OUT_DBM | WDC_DBG_LEVEL_TRACE)
 
#define WDC_DBG_DBM_ERR   (WDC_DBG_OUT_DBM | WDC_DBG_LEVEL_ERR)
#define WDC_DBG_DBM_TRACE (WDC_DBG_OUT_DBM | WDC_DBG_LEVEL_TRACE)
 
#if !defined(__KERNEL__)
    #define WDC_DBG_FILE_ERR   (WDC_DBG_OUT_FILE | WDC_DBG_LEVEL_ERR)
    #define WDC_DBG_FILE_TRACE (WDC_DBG_OUT_FILE | WDC_DBG_LEVEL_TRACE)
 
    #define WDC_DBG_DBM_FILE_ERR   \
        (WDC_DBG_OUT_DBM | WDC_DBG_OUT_FILE | WDC_DBG_LEVEL_ERR)
    #define WDC_DBG_DBM_FILE_TRACE \
        (WDC_DBG_OUT_DBM | WDC_DBG_OUT_FILE | WDC_DBG_LEVEL_TRACE)
 
    #define WDC_DBG_FULL \
        (WDC_DBG_OUT_DBM | WDC_DBG_OUT_FILE | WDC_DBG_LEVEL_TRACE)
#else
    #define WDC_DBG_FULL (WDC_DBG_OUT_DBM | WDC_DBG_LEVEL_TRACE)
#endif
 
typedef DWORD WDC_DBG_OPTIONS;
 
#define WDC_SLEEP_BUSY 0
#define WDC_SLEEP_NON_BUSY SLEEP_NON_BUSY
typedef DWORD WDC_SLEEP_OPTIONS;
 
/* -----------------------------------------------
    Memory / I/O / Registers
   ----------------------------------------------- */
struct WDC_ADDR_DESC;
 
typedef enum {
    WDC_WRITE = 0x1,
    WDC_READ = 0x2,
    WDC_READ_WRITE = 0x4,
} WDC_DIRECTION;
 
typedef enum {
    WDC_ADDR_RW_DEFAULT = 0x0, 
    WDC_ADDR_RW_NO_AUTOINC = 0x4 
} WDC_ADDR_RW_OPTIONS;
 
/* Memory/I/O address size and access mode definitions (size - in bytes) */
#define WDC_SIZE_8 ((DWORD)sizeof(BYTE))
#define WDC_SIZE_16 ((DWORD)sizeof(WORD))
#define WDC_SIZE_32 ((DWORD)sizeof(UINT32))
#define WDC_SIZE_64 ((DWORD)sizeof(UINT64))
typedef DWORD WDC_ADDR_SIZE;
 
typedef enum {
    WDC_MODE_8 = WDC_SIZE_8,
    WDC_MODE_16 = WDC_SIZE_16,
    WDC_MODE_32 = WDC_SIZE_32,
    WDC_MODE_64 = WDC_SIZE_64
} WDC_ADDR_MODE;
 
#define WDC_ADDR_MODE_TO_SIZE(mode) (UINT64)mode
#define WDC_ADDR_SIZE_TO_MODE(size) (((size) > WDC_SIZE_32) ? WDC_MODE_64 : \
    ((size) > WDC_SIZE_16) ? WDC_MODE_32 : \
    ((size) > WDC_SIZE_8) ? WDC_MODE_16 : WDC_MODE_8)
 
#define WDC_AD_CFG_SPACE 0xFF
 
/**************************************************************
  Function Prototypes
 **************************************************************/
/* -----------------------------------------------
    General
   ----------------------------------------------- */
HANDLE DLLCALLCONV WDC_GetWDHandle(void);
 
PVOID DLLCALLCONV WDC_GetDevContext(_In_ WDC_DEVICE_HANDLE hDev);
 
WD_BUS_TYPE DLLCALLCONV WDC_GetBusType(_In_ WDC_DEVICE_HANDLE hDev);
 
DWORD DLLCALLCONV WDC_Sleep(_In_ DWORD dwMicroSecs,
    _In_ WDC_SLEEP_OPTIONS options);
 
DWORD DLLCALLCONV WDC_Version(_Outptr_ CHAR *pcVersion, _In_ DWORD dwLen,
    _Outptr_ DWORD *pdwVersion);
 
DWORD DLLCALLCONV WDC_DriverOpen(_In_ WDC_DRV_OPEN_OPTIONS openOptions,
    _In_ const CHAR *pcLicense);
 
DWORD DLLCALLCONV WDC_DriverClose(void);
 
#ifndef __KERNEL__
DWORD DLLCALLCONV WDC_PciScanDevices(_In_ DWORD dwVendorId,
    _In_ DWORD dwDeviceId, _Outptr_ WDC_PCI_SCAN_RESULT *pPciScanResult);
 
DWORD DLLCALLCONV WDC_PciScanDevicesByTopology(_In_ DWORD dwVendorId,
    _In_ DWORD dwDeviceId, _Outptr_ WDC_PCI_SCAN_RESULT *pPciScanResult);
 
DWORD DLLCALLCONV WDC_PciScanRegisteredDevices(_In_ DWORD dwVendorId,
    _In_ DWORD dwDeviceId, _Outptr_ WDC_PCI_SCAN_RESULT *pPciScanResult);
 
#if defined(PLATFORM_API)
DWORD DLLCALLCONV WDC_PlatformScanDevices(_In_ const CHAR *pcDeviceName, 
    _In_ PHYS_ADDR pSearchAddr,
    _Outptr_ WDC_PLATFORM_SCAN_RESULT *pPlatformScanResult);
#endif
 
DWORD DLLCALLCONV WDC_ScanDevices(_In_ DWORD dwVendorId,
    _In_ DWORD dwDeviceId, _Outptr_ WDC_PCI_SCAN_RESULT *pPciScanResult
#if defined(PLATFORM_API)
    , _In_ const CHAR *pcDeviceName, _In_ PHYS_ADDR pSearchAddr,
    _Outptr_ WDC_PLATFORM_SCAN_RESULT *pPlatformScanResult
#endif
    );
#endif
 
DWORD DLLCALLCONV WDC_PciGetExpressOffset(_In_ WDC_DEVICE_HANDLE hDev,
    _Outptr_ DWORD *pdwOffset);
DWORD DLLCALLCONV WDC_PciGetHeaderType(_In_ WDC_DEVICE_HANDLE hDev,
    _Outptr_ WDC_PCI_HEADER_TYPE *pHeaderType);
 
DWORD DLLCALLCONV WDC_PciScanCaps(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ DWORD dwCapId, _Outptr_ WDC_PCI_SCAN_CAPS_RESULT *pScanCapsResult);
 
DWORD DLLCALLCONV WDC_PciScanCapsBySlot(_In_ WD_PCI_SLOT *pPciSlot,
    _In_ DWORD dwCapId, _Outptr_ WDC_PCI_SCAN_CAPS_RESULT *pScanCapsResult);
 
DWORD DLLCALLCONV WDC_PciScanExtCaps(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ DWORD dwCapId, _Outptr_ WDC_PCI_SCAN_CAPS_RESULT *pScanCapsResult);
 
DWORD DLLCALLCONV WDC_PciGetExpressGenBySlot(_In_ WD_PCI_SLOT *pPciSlot);
 
DWORD DLLCALLCONV WDC_PciGetExpressGen(_In_ WDC_DEVICE_HANDLE hDev);
 
#ifndef __KERNEL__
DWORD DLLCALLCONV WDC_PciGetDeviceInfo(_Inout_ WD_PCI_CARD_INFO *pDeviceInfo);
 
#if defined(PLATFORM_API)
DWORD DLLCALLCONV WDC_PlatformGetDeviceInfo(
    _Inout_ WD_PLATFORM_CARD_INFO *pDeviceInfo);
#endif
 
DWORD DLLCALLCONV WDC_GetDeviceInfo(_Inout_ WD_PCI_CARD_INFO *pPciDeviceInfo
#if defined(PLATFORM_API)
    , _Inout_ WD_PLATFORM_CARD_INFO *pPlatformInfo
#endif
    );
 
#endif
 
DWORD DLLCALLCONV WDC_PciSriovEnable(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ DWORD dwNumVFs);
 
DWORD DLLCALLCONV WDC_PciSriovDisable(_In_ WDC_DEVICE_HANDLE hDev);
 
DWORD DLLCALLCONV WDC_PciSriovGetNumVFs(_In_ WDC_DEVICE_HANDLE hDev,
    _Outptr_ DWORD *pdwNumVFs);
 
#if !defined(__KERNEL__)    
DWORD DLLCALLCONV WDC_PciDeviceOpen(_Outptr_ WDC_DEVICE_HANDLE *phDev,
    _In_ const WD_PCI_CARD_INFO *pDeviceInfo, _In_ const PVOID pDevCtx);
 
DWORD DLLCALLCONV WDC_IsaDeviceOpen(_Outptr_ WDC_DEVICE_HANDLE *phDev,
    _In_ const WD_CARD *pDeviceInfo, _In_ const PVOID pDevCtx);
 
#if defined(PLATFORM_API)
DWORD DLLCALLCONV WDC_PlatformDeviceOpen(_Outptr_ WDC_DEVICE_HANDLE *phDev,
    _In_ const WD_PLATFORM_CARD_INFO *pDeviceInfo, _In_ const PVOID pDevCtx);
#endif
 
DWORD DLLCALLCONV WDC_DeviceOpen(_Outptr_ WDC_DEVICE_HANDLE *phDev,
    _In_ const WD_PCI_CARD_INFO *pPciDeviceInfo,
#if defined(PLATFORM_API)
    _In_ const WD_PLATFORM_CARD_INFO *pPlatformDeviceInfo,
#endif
    _In_ const PVOID pDevCtx);
 
DWORD DLLCALLCONV WDC_PciDeviceClose(_In_ WDC_DEVICE_HANDLE hDev);
 
DWORD DLLCALLCONV WDC_IsaDeviceClose(_In_ WDC_DEVICE_HANDLE hDev);
 
DWORD DLLCALLCONV WDC_DeviceClose(_In_ WDC_DEVICE_HANDLE hDev);
#endif
 
/* -----------------------------------------------
    Reset PCI device
   ----------------------------------------------- */
DWORD DLLCALLCONV WDC_PciResetDevice(_In_ WDC_DEVICE_HANDLE hDev);
 
DWORD WDC_CardCleanupSetup(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ WD_TRANSFER *pTransCmds, _In_ DWORD dwCmds, _In_ BOOL fForceCleanup);
 
DWORD DLLCALLCONV WDC_KernelPlugInOpen(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ const CHAR *pcKPDriverName, _In_ PVOID pKPOpenData);
 
DWORD DLLCALLCONV WDC_CallKerPlug(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ DWORD dwMsg, _Inout_ PVOID pData, _Outptr_ PDWORD pdwResult);
 
#define WDC_ReadMem8(addr, off) *(volatile BYTE *)((UPTR)(addr) + (UPTR)(off))
 
#define WDC_ReadMem16(addr, off) \
    *(volatile WORD *)((UPTR)(addr) + (UPTR)(off))
 
#define WDC_ReadMem32(addr, off) \
    *(volatile UINT32 *)((UPTR)(addr) + (UPTR)(off))
 
#define WDC_ReadMem64(addr, off) \
    *(volatile UINT64 *)((UPTR)(addr) + (UPTR)(off))
 
 
#define WDC_WriteMem8(addr, off, val) \
    *(volatile BYTE * )(((UPTR)(addr) + (UPTR)(off))) = (val)
 
#define WDC_WriteMem16(addr, off, val) \
    *(volatile WORD * )(((UPTR)(addr) + (UPTR)(off))) = (val)
 
#define WDC_WriteMem32(addr, off, val) \
    *(volatile UINT32 *)(((UPTR)(addr) + (UPTR)(off))) = (val)
 
#define WDC_WriteMem64(addr, off, val) \
    *(volatile UINT64 *)(((UPTR)(addr) + (UPTR)(off))) = (val)
 
 
DWORD DLLCALLCONV WDC_ReadAddr8(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ DWORD dwAddrSpace, _In_ KPTR dwOffset, _Outptr_ BYTE *pbVal);
 
DWORD DLLCALLCONV WDC_ReadAddr16(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ DWORD dwAddrSpace, _In_ KPTR dwOffset, _Outptr_ WORD *pwVal);
 
DWORD DLLCALLCONV WDC_ReadAddr32(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ DWORD dwAddrSpace, _In_ KPTR dwOffset, _Outptr_ UINT32 *pdwVal);
 
DWORD DLLCALLCONV WDC_ReadAddr64(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ DWORD dwAddrSpace, _In_ KPTR dwOffset, _Outptr_ UINT64 *pqwVal);
 
DWORD DLLCALLCONV WDC_ReadAddrByAddrDesc8(_In_ struct WDC_ADDR_DESC *pAddrDesc,
    _In_ KPTR dwOffset, _In_ BYTE *pbVal);
 
DWORD DLLCALLCONV WDC_ReadAddrByAddrDesc16(_In_ struct WDC_ADDR_DESC *pAddrDesc,
    _In_ KPTR dwOffset, _In_ WORD *pwVal);
 
DWORD DLLCALLCONV WDC_ReadAddrByAddrDesc32(_In_ struct WDC_ADDR_DESC *pAddrDesc,
    _In_ KPTR dwOffset, _In_ UINT32 *pdwVal);
 
DWORD DLLCALLCONV WDC_ReadAddrByAddrDesc64(_In_ struct WDC_ADDR_DESC *pAddrDesc,
    _In_ KPTR dwOffset, _In_ UINT64 *pqwVal);
 
DWORD DLLCALLCONV WDC_WriteAddr8(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ DWORD dwAddrSpace, _In_ KPTR dwOffset, _In_ BYTE bVal);
 
DWORD DLLCALLCONV WDC_WriteAddr16(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ DWORD dwAddrSpace, _In_ KPTR dwOffset, _In_ WORD wVal);
 
DWORD DLLCALLCONV WDC_WriteAddr32(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ DWORD dwAddrSpace, _In_ KPTR dwOffset, _In_ UINT32 dwVal);
 
DWORD DLLCALLCONV WDC_WriteAddr64(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ DWORD dwAddrSpace, _In_ KPTR dwOffset, _In_ UINT64 qwVal);
 
DWORD DLLCALLCONV WDC_WriteAddrByAddrDesc8(_In_ struct WDC_ADDR_DESC *pAddrDesc,
    _In_ KPTR dwOffset, _In_ BYTE bVal);
 
DWORD DLLCALLCONV WDC_WriteAddrByAddrDesc16(_In_ struct WDC_ADDR_DESC *pAddrDesc,
    _In_ KPTR dwOffset, _In_ WORD wVal);
 
DWORD DLLCALLCONV WDC_WriteAddrByAddrDesc32(_In_ struct WDC_ADDR_DESC *pAddrDesc,
    _In_ KPTR dwOffset, _In_ UINT32 dwVal);
 
DWORD DLLCALLCONV WDC_WriteAddrByAddrDesc64(_In_ struct WDC_ADDR_DESC *pAddrDesc,
    _In_ KPTR dwOffset, _In_ UINT64 qwVal);
 
 
DWORD DLLCALLCONV WDC_ReadAddrBlock(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ DWORD dwAddrSpace,_In_ KPTR dwOffset, _In_ UINT64 u64Bytes,
    _Outptr_ PVOID pData, _In_ WDC_ADDR_MODE mode,
    _In_ WDC_ADDR_RW_OPTIONS options);
 
DWORD DLLCALLCONV WDC_WriteAddrBlock(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ DWORD dwAddrSpace, _In_ KPTR dwOffset, _In_ UINT64 u64Bytes,
    _In_ PVOID pData, _In_ WDC_ADDR_MODE mode,
    _In_ WDC_ADDR_RW_OPTIONS options);
 
/* @snippet highlevel_examples.c WDC_ReadAddrBlock8 */
#define WDC_ReadAddrBlock8(hDev,dwAddrSpace,dwOffset,dwBytes,pData,options) \
    WDC_ReadAddrBlock(hDev, dwAddrSpace, dwOffset, dwBytes, pData, \
        WDC_MODE_8, options)
 
/* @snippet highlevel_examples.c WDC_ReadAddrBlock16 */
#define WDC_ReadAddrBlock16(hDev,dwAddrSpace,dwOffset,dwBytes,pData,options) \
    WDC_ReadAddrBlock(hDev, dwAddrSpace, dwOffset, dwBytes, pData, \
        WDC_MODE_16, options)
 
/* @snippet highlevel_examples.c WDC_ReadAddrBlock32 */
#define WDC_ReadAddrBlock32(hDev,dwAddrSpace,dwOffset,dwBytes,pData,options) \
    WDC_ReadAddrBlock(hDev, dwAddrSpace, dwOffset, dwBytes, pData, \
        WDC_MODE_32, options)
 
/* @snippet highlevel_examples.c WDC_ReadAddrBlock64 */
#define WDC_ReadAddrBlock64(hDev,dwAddrSpace,dwOffset,dwBytes,pData,options) \
    WDC_ReadAddrBlock(hDev, dwAddrSpace, dwOffset, dwBytes, pData, \
        WDC_MODE_64, options)
 
/* @snippet highlevel_examples.c WDC_WriteAddrBlock8 */
#define WDC_WriteAddrBlock8(hDev,dwAddrSpace,dwOffset,dwBytes,pData,options) \
    WDC_WriteAddrBlock(hDev, dwAddrSpace, dwOffset, dwBytes, pData, \
        WDC_MODE_8, options)
 
/* @snippet highlevel_examples.c WDC_WriteAddrBlock16 */
#define WDC_WriteAddrBlock16(hDev,dwAddrSpace,dwOffset,dwBytes,pData,options) \
    WDC_WriteAddrBlock(hDev, dwAddrSpace, dwOffset, dwBytes, pData, \
        WDC_MODE_16, options)
 
/* @snippet highlevel_examples.c WDC_WriteAddrBlock32 */
#define WDC_WriteAddrBlock32(hDev,dwAddrSpace,dwOffset,dwBytes,pData,options) \
    WDC_WriteAddrBlock(hDev, dwAddrSpace, dwOffset, dwBytes, pData, \
        WDC_MODE_32, options)
 
/* @snippet highlevel_examples.c WDC_WriteAddrBlock64 */
#define WDC_WriteAddrBlock64(hDev,dwAddrSpace,dwOffset,dwBytes,pData,options) \
    WDC_WriteAddrBlock(hDev, dwAddrSpace, dwOffset, dwBytes, pData, \
        WDC_MODE_64, options)
 
DWORD DLLCALLCONV WDC_MultiTransfer(_In_ WD_TRANSFER *pTransCmds,
    _In_ DWORD dwNumTrans);
 
BOOL DLLCALLCONV WDC_AddrSpaceIsActive(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ DWORD dwAddrSpace);
 
DWORD DLLCALLCONV WDC_PciReadCfgBySlot(_In_ WD_PCI_SLOT *pPciSlot,
    _In_ DWORD dwOffset, _Outptr_ PVOID pData, _In_ DWORD dwBytes);
 
DWORD DLLCALLCONV WDC_PciWriteCfgBySlot(_In_ WD_PCI_SLOT *pPciSlot,
    _In_ DWORD dwOffset, _In_ PVOID pData, _In_ DWORD dwBytes);
 
 
DWORD DLLCALLCONV WDC_PciReadCfg(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ DWORD dwOffset, _Outptr_ PVOID pData, _In_ DWORD dwBytes);
 
DWORD DLLCALLCONV WDC_PciWriteCfg(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ DWORD dwOffset, _In_ PVOID pData, _In_ DWORD dwBytes);
 
DWORD DLLCALLCONV WDC_PciReadCfgBySlot8(_In_ WD_PCI_SLOT *pPciSlot,
     _In_ DWORD dwOffset, _Outptr_ BYTE *pbVal);
 
DWORD DLLCALLCONV WDC_PciReadCfgBySlot16(_In_ WD_PCI_SLOT *pPciSlot,
    _In_ DWORD dwOffset, _Outptr_ WORD *pwVal);
 
DWORD DLLCALLCONV WDC_PciReadCfgBySlot32(_In_ WD_PCI_SLOT *pPciSlot,
    _In_ DWORD dwOffset, _Outptr_ UINT32 *pdwVal);
 
DWORD DLLCALLCONV WDC_PciReadCfgBySlot64(_In_ WD_PCI_SLOT *pPciSlot,
    _In_ DWORD dwOffset, _Outptr_ UINT64 *pqwVal);
 
DWORD DLLCALLCONV WDC_PciWriteCfgBySlot8(_In_ WD_PCI_SLOT *pPciSlot,
    _In_ DWORD dwOffset, _In_ BYTE bVal);
 
DWORD DLLCALLCONV WDC_PciWriteCfgBySlot16(_In_ WD_PCI_SLOT *pPciSlot,
    _In_ DWORD dwOffset, _In_ WORD wVal);
 
DWORD DLLCALLCONV WDC_PciWriteCfgBySlot32(_In_ WD_PCI_SLOT *pPciSlot,
    _In_ DWORD dwOffset, _In_ UINT32 dwVal);
 
DWORD DLLCALLCONV WDC_PciWriteCfgBySlot64(_In_ WD_PCI_SLOT *pPciSlot,
    _In_ DWORD dwOffset, _In_ UINT64 qwVal);
 
DWORD DLLCALLCONV WDC_PciReadCfg8(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ DWORD dwOffset, _Outptr_ BYTE *pbVal);
 
DWORD DLLCALLCONV WDC_PciReadCfg16(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ DWORD dwOffset, _Outptr_ WORD *pwVal);
 
DWORD DLLCALLCONV WDC_PciReadCfg32(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ DWORD dwOffset, _Outptr_ UINT32 *pdwVal);
 
DWORD DLLCALLCONV WDC_PciReadCfg64(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ DWORD dwOffset, _Outptr_ UINT64 *pqwVal);
 
DWORD DLLCALLCONV WDC_PciWriteCfg8(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ DWORD dwOffset, _In_ BYTE bVal);
 
DWORD DLLCALLCONV WDC_PciWriteCfg16(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ DWORD dwOffset, _In_ WORD wVal);
 
DWORD DLLCALLCONV WDC_PciWriteCfg32(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ DWORD dwOffset, _In_ UINT32 dwVal);
 
DWORD DLLCALLCONV WDC_PciWriteCfg64(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ DWORD dwOffset, _In_ UINT64 qwVal);
 
#if !defined(__KERNEL__)
DWORD DLLCALLCONV WDC_DMAContigBufLock(_In_ WDC_DEVICE_HANDLE hDev,
    _Outptr_ PVOID *ppBuf, _In_ DWORD dwOptions, _In_ DWORD dwDMABufSize,
    _Outptr_ WD_DMA **ppDma);
 
DWORD DLLCALLCONV WDC_DMASGBufLock(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ PVOID pBuf, _In_ DWORD dwOptions, _In_ DWORD dwDMABufSize,
    _Outptr_ WD_DMA **ppDma);
 
 
typedef struct {
    WD_TRANSFER *pTransCmds;
    DWORD dwNumCmds;
    DWORD dwOptions;
    INT_HANDLER funcIntHandler;
    PVOID pData;
    BOOL fUseKP;
} WDC_INTERRUPT_PARAMS;
 
DWORD DLLCALLCONV WDC_DMATransactionContigInit(_In_ WDC_DEVICE_HANDLE hDev,
    _Outptr_ PVOID *ppBuf, _In_ DWORD dwOptions, _In_ DWORD dwDMABufSize,
    _Outptr_ WD_DMA **ppDma, _In_ WDC_INTERRUPT_PARAMS *pInterruptParams,
    _In_ DWORD dwAlignment);
 
DWORD DLLCALLCONV WDC_DMATransactionSGInit(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ PVOID pBuf, _In_ DWORD dwOptions, _In_ DWORD dwDMABufSize,
    _Outptr_ WD_DMA **ppDma, _In_ WDC_INTERRUPT_PARAMS *pInterruptParams,
    _In_ DWORD dwMaxTransferSize, _In_ DWORD dwTransferElementSize);
 
DWORD DLLCALLCONV WDC_DMATransactionExecute(_Inout_ WD_DMA *pDma,
    _In_ DMA_TRANSACTION_CALLBACK funcDMATransactionCallback,
    _In_ PVOID DMATransactionCallbackCtx);
 
DWORD DLLCALLCONV WDC_DMATransferCompletedAndCheck(_Inout_ WD_DMA *pDma,
    _In_ BOOL fRunCallback);
 
DWORD DLLCALLCONV WDC_DMATransactionRelease(_In_ WD_DMA *pDma);
 
DWORD DLLCALLCONV WDC_DMATransactionUninit(_In_ WD_DMA *pDma);
 
DWORD DLLCALLCONV WDC_DMAReservedBufLock(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ PHYS_ADDR qwAddr, _Outptr_ PVOID *ppBuf, _In_ DWORD dwOptions,
    _In_ DWORD dwDMABufSize, _Outptr_ WD_DMA **ppDma);
 
 
DWORD DLLCALLCONV WDC_DMABufUnlock(_In_ WD_DMA *pDma);
 
#define WDC_DMAGetGlobalHandle(pDma) ((pDma)->hDma)
 
DWORD DLLCALLCONV WDC_DMABufGet(_In_ DWORD hDma, _Outptr_ WD_DMA **ppDma);
 
DWORD DLLCALLCONV WDC_DMASyncCpu(_In_ WD_DMA *pDma);
 
DWORD DLLCALLCONV WDC_DMASyncIo(_In_ WD_DMA *pDma);
#endif
/* -----------------------------------------------
    Interrupts
   ----------------------------------------------- */
#if !defined(__KERNEL__)
DWORD DLLCALLCONV WDC_IntEnable(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ WD_TRANSFER *pTransCmds, _In_ DWORD dwNumCmds, _In_ DWORD dwOptions,
    _In_ INT_HANDLER funcIntHandler, _In_ PVOID pData, _In_ BOOL fUseKP);
 
DWORD DLLCALLCONV WDC_IntDisable(_In_ WDC_DEVICE_HANDLE hDev);
 
#endif
 
BOOL DLLCALLCONV WDC_IntIsEnabled(_In_ WDC_DEVICE_HANDLE hDev);
 
const CHAR * DLLCALLCONV WDC_IntType2Str(_In_ DWORD dwIntType);
 
#if !defined(__KERNEL__)
DWORD DLLCALLCONV WDC_EventRegister(_In_ WDC_DEVICE_HANDLE hDev,
    _In_ DWORD dwActions, _In_ EVENT_HANDLER funcEventHandler,
    _In_ PVOID pData, _In_ BOOL fUseKP);
 
DWORD DLLCALLCONV WDC_EventUnregister(_In_ WDC_DEVICE_HANDLE hDev);
 
#endif
 
BOOL DLLCALLCONV WDC_EventIsRegistered(_In_ WDC_DEVICE_HANDLE hDev);
 
DWORD DLLCALLCONV WDC_SetDebugOptions(_In_ WDC_DBG_OPTIONS dbgOptions,
    _In_ const CHAR *pcDbgFile);
 
void DLLCALLCONV WDC_Err(const CHAR *format, ...);
 
void DLLCALLCONV WDC_Trace(const CHAR *format, ...);
 
#ifdef __cplusplus
}
#endif
 
#endif /* _WDC_LIB_H_ */