p9050_lib.c

powerspan pci slave device driver

////////////////////////////////////////////////////////////////
// File - P9050_LIB.C
//
// Library for 'DriverBuilder for PLX 9050' API. 
// The basic idea is to get a handle for the board
// with P9050_Open() and use it in the rest of the program
// when calling WD functions.  Call P9050_Close() when done.
// 
////////////////////////////////////////////////////////////////

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

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

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

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

typedef struct P9050_STRUCT
{
    HANDLE hWD;
    WD_CARD cardLock;
    WD_PCI_SLOT pciSlot;
    WD_CARD_REGISTER cardReg;
    P9050_ADDR_DESC addrDesc[AD_PCI_BARS];
    P9050_INTERRUPT Int;
} P9050_STRUCT;

// internal function used by P9050_Open()
BOOL P9050_DetectCardElements(P9050_HANDLE hPlx);
// internal function used by P9050_Read... and P9050_Write... functions
void P9050_SetMode (P9050_HANDLE hPlx, P9050_ADDR addrSpace, DWORD dwLocalAddr);

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

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

    BZERO(ver);
    WD_Version(hWD,&ver);
    if (ver.dwVer<WD_VER) 
    {
        sprintf( P9050_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( P9050_ErrorString, "no cards found\n");
    return pciScan.dwCards;
    */
	    
}


BOOL P9050_Open (P9050_HANDLE *phPlx, DWORD dwVendorID, DWORD dwDeviceID, DWORD nCardNum, DWORD options)
{
    P9050_HANDLE hPlx = (P9050_HANDLE) malloc (sizeof (P9050_STRUCT));

    WD_VERSION ver;
    WD_PCI_SCAN_CARDS pciScan;
    WD_PCI_CARD_INFO pciCardInfo;
    DWORD dwData;

    int li;

    *phPlx = NULL;
    P9050_ErrorString[0] = '\0';
    BZERO(*hPlx);

    hPlx->hWD = WD_Open();
    
    /* // commented begin by pgn
    // check if handle valid & version OK
    if (hPlx->hWD==INVALID_HANDLE_VALUE) 
    {
        sprintf( P9050_ErrorString, "Failed opening " WD_PROD_NAME " device\n");
        goto Exit;
    }

    BZERO(ver);
    WD_Version(hPlx->hWD,&ver);
    if (ver.dwVer<WD_VER) 
    {
        sprintf( P9050_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( P9050_ErrorString, "Could not find PCI card\n");
        goto Exit;
    }
    if (pciScan.dwCards<=nCardNum)
    {
        sprintf( P9050_ErrorString, "Card out of range of available cards\n");
        goto Exit;
    }

    BZERO(pciCardInfo);
    pciCardInfo.pciSlot = pciScan.cardSlot[nCardNum];
    hPlx->pciSlot = pciCardInfo.pciSlot;
    */ // commented end by pgn

    if (options & P9050_OPEN_FIX_BIT7)
    {
        // this section fixes the BIT7 errata on PLX 9050 chip
        dwData = P9050_ReadPCIReg(hPlx, PCI_BAR0) & ~BIT7;
        P9050_WritePCIReg(hPlx, PCI_BAR0, dwData);
        // There is usually no need to fix also BAR1
        //dwData = P9050_ReadPCIReg(hPlx, PCI_BAR1) & ~BIT7;
        //P9050_WritePCIReg(hPlx, PCI_BAR1, dwData);
    }
    
    /* //commented begin by pgn
    WD_PciGetCardInfo (hPlx->hWD, &pciCardInfo);
    hPlx->cardReg.Card = pciCardInfo.Card;

    hPlx->cardReg.fCheckLockOnly = FALSE;
    WD_CardRegister (hPlx->hWD, &hPlx->cardReg);
    if (hPlx->cardReg.hCard==0)
    {
        sprintf ( P9050_ErrorString, "Failed locking device\n");
        goto Exit;
    }

    if (!P9050_DetectCardElements(hPlx))
    {
        sprintf ( P9050_ErrorString, "Card does not have all items expected for PLX 9050\n");
        goto Exit;
    }
    */ // commented end by pgn

    // Open finished OK
    *phPlx = hPlx;
    
    /*
    // added begin by pgn
    // hWD
    printf("hPlx->hWD = 0x%x.\n",hPlx->hWD);
    
    //cardReg
    printf("hPlx->cardReg.Card.dwItems = 0x%x.\n",hPlx->cardReg.Card.dwItems);
    for(li=0;li<5;li++)
    {
    	printf("hPlx->cardReg.Card.Item[0x%x].item = 0x%x.\n",li,hPlx->cardReg.Card.Item[li].item);
    	printf("hPlx->cardReg.Card.Item[0x%x].fNotSharable = 0x%x.\n",li,hPlx->cardReg.Card.Item[li].fNotSharable);
    	switch(hPlx->cardReg.Card.Item[li].item)
    	{
    	    case ITEM_MEMORY:
    	    printf("hPlx->cardReg.Card.Item[0x%x].I.Mem.dwPhysicalAddr = 0x%x\n",li,hPlx->cardReg.Card.Item[li].I.Mem.dwPhysicalAddr);
    	    printf("hPlx->cardReg.Card.Item[0x%x].I.Mem.dwBytes = 0x%x.\n",li,hPlx->cardReg.Card.Item[li].I.Mem.dwBytes);
    	    printf("hPlx->cardReg.Card.Item[0x%x].I.Mem.dwTransAddr = 0x%x.\n",li,hPlx->cardReg.Card.Item[li].I.Mem.dwTransAddr);
    	    printf("hPlx->cardReg.Card.Item[0x%x].I.Mem.dwUserDirectAddr = 0x%x.\n",li,hPlx->cardReg.Card.Item[li].I.Mem.dwUserDirectAddr);
    	    printf("hPlx->cardReg.Card.Item[0x%x].I.Mem.dwCpuPhysicalAddr = 0x%x.\n",li,hPlx->cardReg.Card.Item[li].I.Mem.dwCpuPhysicalAddr);
    	    break;
    	    
    	    case ITEM_IO:
    	    printf("hPlx->cardReg.Card.Item[0x%x].I.IO.dwAddr = 0x%x\n",li,hPlx->cardReg.Card.Item[li].I.IO.dwAddr);
    	    printf("hPlx->cardReg.Card.Item[0x%x].I.IO.dwBytes = 0x%x\n",li,hPlx->cardReg.Card.Item[li].I.IO.dwBytes);
    	    break;
    		
    	    default:
    	    break;
    	}
    }
    
    //addrDesc
    for(li=0;li<6;li++)
    {
    	    printf("\n\n");
    	    printf(" hPlx->addrDesc[0x%d].dwLocalBase is 0x%x\n", li,hPlx->addrDesc[li].dwLocalBase);
	    printf(" hPlx->addrDesc[0x%d].dwBytes is 0x%x\n", li,hPlx->addrDesc[li].dwBytes);
	    printf(" hPlx->addrDesc[0x%d].dwAddr is 0x%x\n", li,hPlx->addrDesc[li].dwAddr);
	    printf(" hPlx->addrDesc[0x%d].dwAddrDirect is 0x%x\n", li,hPlx->addrDesc[li].dwAddrDirect);
	    printf(" hPlx->addrDesc[0x%d].fIsMemory is 0x%x\n", li,hPlx->addrDesc[li].fIsMemory);
	    printf(" hPlx->addrDesc[0x%d].dwMask is 0x%x\n", li,hPlx->addrDesc[li].dwMask);
	    printf("\n\n"); 
   	
    }
    
    //pciSlot
    printf(" hPlx->pciSlot.dwBus is 0x%x\n", hPlx->pciSlot.dwBus);
    printf(" hPlx->pciSlot.dwSlot is 0x%x\n", hPlx->pciSlot.dwSlot);
    printf(" hPlx->pciSlot.dwFunction is 0x%x\n", hPlx->pciSlot.dwFunction);
    
    // added end by pgn
    */
    
    
    // added begin by pgn
    hPlx->addrDesc[0].dwLocalBase=0;
    hPlx->addrDesc[0].dwBytes=0x100;
    hPlx->addrDesc[0].dwAddr=0xf6040000;
    hPlx->addrDesc[0].dwAddrDirect=0xf6040000;
    hPlx->addrDesc[0].fIsMemory=1;
    hPlx->addrDesc[0].dwMask=0xff;
    
    hPlx->addrDesc[1].dwLocalBase=0;
    hPlx->addrDesc[1].dwBytes=0x100;
    hPlx->addrDesc[1].dwAddr=0x2000;
    hPlx->addrDesc[1].dwAddrDirect=0x2000;
    hPlx->addrDesc[1].fIsMemory=0;
    hPlx->addrDesc[1].dwMask=0xff;    
    
    hPlx->addrDesc[2].dwLocalBase=0;
    hPlx->addrDesc[2].dwBytes= 0x40000;
    hPlx->addrDesc[2].dwAddr=0xf6000000;
    hPlx->addrDesc[2].dwAddrDirect=0xf6000000;
    hPlx->addrDesc[2].fIsMemory=1;
    hPlx->addrDesc[2].dwMask=0x3ffff;      
    
    
    hPlx->pciSlot.dwBus  =3;
    hPlx->pciSlot.dwSlot=0xc;
    hPlx->pciSlot.dwFunction=0;
    // added end by pgn
    
    
    return TRUE;

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


void P9050_GetPciSlot(P9050_HANDLE hPlx, WD_PCI_SLOT *pPciSlot)
{
    *pPciSlot = hPlx->pciSlot;
}


DWORD P9050_ReadPCIReg(P9050_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 P9050_WritePCIReg(P9050_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 P9050_DetectCardElements(P9050_HANDLE hPlx)
{
	
    return TRUE;
    
    /*
    DWORD i;
    DWORD ad_sp;
    
    BZERO(hPlx->Int);
    BZERO(hPlx->addrDesc);
    
    // added by pgn for debug use 
    printf("hPlx->cardReg.Card.dwItems is 0x%x.\n\n",hPlx->cardReg.Card.dwItems);
    // added end by pgn

    for (i=0; i<hPlx->cardReg.Card.dwItems; i++)
    {
        WD_ITEMS *pItem = &hPlx->cardReg.Card.Item[i];

        switch (pItem->item)
        {
        case ITEM_MEMORY:
        case ITEM_IO:
            {
                DWORD dwBytes;
                DWORD dwAddr;
                DWORD dwAddrDirect = 0;
                DWORD dwPhysAddr;
                BOOL fIsMemory;
                if (pItem->item==ITEM_MEMORY)
                {
                    dwBytes = pItem->I.Mem.dwBytes;
                    dwAddr = pItem->I.Mem.dwTransAddr;
                    dwAddrDirect = pItem->I.Mem.dwUserDirectAddr;
                    dwPhysAddr = pItem->I.Mem.dwPhysicalAddr;
                    fIsMemory = TRUE;
                }
                else 
                {
                    dwBytes = pItem->I.IO.dwBytes;
                    dwAddr = pItem->I.IO.dwAddr;
                    dwPhysAddr = dwAddr & 0xffff;
                    fIsMemory = FALSE;
                }

                for (ad_sp=P9050_ADDR_REG; ad_sp<=P9050_ADDR_EPROM; ad_sp++)
                {
                    DWORD dwPCIAddr;
                    DWORD dwPCIReg;

                    if (hPlx->addrDesc[ad_sp].dwAddr) continue;
                    if (ad_sp==P9050_ADDR_REG) dwPCIReg = PCI_BAR0;
                    else if (ad_sp<P9050_ADDR_EPROM) 
                        dwPCIReg = PCI_BAR2 + 4*(ad_sp-P9050_ADDR_SPACE0);
                    else dwPCIReg = PCI_ERBAR;
                    dwPCIAddr = P9050_ReadPCIReg(hPlx, dwPCIReg);
                    if (dwPCIAddr & 1)
                    {
                        if (fIsMemory) continue;
                        dwPCIAddr &= 0x0ffffffc;
                        dwPhysAddr &= 0x0ffffffc;
                    }
                    else
                    {
                        if (!fIsMemory) continue;
                        dwPCIAddr &= ~0xf;
                    }
                    if (dwPCIAddr==dwPhysAddr)
                        break;