p9056_lib.h

Jungo公司确实为VxWorks开发了类似于WinDriver的驱动开发辅助套件DriverBuilder (for VxWorks)！

#ifndef _P9056_LIB_H_
#define _P9056_LIB_H_

#if !defined(UNIX) && (defined(LINUX) || defined(SOLARIS))
    #define UNIX
#endif

#if defined(__KERNEL__)
    #include "../../../include/kdstdlib.h"
#endif 
#include "../../../include/windrvr.h"
#include "../../../samples/shared/pci_regs.h"
#include "../../../samples/shared/bits.h"

#ifdef __cplusplus
extern "C" {
#endif

// PLX register definitions 
enum {
    P9056_LAS0RR    = 0x00,
    P9056_LAS0BA    = 0x04,
    P9056_PCISR     = 0x06,
    P9056_MARBR     = 0x08,
    P9056_BIGEND    = 0x0c,
    P9056_LMISC     = 0x0d,
    P9056_PROT_AREA = 0x0e,
    P9056_PCIBISTR  = 0x0f,
    P9056_EROMRR    = 0x10,
    P9056_EROMBA    = 0x14,
    P9056_LBRD0     = 0x18,
    P9056_DMRR      = 0x1c,
    P9056_DMLBAM    = 0x20,
    P9056_DMLBAI    = 0x24,
    P9056_DMPBAM    = 0x28,
    P9056_DMCFGA    = 0x2c,
    P9056_OPQIS     = 0x30,
    P9056_OPQIM     = 0x34,
    P9056_IQP       = 0x40,
    P9056_OQP       = 0x44,
    P9056_MQCR      = 0xc0,
    P9056_QBAR      = 0xc4,
    P9056_MBOX0     = 0x78, 
    P9056_MBOX1     = 0x7c,  
    P9056_MBOX2     = 0x48,
    P9056_HS_CSR    = 0x4a,
    P9056_MBOX3     = 0x4c,
    P9056_MBOX4     = 0x50,
    P9056_MBOX5     = 0x54,
    P9056_MBOX6     = 0x58,
    P9056_MBOX7     = 0x5c,
    P9056_P2LDBELL  = 0x60,
    P9056_L2PDBELL  = 0x64,
    P9056_INTCSR    = 0x68,
    P9056_CNTRL     = 0x6c,
    P9056_PCIHIDR   = 0x70,
    P9056_PCIHREV   = 0x74,
    P9056_DMAMODE   = 0x80,
    P9056_DMAPADR   = 0x84,
    P9056_DMALADR   = 0x88,
    P9056_DMASIZ    = 0x8c,
    P9056_DMADPR    = 0x90,
    P9056_DMAMODE1  = 0x94,
    P9056_DMAPADR1  = 0x98,
    P9056_DMALADR1  = 0x9c,
    P9056_DMASIZ1   = 0xa0,
    P9056_DMADPR1   = 0xa4,
    P9056_DMACSR    = 0xa8,
    P9056_DMACSR1   = 0xa9,
    P9056_DMAARB    = 0xac,
    P9056_DMATHR    = 0xb0,
    P9056_DMADAC0   = 0xb4,
    P9056_DMADAC1   = 0xb8,
    P9056_IFHPR     = 0xc8,
    P9056_IFTPR     = 0xcc,
    P9056_IPHPR     = 0xd0,
    P9056_IPTPR     = 0xd4,
    P9056_OFHPR     = 0xd8,
    P9056_OFTPR     = 0xdc,
    P9056_OPHPR     = 0xe0,
    P9056_OPTPR     = 0xe4,
    P9056_QSR       = 0xe8,
    P9056_LAS1RR    = 0xf0,
    P9056_LAS1BA    = 0xf4,
    P9056_LBRD1     = 0xf8,
    P9056_DMDAC     = 0xfc,
    P9056_PCIARB    = 0x100,
    P9056_PABTADR   = 0x104 
};

// PLX specific PCI configuration registers
enum {
    P9056_VPD_CNTL   = 0x4c,
    P9056_VPD_NEXT   = 0x4d,
    P9056_VPD_ADDR   = 0x4E,
    P9056_VPD_DATA   = 0x50
};

typedef enum
{
    P9056_DMA_CHANNEL_0 = 0,
    P9056_DMA_CHANNEL_1 = 1
} P9056_DMA_CHANNEL;

typedef enum
{
    P9056_MODE_BYTE   = 0,
    P9056_MODE_WORD   = 1,
    P9056_MODE_DWORD  = 2
} P9056_MODE;

typedef enum
{
    P9056_ADDR_REG     = AD_PCI_BAR0,
    P9056_ADDR_REG_IO  = AD_PCI_BAR1,
    P9056_ADDR_SPACE0  = AD_PCI_BAR2,
    P9056_ADDR_SPACE1  = AD_PCI_BAR3,
    P9056_ADDR_SPACE2  = AD_PCI_BAR4,
    P9056_ADDR_SPACE3  = AD_PCI_BAR5,
    P9056_ADDR_EPROM   = AD_PCI_BAR_EPROM
} P9056_ADDR;

enum { P9056_RANGE_REG = 0x00000080 };

typedef struct P9056_DMA_STRUCT *P9056_DMA_HANDLE;

typedef struct P9056_STRUCT *P9056_HANDLE;

typedef struct
{
    DWORD dwCounter;   // number of interrupts received
    DWORD dwLost;      // number of interrupts not yet dealt with
    BOOL fStopped;     // was interrupt disabled during wait
    DWORD dwStatusReg; // value of status register when interrupt occurred
} P9056_INT_RESULT;
typedef void (WINAPI *P9056_INT_HANDLER)( P9056_HANDLE hPlx, P9056_INT_RESULT *intResult);

DWORD P9056_CountCards (DWORD dwVendorID, DWORD dwDeviceID);
BOOL P9056_Open(P9056_HANDLE *phPlx, DWORD dwVendorID, DWORD dwDeviceID, DWORD nCardNum);
void P9056_Close (P9056_HANDLE hPlx);
BOOL P9056_IsAddrSpaceActive(P9056_HANDLE hPlx, P9056_ADDR addrSpace);
void P9056_GetPciSlot(P9056_HANDLE hPlx, WD_PCI_SLOT *pPciSlot);

void P9056_ReadWriteBlockLocal (P9056_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
                    DWORD dwBytes, BOOL fIsRead, P9056_MODE mode);
void P9056_ReadBlockLocal (P9056_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, DWORD dwBytes, P9056_MODE mode);
void P9056_WriteBlockLocal (P9056_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, DWORD dwBytes, P9056_MODE mode);
BYTE P9056_ReadByteLocal (P9056_HANDLE hPlx, DWORD dwLocalAddr);
void P9056_WriteByteLocal (P9056_HANDLE hPlx, DWORD dwLocalAddr, BYTE data);
WORD P9056_ReadWordLocal (P9056_HANDLE hPlx, DWORD dwLocalAddr);
void P9056_WriteWordLocal (P9056_HANDLE hPlx, DWORD dwLocalAddr, WORD data);
DWORD P9056_ReadDWordLocal (P9056_HANDLE hPlx, DWORD dwLocalAddr);
void P9056_WriteDWordLocal (P9056_HANDLE hPlx, DWORD dwLocalAddr, DWORD data);

void P9056_ReadWriteBlock (P9056_HANDLE hPlx, DWORD dwOffset, PVOID buf, 
                    DWORD dwBytes, BOOL fIsRead, P9056_ADDR addrSpace, P9056_MODE mode);
BYTE P9056_ReadByte (P9056_HANDLE hPlx, P9056_ADDR addrSpace, DWORD dwOffset);
void P9056_WriteByte (P9056_HANDLE hPlx, P9056_ADDR addrSpace, DWORD dwOffset, BYTE data);
WORD P9056_ReadWord (P9056_HANDLE hPlx, P9056_ADDR addrSpace, DWORD dwOffset);
void P9056_WriteWord (P9056_HANDLE hPlx, P9056_ADDR addrSpace, DWORD dwOffset, WORD data);
DWORD P9056_ReadDWord (P9056_HANDLE hPlx, P9056_ADDR addrSpace, DWORD dwOffset);
void P9056_WriteDWord (P9056_HANDLE hPlx, P9056_ADDR addrSpace, DWORD dwOffset, DWORD data);
void P9056_ReadBlock (P9056_HANDLE hPlx, DWORD dwOffset, PVOID buf, 
                    DWORD dwBytes, P9056_ADDR addrSpace, P9056_MODE mode);
void P9056_WriteBlock (P9056_HANDLE hPlx, DWORD dwOffset, PVOID buf, 
                     DWORD dwBytes, P9056_ADDR addrSpace, P9056_MODE mode);

// interrupt functions
BOOL P9056_IntIsEnabled (P9056_HANDLE hPlx);
BOOL P9056_IntEnable (P9056_HANDLE hPlx, P9056_INT_HANDLER funcIntHandler);
void P9056_IntDisable (P9056_HANDLE hPlx);

// access registers
DWORD P9056_ReadReg (P9056_HANDLE hPlx, DWORD dwReg);
void P9056_WriteReg (P9056_HANDLE hPlx, DWORD dwReg, DWORD dwData);

// access PCI configuration registers
DWORD P9056_ReadPCIReg(P9056_HANDLE hPlx, DWORD dwReg);
void P9056_WritePCIReg(P9056_HANDLE hPlx, DWORD dwReg, DWORD dwData);

// Start DMA to/from card.
// fIsRead - TRUE: read from card to buffer.  FALSE: write from buffer to card
// dwBytes - number of bytes to transfer (must be a multiple of 4)
// mode - local bus width.
// dwLocalAddr - local address on card to write to / read from
// channel - uses channel 0 or 1 of the 9056
// buf - the buffer to transfer
P9056_DMA_HANDLE P9056_DMAOpen (P9056_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
    DWORD dwBytes, BOOL fIsRead, P9056_MODE mode, P9056_DMA_CHANNEL dmaChannel);
void P9056_DMAClose (P9056_HANDLE hPlx, P9056_DMA_HANDLE hDma);
void P9056_DMAStart (P9056_HANDLE hPlx, P9056_DMA_HANDLE hDma, BOOL fBlocking);
BOOL P9056_DMAIsDone (P9056_HANDLE hPlx, P9056_DMA_HANDLE hDma);
BOOL P9056_DMAReadWriteBlock (P9056_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
    DWORD dwBytes, BOOL fIsRead, P9056_MODE mode, P9056_DMA_CHANNEL dmaChannel);

BOOL P9056_EEPROMReadWord(P9056_HANDLE hPlx, DWORD dwOffset, PWORD pwData);
BOOL P9056_EEPROMWriteWord(P9056_HANDLE hPlx, DWORD dwOffset, WORD wData);
BOOL P9056_EEPROMReadDWord(P9056_HANDLE hPlx, DWORD dwOffset, PDWORD pdwData);
BOOL P9056_EEPROMWriteDWord(P9056_HANDLE hPlx, DWORD dwOffset, DWORD dwData);
BOOL P9056_EEPROMValid(P9056_HANDLE hPlx);

// this string is set to an error message, if one occurs
extern CHAR P9056_ErrorString[];

#ifdef __cplusplus
}
#endif

#endif