gt64_lib.c

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

////////////////////////////////////////////////////////////////
// File - GT64_LIB.C
//
// Library for 'DriverBuilder for Marvell GT64' API. 
// The basic idea is to get a handle for the board
// with GT64_Open() and use it in the rest of the program
// when calling WD functions.  Call GT64_Close() when done.
// 
////////////////////////////////////////////////////////////////

#include "../../../include/windrvr.h"
#include "../../../include/windrvr_int_thread.h"
#include "gt64_lib.h"
#include <stdio.h>

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

// internal function used by GT64_Open()
BOOL GT64_DetectCardElements(GT64_HANDLE hGT);

DWORD GT64_CountCards (DWORD dwVendorID, DWORD dwDeviceID)
{
    WD_VERSION ver;
    WD_PCI_SCAN_CARDS pciScan;
    HANDLE hWD = INVALID_HANDLE_VALUE;

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

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


BOOL GT64_Open(GT64_HANDLE *phGT, GT64_VERSION gt64Ver, DWORD dwVendorID, DWORD dwDeviceID, DWORD nCardNum)
{
    GT64_HANDLE hGT = (GT64_HANDLE) malloc (sizeof (GT64_STRUCT));

    WD_VERSION ver;
    WD_PCI_SCAN_CARDS pciScan;
    WD_PCI_CARD_INFO pciCardInfo;

    *phGT = NULL;
    GT64_ErrorString[0] = '\0';
    BZERO(*hGT);

    hGT->hWD = WD_Open();

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

    BZERO(ver);
    WD_Version(hGT->hWD,&ver);
    if (ver.dwVer<WD_VER) 
    {
        sprintf( GT64_ErrorString, "Incorrect " WD_PROD_NAME " version\n");
        goto Exit;
    }
    hGT->gt64Ver = gt64Ver;
    BZERO(pciScan);
    pciScan.searchId.dwVendorId = dwVendorID;
    pciScan.searchId.dwDeviceId = dwDeviceID;
    WD_PciScanCards (hGT->hWD, &pciScan);
    if (pciScan.dwCards==0) // Found at least one card
    {
        sprintf( GT64_ErrorString, "Could not find PCI card\n");
        goto Exit;
    }
    if (pciScan.dwCards<=nCardNum)
    {
        sprintf( GT64_ErrorString, "Card out of range of available cards\n");
        goto Exit;
    }

    BZERO(pciCardInfo);
    pciCardInfo.pciSlot = pciScan.cardSlot[nCardNum];
    WD_PciGetCardInfo (hGT->hWD, &pciCardInfo);
    hGT->pciSlot = pciCardInfo.pciSlot;
    hGT->cardReg.Card = pciCardInfo.Card;

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

    if (!GT64_DetectCardElements(hGT))
    {
        sprintf ( GT64_ErrorString, "Card does not have all items expected for Marvell GT64\n");
        goto Exit;
    }

    // Open finished OK
    *phGT = hGT;
    return TRUE;

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

DWORD GT64_ReadPCIReg(GT64_HANDLE hGT, DWORD dwReg)
{
    WD_PCI_CONFIG_DUMP pciCnf;
    DWORD dwVal;

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

void GT64_WritePCIReg(GT64_HANDLE hGT, DWORD dwReg, DWORD dwData)
{
    WD_PCI_CONFIG_DUMP pciCnf;

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

BOOL GT64_DetectCardElements(GT64_HANDLE hGT)
{
    DWORD i;
    DWORD ad_sp;

    BZERO(hGT->Int);
    BZERO(hGT->addrDesc);

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

        switch (pItem->item)
        {
        case ITEM_MEMORY:
        case ITEM_IO:
            {
                DWORD dwBytes;
                DWORD dwAddr;
                DWORD dwPhysAddr;
                DWORD dwAddrDirect = 0;
                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=GT64_ADDR_BAR0; ad_sp<=GT64_ADDR_BAR5; ad_sp++)
                {
                    DWORD dwPCIAddr;
                    DWORD dwPCIReg;

                    if (hGT->addrDesc[ad_sp].dwAddr) continue;
                    else if (ad_sp<GT64_ADDR_BAR5) 
                        dwPCIReg = PCI_BAR0 + 4*(ad_sp-GT64_ADDR_BAR0);
                    else dwPCIReg = PCI_ERBAR;
                    dwPCIAddr = GT64_ReadPCIReg(hGT, dwPCIReg);
                    if (dwPCIAddr & 1)
                    {
                        if (fIsMemory) continue;
                        dwPCIAddr &= 0x0ffffffc;
                        dwPhysAddr &= 0x0ffffffc;
                    }
                    else
                    {
                        if (!fIsMemory) continue;
                        dwPCIAddr &= ~0xf;
                    }
                    if (dwPCIAddr==dwPhysAddr)
                        break;
                }
                if (ad_sp<=GT64_ADDR_BAR5)
                {
                    DWORD j;
                    hGT->addrDesc[ad_sp].dwBytes = dwBytes;
                    hGT->addrDesc[ad_sp].dwAddr = dwAddr;
                    hGT->addrDesc[ad_sp].dwAddrDirect = dwAddrDirect;
                    hGT->addrDesc[ad_sp].fIsMemory = fIsMemory;
                    hGT->addrDesc[ad_sp].dwMask = 0;
                    for (j=1; j<hGT->addrDesc[ad_sp].dwBytes && j!=0x80000000; j *= 2)
                    {
                        hGT->addrDesc[ad_sp].dwMask = 
                            (hGT->addrDesc[ad_sp].dwMask << 1) | 1;
                    }
                }
            }
            break;
        case ITEM_INTERRUPT:
            if (hGT->Int.Int.hInterrupt) return FALSE;
            hGT->Int.Int.hInterrupt = pItem->I.Int.hInterrupt;
            break;
        }
    }

    // check that all the items needed were found
    // check if interrupt found
    if (!hGT->Int.Int.hInterrupt) 
        return FALSE;

    // check that the registers space was found
    if (!GT64_IsAddrSpaceActive(hGT, GT64_ADDR_REG)) 
            //|| hGT->addrDesc[GT64_ADDR_REG].dwBytes!=GT64_RANGE_REG)
        return FALSE;

    // check that address space 0 was found
    if (!GT64_IsAddrSpaceActive(hGT, GT64_ADDR_BAR0)) return FALSE;

    return TRUE;
}

void GT64_Close(GT64_HANDLE hGT)
{
    // disable interrupts
    if (GT64_IntIsEnabled(hGT))
        GT64_IntDisable(hGT);

    // unregister card
    if (hGT->cardReg.hCard) 
        WD_CardUnregister(hGT->hWD, &hGT->cardReg);

    // close DriverBuilder
    WD_Close(hGT->hWD);

    free (hGT);
}

BOOL GT64_IsAddrSpaceActive(GT64_HANDLE hGT, GT64_ADDR addrSpace)
{
    return hGT->addrDesc[addrSpace].dwAddr!=0;
}

DWORD GT64_ReadReg (GT64_HANDLE hGT, DWORD dwReg)
{
    return GT64_ReadDWord(hGT, GT64_ADDR_REG, dwReg);
}

void GT64_WriteReg (GT64_HANDLE hGT, DWORD dwReg, DWORD dwData)
{
    GT64_WriteDWord(hGT, GT64_ADDR_REG, dwReg, dwData);
}