p9050_lib.c

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

{
    // commented by pgn	
    /*
    // disable interrupts
    if (P9050_IntIsEnabled(hPlx))
        P9050_IntDisable(hPlx);
    */

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

    free (hPlx);
}

BOOL P9050_IsAddrSpaceActive(P9050_HANDLE hPlx, P9050_ADDR addrSpace)
{
    return hPlx->addrDesc[addrSpace].dwAddr!=0;
}

DWORD P9050_ReadReg (P9050_HANDLE hPlx, DWORD dwReg)
{
    return P9050_ReadSpaceDWord(hPlx, P9050_ADDR_REG, dwReg);
}

void P9050_WriteReg (P9050_HANDLE hPlx, DWORD dwReg, DWORD dwData)
{
    P9050_WriteSpaceDWord(hPlx, P9050_ADDR_REG, dwReg, dwData);
}

void P9050_SetMode (P9050_HANDLE hPlx, P9050_ADDR addrSpace, DWORD dwLocalAddr)
{
    DWORD dwRegOffset = 4*(addrSpace-P9050_ADDR_SPACE0);
    P9050_ADDR_DESC *addrDesc = &hPlx->addrDesc[addrSpace];
    addrDesc->dwLocalBase = dwLocalAddr & ~addrDesc->dwMask;
    // commented by pgn the following two lines 
    //addrDesc->dwLocalBase |= BIT0;
    //P9050_WriteReg (hPlx, P9050_LAS0BA + dwRegOffset, addrDesc->dwLocalBase);
    
    // added by pgn the following
    if(addrSpace ==2)
    {
    	P9050_WriteReg (hPlx, T_P1_TI0_ADDR, addrDesc->dwLocalBase);//pgn
    }
    else
    {
    	P9050_WriteReg (hPlx, T_P1_TI1_ADDR, addrDesc->dwLocalBase);//pgn	
    }
    
}

BYTE P9050_ReadSpaceByte (P9050_HANDLE hPlx, P9050_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 P9050_WriteSpaceByte (P9050_HANDLE hPlx, P9050_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 P9050_ReadSpaceWord (P9050_HANDLE hPlx, P9050_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 P9050_WriteSpaceWord (P9050_HANDLE hPlx, P9050_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 P9050_ReadSpaceDWord (P9050_HANDLE hPlx, P9050_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 P9050_WriteSpaceDWord (P9050_HANDLE hPlx, P9050_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;
        BZERO(trans);
        trans.cmdTrans = WP_DWORD;
        trans.dwPort = dwAddr;
        trans.Data.Dword = data;
        WD_Transfer (hPlx->hWD, &trans);
        
    }
    
}


void P9050_ReadWriteSpaceBlock (P9050_HANDLE hPlx, DWORD dwOffset, PVOID buf, 
                    DWORD dwBytes, BOOL fIsRead, P9050_ADDR addrSpace, P9050_MODE mode)
{
    WD_TRANSFER trans;
    DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddr + dwOffset;

    BZERO(trans);

    if (hPlx->addrDesc[addrSpace].fIsMemory) 
    {
        if (fIsRead) 
        {
            if (mode==P9050_MODE_BYTE) trans.cmdTrans = RM_SBYTE;
            else if (mode==P9050_MODE_WORD) trans.cmdTrans = RM_SWORD;
            else trans.cmdTrans = RM_SDWORD;
        }
        else 
        {
            if (mode==P9050_MODE_BYTE) trans.cmdTrans = WM_SBYTE;
            else if (mode==P9050_MODE_WORD) trans.cmdTrans = WM_SWORD;
            else trans.cmdTrans = WM_SDWORD;
        }
    }
    else 
    {
        if (fIsRead) 
        {
            if (mode==P9050_MODE_BYTE) trans.cmdTrans = RP_SBYTE;
            else if (mode==P9050_MODE_WORD) trans.cmdTrans = RP_SWORD;
            else trans.cmdTrans = RP_SDWORD;
        }
        else 
        {
            if (mode==P9050_MODE_BYTE) trans.cmdTrans = WP_SBYTE;
            else if (mode==P9050_MODE_WORD) trans.cmdTrans = WP_SWORD;
            else trans.cmdTrans = WP_SDWORD;
        }
    }
    
    trans.dwPort = dwAddr;
    trans.fAutoinc = TRUE;
    trans.dwBytes = dwBytes;
    trans.dwOptions = 0;
    trans.Data.pBuffer = buf;
    WD_Transfer (hPlx->hWD, &trans);
}


void P9050_ReadSpaceBlock (P9050_HANDLE hPlx, DWORD dwOffset, PVOID buf, 
                    DWORD dwBytes, P9050_ADDR addrSpace, P9050_MODE mode)
{
    P9050_ReadWriteSpaceBlock (hPlx, dwOffset, buf, dwBytes, TRUE, addrSpace, mode);
}


void P9050_WriteSpaceBlock (P9050_HANDLE hPlx, DWORD dwOffset, PVOID buf, 
                     DWORD dwBytes, P9050_ADDR addrSpace, P9050_MODE mode)
{
    P9050_ReadWriteSpaceBlock (hPlx, dwOffset, buf, dwBytes, FALSE, addrSpace, mode);
}


BYTE P9050_ReadByte (P9050_HANDLE hPlx, P9050_ADDR addrSpace, DWORD dwLocalAddr)
{
    DWORD dwOffset = hPlx->addrDesc[addrSpace].dwMask & dwLocalAddr;
    P9050_SetMode (hPlx, addrSpace, dwLocalAddr);
    return P9050_ReadSpaceByte(hPlx, addrSpace, dwOffset);
}


void P9050_WriteByte (P9050_HANDLE hPlx, P9050_ADDR addrSpace, DWORD dwLocalAddr, BYTE data)
{
    DWORD dwOffset = hPlx->addrDesc[addrSpace].dwMask & dwLocalAddr;
    P9050_SetMode (hPlx, addrSpace, dwLocalAddr);
    P9050_WriteSpaceByte(hPlx, addrSpace, dwOffset, data);
}


WORD P9050_ReadWord (P9050_HANDLE hPlx, P9050_ADDR addrSpace, DWORD dwLocalAddr)
{
    DWORD dwOffset = hPlx->addrDesc[addrSpace].dwMask & dwLocalAddr;
    P9050_SetMode (hPlx, addrSpace, dwLocalAddr);
    return P9050_ReadSpaceWord(hPlx, addrSpace, dwOffset);
}


void P9050_WriteWord (P9050_HANDLE hPlx, P9050_ADDR addrSpace, DWORD dwLocalAddr, WORD data)
{
    DWORD dwOffset = hPlx->addrDesc[addrSpace].dwMask & dwLocalAddr;
    P9050_SetMode (hPlx, addrSpace, dwLocalAddr);
    P9050_WriteSpaceWord(hPlx, addrSpace, dwOffset, data);
}


DWORD P9050_ReadDWord (P9050_HANDLE hPlx, P9050_ADDR addrSpace, DWORD dwLocalAddr)
{
    DWORD dwOffset = hPlx->addrDesc[addrSpace].dwMask & dwLocalAddr;
    P9050_SetMode (hPlx, addrSpace, dwLocalAddr);
    return P9050_ReadSpaceDWord(hPlx, addrSpace, dwOffset);
}


void P9050_WriteDWord (P9050_HANDLE hPlx, P9050_ADDR addrSpace, DWORD dwLocalAddr, DWORD data)
{
    DWORD dwOffset = hPlx->addrDesc[addrSpace].dwMask & dwLocalAddr;
    P9050_SetMode (hPlx, addrSpace, dwLocalAddr);
    P9050_WriteSpaceDWord(hPlx, addrSpace, dwOffset, data);
}


void P9050_ReadWriteBlock (P9050_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
                    DWORD dwBytes, BOOL fIsRead, P9050_ADDR addrSpace, P9050_MODE mode)
{
    DWORD dwOffset = hPlx->addrDesc[addrSpace].dwMask & dwLocalAddr;
    P9050_SetMode (hPlx, addrSpace, dwLocalAddr);
    P9050_ReadWriteSpaceBlock(hPlx, dwOffset, buf, dwBytes, fIsRead, addrSpace, mode);
}


void P9050_ReadBlock (P9050_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
                    DWORD dwBytes, P9050_ADDR addrSpace, P9050_MODE mode)
{
    P9050_ReadWriteBlock (hPlx, dwLocalAddr, buf, dwBytes, TRUE, addrSpace, mode);
}


void P9050_WriteBlock (P9050_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
                     DWORD dwBytes, P9050_ADDR addrSpace, P9050_MODE mode)
{
    P9050_ReadWriteBlock (hPlx, dwLocalAddr, buf, dwBytes, FALSE, addrSpace, mode);
}



BOOL P9050_IntIsEnabled (P9050_HANDLE hPlx)
{
    if (!hPlx->Int.hThread)
        return FALSE;
    return TRUE;
}


void P9050_IntHandler (PVOID pData)
{
    // commented begin by pgn
    /*		
    P9050_HANDLE hPlx = (P9050_HANDLE) pData;
    P9050_INT_RESULT intResult;
    
    intResult.dwCounter = hPlx->Int.Int.dwCounter;
    intResult.dwLost = hPlx->Int.Int.dwLost;
    intResult.fStopped = hPlx->Int.Int.fStopped;
    intResult.dwStatusReg = hPlx->Int.Trans[0].Data.Dword;
    hPlx->Int.funcIntHandler(hPlx, &intResult);
    */
    // commented end by pgn
    
    // Here is the user's interrupt routine
    
    P9050_HANDLE hPlx = (P9050_HANDLE) pData;
    P9050_INT_RESULT intResult;
    DWORD dwIntStatus;
    
    //dwIntStatus = P9050_ReadReg (hPlx, P9050_INTCSR);
    //P9050_WriteReg (hPlx, P9050_INTCSR, dwIntStatus & ~BIT6); // put here the data to write to the control register
    
    // here is the user code to do something
    logMsg("Now is in the user's interrupt routine.\n" );
    
    // this physically enables interrupts
    //P9050_WriteReg (hPlx, P9050_INTCSR, dwIntStatus | BIT6);
       
    return;