pspan_lib.c

adlink master board 6760 pci driver for control powerspan slave pci driver

////////////////////////////////////////////////////////////////
// File - PSPAN_LIB.C
//
// Library for PspanII API. 
// The basic idea is to get a handle for the board
// with PSPAN_Open() and use it in the rest of the program
// when calling WD functions.  Call PSPAN_Close() when done.
// 
////////////////////////////////////////////////////////////////

#include "pspan_lib.h"
#include "../../../include/windrvr_int_thread.h"
#include <stdio.h>


#define PSPAN_LIB_DEBUG
#undef PSPAN_LIB_DEBUG

#ifdef  PSPAN_LIB_DEBUG
    #define pspan_lib_printf    printf
#else
    #define pspan_lib_printf
#endif
         

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

// internal data structures
typedef struct
{
    WD_INTERRUPT Int;
    HANDLE hThread;
    WD_TRANSFER Trans[2];
    PSPAN_INT_HANDLER funcIntHandler;
} PSPAN_INTERRUPT;

typedef struct
{
    DWORD dwLocalBase;
    DWORD dwMask;
    DWORD dwBytes;
    DWORD dwAddr;
    DWORD dwAddrDirect;
    BOOL  fIsMemory;
} PSPAN_ADDR_DESC;

typedef struct PSPAN_STRUCT
{
    HANDLE hWD;
    WD_CARD cardLock;
    WD_PCI_SLOT pciSlot;
    WD_CARD_REGISTER cardReg;
    PSPAN_ADDR_DESC addrDesc[AD_PCI_BARS];
    PSPAN_INTERRUPT Int;
} PSPAN_STRUCT;

// internal function used by PSPAN_Open()
BOOL PSPAN_DetectCardElements(PSPAN_HANDLE hPlx);

// internal function used by PSPAN_Read... and PSPAN_Write... functions
void PSPAN_SetMode (PSPAN_HANDLE hPlx, PSPAN_ADDR addrSpace, DWORD dwLocalAddr);

DWORD PSPAN_CountCards (DWORD dwVendorID, DWORD dwDeviceID)
{
    //return 1;
   
    WD_VERSION ver;
    WD_PCI_SCAN_CARDS pciScan;
    HANDLE hWD = INVALID_HANDLE_VALUE;

    PSPAN_ErrorString[0] = '\0';
    hWD = WD_OpenLocal_Pspan();
    // check if handle valid & version OK
    if (hWD==INVALID_HANDLE_VALUE) 
    {
        sprintf( PSPAN_ErrorString, "Failed opening " WD_PROD_NAME " device\n");
        return 0;
    }

    BZERO(ver);
    WD_Version(hWD,&ver);
    if (ver.dwVer<WD_VER) 
    {
        sprintf( PSPAN_ErrorString, "Incorrect " WD_PROD_NAME " version\n");
        WD_Close (hWD);
        return 0;
    }

    BZERO(pciScan);
    pciScan.searchId.dwVendorId = dwVendorID;
    pciScan.searchId.dwDeviceId = dwDeviceID;
    WD_PciScanCards (hWD, &pciScan);
    WD_Close (hWD);
    if (pciScan.dwCards==0)
        sprintf( PSPAN_ErrorString, "no cards found\n");
    return pciScan.dwCards;
	    
}


BOOL PSPAN_Open (PSPAN_HANDLE *phPlx, DWORD dwVendorID, DWORD dwDeviceID, DWORD nCardNum, DWORD options)
{
    PSPAN_HANDLE hPlx = (PSPAN_HANDLE) malloc (sizeof (PSPAN_STRUCT));

    WD_VERSION ver;
    WD_PCI_SCAN_CARDS pciScan;
    WD_PCI_CARD_INFO pciCardInfo;
    DWORD dwData;
    
    *phPlx = NULL;
    PSPAN_ErrorString[0] = '\0';
    BZERO(*hPlx);

    hPlx->hWD = WD_OpenLocal_Pspan();
    
    // check if handle valid & version OK
    if (hPlx->hWD==INVALID_HANDLE_VALUE) 
    {
        sprintf( PSPAN_ErrorString, "Failed opening " WD_PROD_NAME " device\n");
        goto Exit;
    }

    BZERO(ver);
    WD_Version(hPlx->hWD,&ver);
    if (ver.dwVer<WD_VER) 
    {
        sprintf( PSPAN_ErrorString, "Incorrect " WD_PROD_NAME " version\n");
        goto Exit;
    }
    

    BZERO(pciScan);
    pciScan.searchId.dwVendorId = dwVendorID;
    pciScan.searchId.dwDeviceId = dwDeviceID;
    WD_PciScanCards (hPlx->hWD, &pciScan);
    if (pciScan.dwCards==0) // Found at least one card
    {
        sprintf( PSPAN_ErrorString, "Could not find PCI card\n");
        goto Exit;
    }
    if (pciScan.dwCards<=nCardNum)
    {
        sprintf( PSPAN_ErrorString, "Card out of range of available cards\n");
        goto Exit;
    }

    BZERO(pciCardInfo);
    pciCardInfo.pciSlot = pciScan.cardSlot[nCardNum];
    hPlx->pciSlot = pciCardInfo.pciSlot;


    if (options & PSPAN_OPEN_FIX_BIT7)
    {
        // this section fixes the BIT7 errata on PSPAN chip
        dwData = PSPAN_ReadPCIReg(hPlx, PCI_BAR0) & ~BIT7;
        PSPAN_WritePCIReg(hPlx, PCI_BAR0, dwData);
        // There is usually no need to fix also BAR1
        //dwData = PSPAN_ReadPCIReg(hPlx, PCI_BAR1) & ~BIT7;
        //PSPAN_WritePCIReg(hPlx, PCI_BAR1, dwData);
    }
    
    /*
    /// added begin by pgn
    dwData = PSPAN_ReadPCIReg(hPlx, 4) |7;
    PSPAN_WritePCIReg(hPlx, 4, dwData);    
    // added end by pgn
    */
    
    WD_PciGetCardInfo (hPlx->hWD, &pciCardInfo);
    hPlx->cardReg.Card = pciCardInfo.Card;

    hPlx->cardReg.fCheckLockOnly = FALSE;
    //WD_CardRegister (hPlx->hWD, &hPlx->cardReg); //commented by pgn
    WD_CardRegister (hPlx->hWD, hPlx);		   // replaced by pgn

    if (hPlx->cardReg.hCard==0)
    {
        sprintf ( PSPAN_ErrorString, "Failed locking device\n");
        goto Exit;
    }

    if (!PSPAN_DetectCardElements(hPlx))
    {
        sprintf ( PSPAN_ErrorString, "Card does not have all items expected for PSPAN\n");
        goto Exit;
    }

    // Added begin by pgn for debug use
    pspan_lib_printf("hPlx->addrDesc[1].dwLocalBase is %x\n",hPlx->addrDesc[1].dwLocalBase);
    pspan_lib_printf("hPlx->addrDesc[1].dwBytes is %x\n",hPlx->addrDesc[1].dwBytes);
    pspan_lib_printf("hPlx->addrDesc[1].dwAddr   is %x\n",hPlx->addrDesc[1].dwAddr);
    pspan_lib_printf("hPlx->addrDesc[1].dwAddrDirect is %x\n",hPlx->addrDesc[1].dwAddrDirect);
    pspan_lib_printf("hPlx->addrDesc[1].fIsMemory is %x\n",hPlx->addrDesc[1].fIsMemory);
    pspan_lib_printf("hPlx->addrDesc[1].dwMask is %x\n",hPlx->addrDesc[1].dwMask);
    // Added end by pgn for debug use   
    
    // Open finished OK
    *phPlx = hPlx;
    
    return TRUE;

Exit:
    // Error during Open
    if (hPlx->cardReg.hCard) 
        //WD_CardUnregister(hPlx->hWD, &hPlx->cardReg); // commented by pgn
        WD_CardUnregister(hPlx->hWD, hPlx);		// replaced by pgn
    if (hPlx->hWD!=INVALID_HANDLE_VALUE)
        WD_Close(hPlx->hWD);
    free (hPlx);
    return FALSE;
}


void PSPAN_GetPciSlot(PSPAN_HANDLE hPlx, WD_PCI_SLOT *pPciSlot)
{
    *pPciSlot = hPlx->pciSlot;
}


DWORD PSPAN_ReadPCIReg(PSPAN_HANDLE hPlx, DWORD dwReg)
{
    WD_PCI_CONFIG_DUMP pciCnf;
    DWORD dwVal;

    BZERO (pciCnf);
    pciCnf.pciSlot = hPlx->pciSlot;
    pciCnf.pBuffer = &dwVal;
    pciCnf.dwOffset = dwReg;
    pciCnf.dwBytes = 4;
    pciCnf.fIsRead = TRUE;
    WD_PciConfigDump(hPlx->hWD,&pciCnf);
    return dwVal;
}

void PSPAN_WritePCIReg(PSPAN_HANDLE hPlx, DWORD dwReg, DWORD dwData)
{
    WD_PCI_CONFIG_DUMP pciCnf;

    BZERO (pciCnf);
    pciCnf.pciSlot = hPlx->pciSlot;
    pciCnf.pBuffer = &dwData;
    pciCnf.dwOffset = dwReg;
    pciCnf.dwBytes = 4;
    pciCnf.fIsRead = FALSE;
    WD_PciConfigDump(hPlx->hWD,&pciCnf);
}

BOOL PSPAN_DetectCardElements(PSPAN_HANDLE hPlx)
{
	
    return TRUE;	// added by pgn
   
}

void PSPAN_Close(PSPAN_HANDLE hPlx)
{
    // commented by pgn	
    /*
    // disable interrupts
    if (PSPAN_IntIsEnabled(hPlx))
        PSPAN_IntDisable(hPlx);
    */

    // unregister card
    if (hPlx->cardReg.hCard) 
        WD_CardUnregister(hPlx->hWD, &hPlx->cardReg);
    
	
    // close DriverBuilder
    WD_Close(hPlx->hWD);

    free (hPlx);
    
}

BOOL PSPAN_IsAddrSpaceActive(PSPAN_HANDLE hPlx, PSPAN_ADDR addrSpace)
{
    return hPlx->addrDesc[addrSpace].dwAddr!=0;
}

DWORD PSPAN_ReadReg (PSPAN_HANDLE hPlx, DWORD dwReg)
{
    return PSPAN_ReadSpaceDWord(hPlx, PSPAN_ADDR_REG, dwReg);
}

void PSPAN_WriteReg (PSPAN_HANDLE hPlx, DWORD dwReg, DWORD dwData)
{
    PSPAN_WriteSpaceDWord(hPlx, PSPAN_ADDR_REG, dwReg, dwData);
}

void PSPAN_SetMode (PSPAN_HANDLE hPlx, PSPAN_ADDR addrSpace, DWORD dwLocalAddr)
{
	
    DWORD dwRegOffset = 4*(addrSpace-PSPAN_ADDR_SPACE0);
    PSPAN_ADDR_DESC *addrDesc = &hPlx->addrDesc[addrSpace];
    addrDesc->dwLocalBase = dwLocalAddr & ~addrDesc->dwMask;
    
    // added by pgn the following
    if(addrSpace ==2)
    {
    	PSPAN_WriteReg (hPlx, T_P1_TI0_ADDR, addrDesc->dwLocalBase);//pgn
    }
    else if(addrSpace ==3)
    {
    	PSPAN_WriteReg (hPlx, T_P1_TI1_ADDR, addrDesc->dwLocalBase);//pgn	
    }
    else
    {
        ;
    }
    
    
}

BYTE PSPAN_ReadSpaceByte (PSPAN_HANDLE hPlx, PSPAN_ADDR addrSpace, DWORD dwOffset)
{
    if (hPlx->addrDesc[addrSpace].fIsMemory)
    {
        DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddrDirect + dwOffset;
        BYTE *pByte = (BYTE *) dwAddr;
        return *pByte;
    }
    else
    {
        DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddr + dwOffset;
        WD_TRANSFER trans;
        BZERO(trans);
        trans.cmdTrans = RP_BYTE;
        trans.dwPort = dwAddr;
        WD_Transfer (hPlx->hWD, &trans);
        return trans.Data.Byte;
    }
}

void PSPAN_WriteSpaceByte (PSPAN_HANDLE hPlx, PSPAN_ADDR addrSpace, DWORD dwOffset, BYTE data)
{
    if (hPlx->addrDesc[addrSpace].fIsMemory)
    {
        DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddrDirect + dwOffset;
        BYTE *pByte = (BYTE *) dwAddr;
        *pByte = data;
    }
    else
    {
        DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddr + dwOffset;
        WD_TRANSFER trans;
        BZERO(trans);
        trans.cmdTrans = WP_BYTE;
        trans.dwPort = dwAddr;
        trans.Data.Byte = data;
        WD_Transfer (hPlx->hWD, &trans);
    }
}


WORD PSPAN_ReadSpaceWord (PSPAN_HANDLE hPlx, PSPAN_ADDR addrSpace, DWORD dwOffset)
{
    if (hPlx->addrDesc[addrSpace].fIsMemory)
    {
        DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddrDirect + dwOffset;
        WORD *pWord = (WORD *) dwAddr;
        return *pWord;
    }
    else
    {
        DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddr + dwOffset;
        WD_TRANSFER trans;
        BZERO(trans);
        trans.cmdTrans = RP_WORD;
        trans.dwPort = dwAddr;
        WD_Transfer (hPlx->hWD, &trans);
        return trans.Data.Word;
    }
}


void PSPAN_WriteSpaceWord (PSPAN_HANDLE hPlx, PSPAN_ADDR addrSpace, DWORD dwOffset, WORD data)
{
    if (hPlx->addrDesc[addrSpace].fIsMemory)
    {
        DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddrDirect + dwOffset;
        WORD *pWord = (WORD *) dwAddr;
        *pWord = data;
    }
    else
    {
        DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddr + dwOffset;
        WD_TRANSFER trans;
        BZERO(trans);
        trans.cmdTrans = WP_WORD;
        trans.dwPort = dwAddr;
        trans.Data.Word = data;
        WD_Transfer (hPlx->hWD, &trans);
    }
    
}

DWORD PSPAN_ReadSpaceDWord (PSPAN_HANDLE hPlx, PSPAN_ADDR addrSpace, DWORD dwOffset)
{
    if (hPlx->addrDesc[addrSpace].fIsMemory)
    {
        DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddrDirect + dwOffset;
        DWORD *pDword = (DWORD *) dwAddr;
        return *pDword;
    }
    else
    {
        DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddr + dwOffset;
        
        WD_TRANSFER trans;
        BZERO(trans);
        trans.cmdTrans = RP_DWORD;
        trans.dwPort = dwAddr;
        WD_Transfer (hPlx->hWD, &trans);
        return trans.Data.Dword;
        
    }
}


void PSPAN_WriteSpaceDWord (PSPAN_HANDLE hPlx, PSPAN_ADDR addrSpace, DWORD dwOffset, DWORD data)
{

    int li;
    long ll;
    
    int number;
    short pVendorId;
    short pDeviceId;
    int   pBusNo;
    int   pDeviceNo;
    int   pFuncNo;
     
    if (hPlx->addrDesc[addrSpace].fIsMemory)
    {
        DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddrDirect + dwOffset;
        DWORD *pDword = (DWORD *) dwAddr;
        *pDword = data;
    }
    else
    {
        DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddr + dwOffset;
        
        WD_TRANSFER trans;