////////////////////////////////////////////////////////////////
// File - P9054_LIB.C
//
// Library for 'WinDriver for PLX 9054' API. 
// The basic idea is to get a handle for the board
// with P9054_Open() and use it in the rest of the program
// when calling WD functions.  Call P9054_Close() when done.
// 
// Copyright (c) 2003 Jungo Ltd.  http://www.jungo.com
// 
////////////////////////////////////////////////////////////////

#include "p9054_lib.h"
#include "windrvr_int_thread.h"
#include "status_strings.h"
#if !defined(__KERNEL__) 
    #include <stdio.h>
#endif

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

// internal data structures and enum definitions 
enum { P9054_DMA_CHANNEL_SHIFT = 0x14 }; // shift in address between channels 0 and 1 of DMA

typedef struct P9054_DMA_STRUCT{
    WD_DMA dmaList;
    P9054_DMA_CHANNEL dmaChannel;
    WD_DMA dma;
} P9054_DMA_STRUCT;

enum { P9054_MODE_DESC       = 0xF9000140 };
enum { P9054_MODE_DESC_BYTE  = 0x00000000 };
enum { P9054_MODE_DESC_WORD  = 0x00010001 };
enum { P9054_MODE_DESC_DWORD = 0x00030003 };

typedef struct
{
    WD_INTERRUPT Int;
    HANDLE hThread;
    WD_TRANSFER Trans[2];
    P9054_INT_HANDLER funcIntHandler;
} P9054_INTERRUPT;

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

typedef struct P9054_STRUCT
{
    HANDLE hWD;
    WD_CARD cardLock;
    WD_PCI_SLOT pciSlot;
    WD_CARD_REGISTER cardReg;
    P9054_ADDR_DESC addrDesc[AD_PCI_BARS];
    DWORD  addrSpace;
    P9054_INTERRUPT Int;
} P9054_STRUCT;

// internal function used by P9054_Open()
BOOL P9054_DetectCardElements(P9054_HANDLE hPlx);
// internal function used by P9054_Read... and P9054_Write... functions
void P9054_SetMode (P9054_HANDLE hPlx, DWORD dwLocalAddr);

void P9054_RegisterWinDriver()
{
    HANDLE hWD;
    WD_LICENSE lic;

    hWD = WD_Open();
    if (hWD!=INVALID_HANDLE_VALUE)
    {
         strcpy(lic.cLicense, "6C3CC2BFF76637EC556BF9D50D98F518FD246109.dzz");
         WD_License(hWD, &lic);
         WD_Close(hWD);
    }
}

BOOL P9054_CheckVersion()
{
    HANDLE hWD = INVALID_HANDLE_VALUE;
    DWORD dwStatus;
    WD_VERSION ver;

    hWD = WD_Open();
    // check if handle valid & version OK
    if (hWD==INVALID_HANDLE_VALUE) 
    {
        sprintf(P9054_ErrorString, "Failed opening " WD_PROD_NAME " device\n");
        return FALSE;
    }
    BZERO(ver);
    dwStatus = WD_Version(hWD, &ver);
    WD_Close (hWD);
    if (dwStatus)
    {
        sprintf(P9054_ErrorString, "WD_Version() failed with status 0x%x - %s\n",
            dwStatus, Stat2Str(dwStatus));
        return FALSE;
    }
    if (ver.dwVer<WD_VER)
    {
        sprintf(P9054_ErrorString, "Incorrect " WD_PROD_NAME " version. "
            "expected %d.%02d, got %d.%02d\n",
            WD_VER/100, WD_VER%100, ver.dwVer/100, ver.dwVer%100);
        return FALSE;
    }
    return TRUE;
}

DWORD P9054_CountCards (DWORD dwVendorID, DWORD dwDeviceID)
{
    WD_PCI_SCAN_CARDS pciScan;
    HANDLE hWD = INVALID_HANDLE_VALUE;
    DWORD dwStatus;

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

    BZERO(pciScan);
    pciScan.searchId.dwVendorId = dwVendorID;
    pciScan.searchId.dwDeviceId = dwDeviceID;
    dwStatus = WD_PciScanCards(hWD, &pciScan);
    WD_Close(hWD);
    if (dwStatus)
    {
        sprintf(P9054_ErrorString, "WD_PciScanCards() failed with status 0x%x - %s\n",
            dwStatus, Stat2Str(dwStatus));
        pciScan.dwCards = 0;
    }
    else if (pciScan.dwCards==0)
        sprintf(P9054_ErrorString, "no cards found\n");
    return pciScan.dwCards;
}

BOOL P9054_Open(P9054_HANDLE *phPlx, DWORD dwVendorID, DWORD dwDeviceID, DWORD nCardNum)
{
    P9054_HANDLE hPlx = (P9054_HANDLE) malloc (sizeof (P9054_STRUCT));
    DWORD dwIntStatus;
    DWORD dwStatus;

    WD_PCI_SCAN_CARDS pciScan;
    WD_PCI_CARD_INFO pciCardInfo;

    *phPlx = NULL;
    P9054_ErrorString[0] = '\0';
    if (!P9054_CheckVersion())
        return FALSE;
    BZERO(*hPlx);

    hPlx->hWD = WD_Open();

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

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

    BZERO(pciCardInfo);
    pciCardInfo.pciSlot = pciScan.cardSlot[nCardNum];
    dwStatus = WD_PciGetCardInfo(hPlx->hWD, &pciCardInfo);
    if (dwStatus)
    {
        sprintf(P9054_ErrorString, "WD_PciGetCardInfo() failed with status 0x%x - %s\n",
            dwStatus, Stat2Str(dwStatus));
        goto Exit;
    }
    hPlx->pciSlot = pciCardInfo.pciSlot;
    hPlx->cardReg.Card = pciCardInfo.Card;
    hPlx->cardReg.fCheckLockOnly = FALSE;
    dwStatus = WD_CardRegister(hPlx->hWD, &hPlx->cardReg);
    if (dwStatus)
    {
        sprintf(P9054_ErrorString, "WD_CardRegister() failed with status 0x%x - %s\n",
            dwStatus, Stat2Str(dwStatus));
        goto Exit;
    }
    if (!P9054_DetectCardElements(hPlx))
    {
        sprintf(P9054_ErrorString, "Card does not have all items expected for PLX 9054\n");
        goto Exit;
    }

    // this enables target abort so it wont get stuck 
    dwIntStatus = P9054_ReadReg (hPlx, P9054_INTCSR);
    P9054_WriteReg(hPlx, P9054_INTCSR, dwIntStatus | BIT12);

    // Open finished OK
    *phPlx = hPlx;
    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 P9054_GetPciSlot(P9054_HANDLE hPlx, WD_PCI_SLOT *pPciSlot)
{
    *pPciSlot = hPlx->pciSlot;
}

DWORD P9054_ReadPCIReg(P9054_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 P9054_WritePCIReg(P9054_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 P9054_DetectCardElements(P9054_HANDLE hPlx)
{
    DWORD i;

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

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

        switch (pItem->item)
        {
        case ITEM_MEMORY:
            ad_sp = pItem->I.Mem.dwBar;
            hPlx->addrDesc[ad_sp].fIsMemory = TRUE;
            hPlx->addrDesc[ad_sp].dwBytes = pItem->I.Mem.dwBytes;
            hPlx->addrDesc[ad_sp].dwAddr = pItem->I.Mem.dwTransAddr;
            hPlx->addrDesc[ad_sp].dwAddrDirect = pItem->I.Mem.dwUserDirectAddr;
            hPlx->addrDesc[ad_sp].dwMask = ~hPlx->addrDesc[ad_sp].dwBytes;
            break;
        case ITEM_IO:
            ad_sp = pItem->I.IO.dwBar;
            hPlx->addrDesc[ad_sp].fIsMemory = FALSE;
            hPlx->addrDesc[ad_sp].dwBytes = pItem->I.Mem.dwBytes;
            hPlx->addrDesc[ad_sp].dwAddr = pItem->I.IO.dwAddr;
            hPlx->addrDesc[ad_sp].dwMask = ~hPlx->addrDesc[ad_sp].dwBytes;
            break;
        case ITEM_INTERRUPT:
            if (hPlx->Int.Int.hInterrupt) return FALSE;
            hPlx->Int.Int.hInterrupt = pItem->I.Int.hInterrupt;
            break;
        }
    }

    // Verify that at least one memory space was found
    for (i=0; i<6; i++)
        if (P9054_IsAddrSpaceActive(hPlx, i)) break;
    if (i==6)
        return FALSE;
    // use address space 0 for accessing local addresses
    hPlx->addrSpace = P9054_ADDR_SPACE0;

    return TRUE;
}

void P9054_Close(P9054_HANDLE hPlx)
{
    // disable interrupts
    if (P9054_IntIsEnabled(hPlx))
        P9054_IntDisable(hPlx);

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

    // close WinDriver
    WD_Close(hPlx->hWD);

    free (hPlx);
}

BOOL P9054_IsAddrSpaceActive(P9054_HANDLE hPlx, P9054_ADDR addrSpace)
{
    return hPlx->addrDesc[addrSpace].dwAddr!=0;
}

DWORD P9054_ReadReg (P9054_HANDLE hPlx, DWORD dwReg)
{
    return P9054_ReadDWord(hPlx, P9054_ADDR_REG, dwReg);
}

void P9054_WriteReg (P9054_HANDLE hPlx, DWORD dwReg, DWORD dwData)
{
    P9054_WriteDWord(hPlx, P9054_ADDR_REG, dwReg, dwData);
}

BYTE P9054_ReadByte (P9054_HANDLE hPlx, P9054_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 P9054_WriteByte (P9054_HANDLE hPlx, P9054_ADDR addrSpace, DWORD dwOffset,
    BYTE data)
{
    if (hPlx->addrDesc[addrSpace].fIsMemory)
    {