p9054_lib.c

driver linux for windows 2

        *pWord = dtoh16(data);
    }
    else
    {
        KPTR 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);
    }
}

UINT32 P9054_ReadDWord (P9054_HANDLE hPlx, P9054_ADDR addrSpace, DWORD dwOffset)
{
    if (hPlx->addrDesc[addrSpace].fIsMemory)
    {
        DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddrDirect + dwOffset;
        UINT32 *pDword = (UINT32 *) dwAddr;
        return dtoh32(*pDword);
    }
    else
    {
        KPTR 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 P9054_WriteDWord (P9054_HANDLE hPlx, P9054_ADDR addrSpace, DWORD dwOffset, UINT32 data)
{
    if (hPlx->addrDesc[addrSpace].fIsMemory)
    {
        DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddrDirect + dwOffset;
        UINT32 *pDword = (UINT32 *) dwAddr;
        *pDword = dtoh32(data);
    }
    else
    {
        KPTR 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 P9054_ReadWriteBlock (P9054_HANDLE hPlx, DWORD dwOffset, PVOID buf, 
    DWORD dwBytes, BOOL fIsRead, P9054_ADDR addrSpace, P9054_MODE mode)
{
    KPTR dwAddr = hPlx->addrDesc[addrSpace].dwAddr + dwOffset;
    WD_TRANSFER trans;

    BZERO(trans);

    if (hPlx->addrDesc[addrSpace].fIsMemory) 
    {
        if (fIsRead) 
        {
            if (mode==P9054_MODE_BYTE) trans.cmdTrans = RM_SBYTE;
            else if (mode==P9054_MODE_WORD) trans.cmdTrans = RM_SWORD;
            else trans.cmdTrans = RM_SDWORD;
        }
        else 
        {
            if (mode==P9054_MODE_BYTE) trans.cmdTrans = WM_SBYTE;
            else if (mode==P9054_MODE_WORD) trans.cmdTrans = WM_SWORD;
            else trans.cmdTrans = WM_SDWORD;
        }
    }
    else 
    {
        if (fIsRead) 
        {
            if (mode==P9054_MODE_BYTE) trans.cmdTrans = RP_SBYTE;
            else if (mode==P9054_MODE_WORD) trans.cmdTrans = RP_SWORD;
            else trans.cmdTrans = RP_SDWORD;
        }
        else 
        {
            if (mode==P9054_MODE_BYTE) trans.cmdTrans = WP_SBYTE;
            else if (mode==P9054_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 P9054_ReadBlock (P9054_HANDLE hPlx, DWORD dwOffset, PVOID buf, 
    DWORD dwBytes, P9054_ADDR addrSpace, P9054_MODE mode)
{
    P9054_ReadWriteBlock (hPlx, dwOffset, buf, dwBytes, TRUE, addrSpace, mode);
}

void P9054_WriteBlock (P9054_HANDLE hPlx, DWORD dwOffset, PVOID buf, 
    DWORD dwBytes, P9054_ADDR addrSpace, P9054_MODE mode)
{
    P9054_ReadWriteBlock (hPlx, dwOffset, buf, dwBytes, FALSE, addrSpace, mode);
}

void P9054_SetMode (P9054_HANDLE hPlx, DWORD dwLocalAddr)
{
    hPlx->addrDesc[hPlx->addrSpace].dwLocalBase = dwLocalAddr & ~hPlx->addrDesc[hPlx->addrSpace].dwMask;
    hPlx->addrDesc[hPlx->addrSpace].dwLocalBase |= BIT0;
    P9054_WriteReg (hPlx, P9054_LAS0BA, hPlx->addrDesc[hPlx->addrSpace].dwLocalBase);
}

BYTE P9054_ReadByteLocal (P9054_HANDLE hPlx, DWORD dwLocalAddr)
{
    DWORD dwOffset = hPlx->addrDesc[hPlx->addrSpace].dwMask & dwLocalAddr;
    P9054_SetMode (hPlx, dwLocalAddr);
    return P9054_ReadByte(hPlx, hPlx->addrSpace, dwOffset);
}

void P9054_WriteByteLocal (P9054_HANDLE hPlx, DWORD dwLocalAddr, BYTE data)
{
    DWORD dwOffset = hPlx->addrDesc[hPlx->addrSpace].dwMask & dwLocalAddr;
    P9054_SetMode (hPlx, dwLocalAddr);
    P9054_WriteByte(hPlx, hPlx->addrSpace, dwOffset, data);
}

WORD P9054_ReadWordLocal (P9054_HANDLE hPlx, DWORD dwLocalAddr)
{
    DWORD dwOffset = hPlx->addrDesc[hPlx->addrSpace].dwMask & dwLocalAddr;
    P9054_SetMode (hPlx, dwLocalAddr);
    return P9054_ReadWord(hPlx, hPlx->addrSpace, dwOffset);
}

void P9054_WriteWordLocal (P9054_HANDLE hPlx, DWORD dwLocalAddr, WORD data)
{
    DWORD dwOffset = hPlx->addrDesc[hPlx->addrSpace].dwMask & dwLocalAddr;
    P9054_SetMode (hPlx, dwLocalAddr);
    P9054_WriteWord(hPlx, hPlx->addrSpace, dwOffset, data);
}

UINT32 P9054_ReadDWordLocal (P9054_HANDLE hPlx, DWORD dwLocalAddr)
{
    DWORD dwOffset = hPlx->addrDesc[hPlx->addrSpace].dwMask & dwLocalAddr;
    P9054_SetMode (hPlx, dwLocalAddr);
    return P9054_ReadDWord(hPlx, hPlx->addrSpace, dwOffset);
}

void P9054_WriteDWordLocal (P9054_HANDLE hPlx, DWORD dwLocalAddr, UINT32 data)
{
    DWORD dwOffset = hPlx->addrDesc[hPlx->addrSpace].dwMask & dwLocalAddr;
    P9054_SetMode (hPlx, dwLocalAddr);
    P9054_WriteDWord(hPlx, hPlx->addrSpace, dwOffset, data);
}

void P9054_ReadWriteBlockLocal (P9054_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
                    DWORD dwBytes, BOOL fIsRead, P9054_MODE mode)
{
    DWORD dwOffset = hPlx->addrDesc[hPlx->addrSpace].dwMask & dwLocalAddr;
    P9054_SetMode (hPlx, dwLocalAddr);
    P9054_ReadWriteBlock(hPlx, dwOffset, buf, dwBytes, fIsRead, hPlx->addrSpace, mode);
}

void P9054_ReadBlockLocal (P9054_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
                    DWORD dwBytes, P9054_MODE mode)
{
    P9054_ReadWriteBlockLocal (hPlx, dwLocalAddr, buf, dwBytes, TRUE, mode);
}

void P9054_WriteBlockLocal (P9054_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
                     DWORD dwBytes, P9054_MODE mode)
{
    P9054_ReadWriteBlockLocal (hPlx, dwLocalAddr, buf, dwBytes, FALSE, mode);
}

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

VOID DLLCALLCONV P9054_IntHandler (PVOID pData)
{
    P9054_HANDLE hPlx = (P9054_HANDLE) pData;
    P9054_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);  
}

BOOL P9054_IntEnable (P9054_HANDLE hPlx, P9054_INT_HANDLER funcIntHandler)
{
    UINT32 dwIntStatus;
    KPTR dwAddr;
    DWORD dwStatus;

    // check if interrupt is already enabled
    if (hPlx->Int.hThread)
        return FALSE;

    dwIntStatus = P9054_ReadReg (hPlx, P9054_INTCSR);

    BZERO(hPlx->Int.Trans);
    // This is a sample of handling interrupts:
    // Two transfer commands are issued. First the value of the interrupt control/status
    // register is read. Then, a value of ZERO is written.
    // This will cancel interrupts after the first interrupt occurs.
    // When using interrupts, this section will have to change:
    // you must put transfer commands to CANCEL the source of the interrupt, otherwise, the 
    // PC will hang when an interrupt occurs!
    dwAddr = hPlx->addrDesc[AD_PCI_BAR0].dwAddr + P9054_INTCSR;
    hPlx->Int.Trans[0].cmdTrans = hPlx->addrDesc[AD_PCI_BAR0].fIsMemory ? RM_DWORD : RP_DWORD;
    hPlx->Int.Trans[0].dwPort = dwAddr;
    hPlx->Int.Trans[1].cmdTrans = hPlx->addrDesc[AD_PCI_BAR0].fIsMemory ? WM_DWORD : WP_DWORD;
    hPlx->Int.Trans[1].dwPort = dwAddr;
    hPlx->Int.Trans[1].Data.Dword = dwIntStatus & ~(BIT8|BIT10); // put here the data to write to the control register
    hPlx->Int.Int.dwCmds = 2; 
    hPlx->Int.Int.Cmd = hPlx->Int.Trans;
    hPlx->Int.Int.dwOptions |= INTERRUPT_CMD_COPY;

    // this calls WD_IntEnable() and creates an interrupt handler thread
    hPlx->Int.funcIntHandler = funcIntHandler;
    dwStatus = InterruptEnable(&hPlx->Int.hThread, hPlx->hWD, &hPlx->Int.Int, P9054_IntHandler, (PVOID) hPlx);
    if (dwStatus)
    {
        sprintf(P9054_ErrorString, "Enabling interrupts failed with status 0x%lx - %s\n",
            dwStatus, Stat2Str(dwStatus));
        return FALSE;
    }

    // this physically enables interrupts
    P9054_WriteReg (hPlx, P9054_INTCSR, dwIntStatus | (BIT8|BIT10));

    return TRUE;
}

void P9054_IntDisable (P9054_HANDLE hPlx)
{
    DWORD dwIntStatus;

    if (!hPlx->Int.hThread)
        return;

    // this disables interrupts
    dwIntStatus = P9054_ReadReg (hPlx, P9054_INTCSR);
    P9054_WriteReg (hPlx, P9054_INTCSR, dwIntStatus & ~(BIT8|BIT10));

    // this calls WD_IntDisable()
    InterruptDisable(hPlx->Int.hThread);
    hPlx->Int.hThread = NULL;
}

void P9054_DMAReadWriteKernelBlock (P9054_HANDLE hPlx, P9054_DMA_HANDLE hDma, PVOID buf, DWORD dwBytes, BOOL fIsRead)
{
    WD_TRANSFER trans;

    BZERO(trans);

    trans.cmdTrans = fIsRead ? RM_SBYTE : WM_SBYTE;
    trans.dwPort = hDma->dma.pKernelAddr;
    trans.fAutoinc = TRUE;
    trans.dwBytes = dwBytes;
    trans.dwOptions = 0;
    trans.Data.pBuffer = buf;
    WD_Transfer (hPlx->hWD, &trans);
}

P9054_DMA_HANDLE P9054_DMAOpen (P9054_HANDLE hPlx, UINT32 dwLocalAddr, PVOID *buf, DWORD dwDmaOptions, 
    DWORD dwBytes, P9054_MODE mode, P9054_DMA_CHANNEL dmaChannel)
{
    UINT32 dwDMAMODE, dwDMADPR, dwDMALADR;
    UINT32 dwChannelShift = (dmaChannel==P9054_DMA_CHANNEL_0) ? 0 : P9054_DMA_CHANNEL_SHIFT;
    BOOL fAutoinc = TRUE;
    P9054_DMA_HANDLE hDma = NULL;
    DWORD dwStatus, dwPagesNeeded, dwAllocSize;
    BOOL fIsRead;

    if (!(dwDmaOptions & DMA_READ_FROM_DEVICE) && 
        !(dwDmaOptions & DMA_WRITE_TO_DEVICE))
    {
        sprintf(P9054_ErrorString, "9054_DMAOpen error: You must set either "
            "DMA_READ_FROM_DEVICE or DMA_WRITE_TO_DEVICE in the DMA options.\n");
        goto Exit;
    }
    
    if ((dwDmaOptions & DMA_READ_FROM_DEVICE) && 
        (dwDmaOptions & DMA_WRITE_TO_DEVICE))
    {
        sprintf(P9054_ErrorString, "P9054_DMAOpen error: DMA_READ_FROM_DEVICE "
            "and DMA_WRITE_TO_DEVICE were both set.\n");
        goto Exit;
    }
    
    fIsRead = dwDmaOptions & DMA_READ_FROM_DEVICE ? TRUE : FALSE;
    
    // Since the first and last page do not necessarily start (or end) on a 
    // PAGE_SIZE boundary, we need to add 1 more pages for worst case
    dwPagesNeeded = ((dwBytes + GetPageSize() - 1) / GetPageSize()) + 1;

    dwAllocSize = sizeof(P9054_DMA_STRUCT);
    if (WD_DMA_PAGES < dwPagesNeeded)
    {
        dwAllocSize += (sizeof(WD_DMA_PAGE) * (dwPagesNeeded - WD_DMA_PAGES));
        dwDmaOptions |= DMA_LARGE_BUFFER;
    }

    hDma = (P9054_DMA_HANDLE) malloc(dwAllocSize);
    if (hDma==NULL)
    {
        sprintf(P9054_ErrorString, "Failed allocating memory for dma handle!\n");
        goto Exit;
    }
    BZERO (*hDma);
    hDma->dmaChannel = dmaChannel;
    hDma->dma.dwBytes = dwBytes;
    if (!(dwDmaOptions & DMA_KERNEL_BUFFER_ALLOC)) // Scatter/Gather DMA
        hDma->dma.pUserAddr = *buf;
    if (dwDmaOptions & DMA_LARGE_BUFFER)
        hDma->dma.dwPages = dwPagesNeeded;
    hDma->dma.dwOptions = dwDmaOptions;
    hDma->dma.hCard = hPlx->cardReg.hCard;
    dwStatus = WD_DMALock(hPlx->hWD, &hDma->dma);
    if (dwStatus) 
    {
        sprintf(P9054_ErrorString, "Failed locking the buffer. status 0x%lx - %s\n",
            dwStatus, Stat2Str(dwStatus));
        goto Exit;
    }

    // If a contiguous kernel buffer was locked, update buffer:
    if (dwDmaOptions & DMA_KERNEL_BUFFER_ALLOC)
        *buf = hDma->dma.pUserAddr;
    
    // common settings for chain and direct DMA
    dwDMAMODE = 
        (fAutoinc ? 0 : BIT11) 
        | BIT6 // enable Ready input
        | BIT8 // local burst
        | (mode==P9054_MODE_BYTE ? 0 : mode==P9054_MODE_WORD ? BIT0 : (BIT1 | BIT0));

    if (hDma->dma.dwPages==1)
    {
        // dma of one page ==> direct dma
        dwDMADPR = BIT0 | (fIsRead ? BIT3 : 0);
        dwDMALADR = dwLocalAddr;

        P9054_WriteReg (hPlx, P9054_DMAMODE + dwChannelShift, dwDMAMODE);
        P9054_WriteReg (hPlx, P9054_DMAPADR + dwChannelShift, (UINT32)hDma->dma.Page[0].pPhysicalAddr);
        P9054_WriteReg (hPlx, P9054_DMALADR + dwChannelShift, dwDMALADR);
        P9054_WriteReg (hPlx, P9054_DMASIZ + dwChannelShift, hDma->dma.Page[0].dwBytes);
        P9054_WriteReg (hPlx, P9054_DMADPR + dwChannelShift, dwDMADPR);
    }
    else
    {
        // dma of more then one page ==> chain dma
        UINT32 dwAlignShift, dwPageNumber, dwMemoryCopied;
        typedef struct {
            UINT32 dwPADR;
            UINT32 dwLADR;
            UINT32 dwSIZ;
            UINT32 dwDPR;
        } DMA_LIST;
        DMA_LIST *pList;
        UINT32 dwStartOfChain;

        // allocate a kernel buffer to hold the chain of DMA descriptors
        // includes extra 0x10 bytes for quadword alignment
        hDma->dmaList.dwBytes = hDma->dma.dwPages * sizeof(DMA_LIST) + 0x10;
        hDma->dmaList.pUserAddr = NULL;
        hDma->dmaList.dwOptions = DMA_KERNEL_BUFFER_ALLOC;
        hDma->dmaList.hCard = hPlx->cardReg.hCard;
        dwStatus = WD_DMALock(hPlx->hWD, &hDma->dmaList);
        if (dwStatus)
        {
            sprintf(P9054_ErrorString, "Failed allocating the chain buffer. status 0x%lx - %s\n",
                dwStatus, Stat2Str(dwStatus));
            goto Exit;
        }

        // verification that bits 0-3 are zero (quadword aligned)
        dwAlignShift = 0x10 - ((UINT32) hDma->dmaList.pUserAddr & 0xf);  
        pList = (DMA_LIST *) ((DWORD) hDma->dmaList.pUserAddr + dwAlignShift);
        dwStartOfChain = (UINT32) hDma->dmaList.Page[0].pPhysicalAddr + dwAlignShift;

        //setting chain of dma pages in the memory
        for (dwPageNumber=0, dwMemoryCopied=0; dwPageNumber<hDma->dma.dwPages; dwPageNumber++)
        {
            pList[dwPageNumber].dwPADR = 
                htod32((UINT32)hDma->dma.Page[dwPageNumber].pPhysicalAddr);
            pList[dwPageNumber].dwLADR = 
                htod32((dwLocalAddr + (fAutoinc ? dwMemoryCopied : 0)));
            pList[dwPageNumber].dwSIZ = 
                htod32((UINT32)hDma->dma.Page[dwPageNumber].dwBytes);
            pList[dwPageNumber].dwDPR =