gt64_lib.c

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

DWORD GT64_ReadDWord (GT64_HANDLE hGT, GT64_ADDR addrSpace, DWORD dwOffset)
{
    if (hGT->addrDesc[addrSpace].fIsMemory)
    {
        DWORD dwAddr = hGT->addrDesc[addrSpace].dwAddrDirect + dwOffset;
        DWORD *pDword = (DWORD *) dwAddr;
        return *pDword;
    }
    else
    {
        DWORD dwAddr = hGT->addrDesc[addrSpace].dwAddr + dwOffset;
        WD_TRANSFER trans;
        BZERO(trans);
        trans.cmdTrans = RP_DWORD;
        trans.dwPort = dwAddr;
        WD_Transfer (hGT->hWD, &trans);
        return trans.Data.Dword;
    }
}

void GT64_WriteDWord (GT64_HANDLE hGT, GT64_ADDR addrSpace, DWORD dwOffset, DWORD data)
{
    if (hGT->addrDesc[addrSpace].fIsMemory)
    {
        DWORD dwAddr = hGT->addrDesc[addrSpace].dwAddrDirect + dwOffset;
        DWORD *pDword = (DWORD *) dwAddr;
        *pDword = data;
    }
    else
    {
        DWORD dwAddr = hGT->addrDesc[addrSpace].dwAddr + dwOffset;
        WD_TRANSFER trans;
        BZERO(trans);
        trans.cmdTrans = WP_DWORD;
        trans.dwPort = dwAddr;
        trans.Data.Dword = data;
        WD_Transfer (hGT->hWD, &trans);
    }
}

void GT64_ReadWriteBlock (GT64_HANDLE hGT, DWORD dwOffset, PVOID buf, 
                    DWORD dwBytes, BOOL fIsRead, GT64_ADDR addrSpace)
{
    DWORD dwAddr = hGT->addrDesc[addrSpace].dwAddr + dwOffset;
    WD_TRANSFER trans;

    BZERO(trans);

    if (hGT->addrDesc[addrSpace].fIsMemory) 
    {
        if (fIsRead) 
            trans.cmdTrans = RM_SDWORD;
        else 
            trans.cmdTrans = WM_SDWORD;
    }
    else 
    {
        if (fIsRead) 
            trans.cmdTrans = RP_SDWORD;
        else 
            trans.cmdTrans = WP_SDWORD;
    }
    trans.dwPort = dwAddr;
    trans.fAutoinc = TRUE;
    trans.dwBytes = dwBytes;
    trans.dwOptions = 0;
    trans.Data.pBuffer = buf;
    WD_Transfer (hGT->hWD, &trans);
}

void GT64_ReadBlock (GT64_HANDLE hGT, DWORD dwOffset, PVOID buf, 
                    DWORD dwBytes, GT64_ADDR addrSpace)
{
    GT64_ReadWriteBlock (hGT, dwOffset, buf, dwBytes, TRUE, addrSpace);
}

void GT64_WriteBlock (GT64_HANDLE hGT, DWORD dwOffset, PVOID buf, 
                     DWORD dwBytes, GT64_ADDR addrSpace)
{
    GT64_ReadWriteBlock (hGT, dwOffset, buf, dwBytes, FALSE, addrSpace);
}

BOOL GT64_IntIsEnabled (GT64_HANDLE hGT)
{
    if (!hGT->Int.hThread)
        return FALSE;
    return TRUE;
}

VOID GT64_IntHandler (PVOID pData)
{
    GT64_HANDLE hGT = (GT64_HANDLE) pData;
    GT64_INT_RESULT intResult;
    intResult.dwCounter = hGT->Int.Int.dwCounter;
    intResult.dwLost = hGT->Int.Int.dwLost;
    intResult.fStopped = hGT->Int.Int.fStopped;
    intResult.dwStatusReg = hGT->Int.Trans[0].Data.Dword;
    hGT->Int.funcIntHandler(hGT, &intResult);  
}

BOOL GT64_IntEnable (GT64_HANDLE hGT, GT64_INT_HANDLER funcIntHandler)
{
    DWORD dwAddr;

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

    BZERO(hGT->Int.Trans);
    // One transfer commands is issued to CANCEL the source of the interrupt,
    // otherwise, the PC will hang when an interrupt occurs!
    dwAddr = hGT->addrDesc[GT64_ADDR_REG].dwAddr + GT64_INTERRUPT_ACKNOWLEDGE;
    hGT->Int.Trans[0].cmdTrans = hGT->addrDesc[GT64_ADDR_REG].fIsMemory ? RM_DWORD : RP_DWORD;
    hGT->Int.Trans[0].dwPort = dwAddr;
    hGT->Int.Int.dwCmds = 1; 
    hGT->Int.Int.Cmd = hGT->Int.Trans;
    hGT->Int.Int.dwOptions |= INTERRUPT_CMD_COPY;
 
    // this calls WD_IntEnable() and creates an interrupt handler thread
    hGT->Int.funcIntHandler = funcIntHandler;
    if (!InterruptThreadEnable(&hGT->Int.hThread, hGT->hWD, &hGT->Int.Int, GT64_IntHandler, (PVOID) hGT))
        return FALSE;

    return TRUE;
}

void GT64_IntDisable (GT64_HANDLE hGT)
{
    if (!hGT->Int.hThread)
        return;

    // this calls WD_IntDisable()
    InterruptThreadDisable(hGT->Int.hThread);
    hGT->Int.hThread = NULL;
}

GT64_DMA_HANDLE GT64_DMAOpen (GT64_HANDLE hGT, DWORD dwLocalAddr, PVOID buf, 
    DWORD dwBytes, BOOL fIsRead, GT64_DAT_TRANS_LIM lim_mode, GT64_DMA_CHANNEL dmaChannel)
{
    DWORD dwChannelShift = dmaChannel*GT64_DMA_CHANNEL_SHIFT;
    BOOL fAutoinc = TRUE;
    GT64_DMA_HANDLE hDma;
    
    if (hGT->gt64Ver == GT64_VERSION_64111) 
    {
        sprintf( GT64_ErrorString, "GT-64111 DMA transfer are not supported\n");
        goto Exit;
    }
    hDma = malloc (sizeof(GT64_DMA_STRUCT));
    if (hDma==NULL)
    {
        sprintf( GT64_ErrorString, "Failed allocating memory for dma handle!\n");
        goto Exit;
    }
    BZERO (*hDma);
    hDma->dmaChannel = dmaChannel;
    hDma->dma.dwBytes = dwBytes;
    hDma->dma.pUserAddr = buf; 
    hDma->dma.dwOptions = 0; 
    WD_DMALock (hGT->hWD, &hDma->dma);
    if (!hDma->dma.hDma) 
    {
        sprintf( GT64_ErrorString, "Failed locking the buffer!\n");
        goto Exit;
    }
    
    hDma->dwDmaControl =  
          ((!fAutoinc && fIsRead)? 0 : BIT3)    // hold source address 
        | ((!fAutoinc && !fIsRead)? 0 : BIT5)   // hold destination address
        | lim_mode       // burst size
        | BIT11          // block transfer mode 
        | BIT12          // to initiate the DMA
        | BIT21 | BIT23 | BIT25; // source, destination, and next record is in PCI_0 Memory space
    if (hDma->dma.dwPages==1)
    {
        hDma->dwDmaControl |= BIT9;  // do not use chain mode
        //dma of one page ==> direct dma

        GT64_WriteReg (hGT, GT64_CHANNEL_0_DMA_BYTE_COUNT + dwChannelShift, hDma->dma.Page[0].dwBytes);
        if (fIsRead)
        {
            GT64_WriteReg (hGT, GT64_CHANNEL_0_DMA_SOURCE_ADDRESS + dwChannelShift, dwLocalAddr);
            GT64_WriteReg (hGT, GT64_CHANNEL_0_DMA_DESTINATION_ADDRESS + dwChannelShift
                , (DWORD) hDma->dma.Page[0].pPhysicalAddr);
        }
        else
        {
            GT64_WriteReg (hGT, GT64_CHANNEL_0_DMA_DESTINATION_ADDRESS + dwChannelShift, dwLocalAddr);
            GT64_WriteReg (hGT, GT64_CHANNEL_0_DMA_SOURCE_ADDRESS + dwChannelShift
                , (DWORD) hDma->dma.Page[0].pPhysicalAddr);
        }
        GT64_WriteReg (hGT, GT64_CHANNEL_0_NEXT_RECORD_POINTER + dwChannelShift, 0);  //One block
    }
    else
    {
        DWORD dwPageNumber, dwMemoryCopied;
        typedef struct {
            DWORD dwByteCt;
            DWORD dwSrcAdd;
            DWORD dwDestAdd;
            DWORD dwNextRecPtr;
        } DMA_LIST;
        DMA_LIST *pList;

        //dma of more then one page ==> chain dma
        hDma->dmaList.dwBytes = hDma->dma.dwPages * sizeof(DMA_LIST);
        hDma->dmaList.pUserAddr = NULL;
        hDma->dmaList.dwOptions = DMA_KERNEL_BUFFER_ALLOC;
        WD_DMALock (hGT->hWD, &hDma->dmaList);
        if (!hDma->dmaList.hDma)
        {
            sprintf (GT64_ErrorString, "Failed locking the chain buffer!\n");
            goto Exit;
        }

        //setting chain of dma pages in the memory
        dwMemoryCopied = 0;
        pList = (DMA_LIST *) ((DWORD) hDma->dmaList.pUserAddr);
        for (dwPageNumber=0; dwPageNumber<hDma->dma.dwPages; dwPageNumber++)
        {
            pList[dwPageNumber].dwByteCt = hDma->dma.Page[dwPageNumber].dwBytes;
            if (fIsRead)
            {
                pList[dwPageNumber].dwSrcAdd = dwLocalAddr + (fAutoinc ? dwMemoryCopied : 0);
                pList[dwPageNumber].dwDestAdd = (DWORD) hDma->dma.Page[dwPageNumber].pPhysicalAddr;
            }
            else
            {
                pList[dwPageNumber].dwDestAdd = dwLocalAddr + (fAutoinc ? dwMemoryCopied : 0);
                pList[dwPageNumber].dwSrcAdd = (DWORD) hDma->dma.Page[dwPageNumber].pPhysicalAddr;
            }
            pList[dwPageNumber].dwNextRecPtr =  
                ((DWORD) hDma->dmaList.Page[0].pPhysicalAddr + sizeof(DMA_LIST)*(dwPageNumber+1));
            dwMemoryCopied += hDma->dma.Page[dwPageNumber].dwBytes;
        }
        pList[dwPageNumber - 1].dwNextRecPtr = 0 ; // mark end of chain
    
        hDma->dwDmaControl |= BIT10    // interrupt only after finishing all pages
            | BIT13;   // fetching the first record
        // adjusting the first record
        GT64_WriteReg (hGT, GT64_CHANNEL_0_NEXT_RECORD_POINTER + dwChannelShift,
            (DWORD)hDma->dmaList.Page[0].pPhysicalAddr);
    }
    return hDma;

Exit:
    if (hDma!=NULL)
        GT64_DMAClose(hGT,hDma);
    return NULL;
}

void GT64_DMAClose (GT64_HANDLE hGT, GT64_DMA_HANDLE hDma)
{
    if (hDma->dma.hDma)
        WD_DMAUnlock(hGT->hWD, &hDma->dma);
    if (hDma->dmaList.hDma)
        WD_DMAUnlock(hGT->hWD, &hDma->dmaList);
    free (hDma);
}

BOOL GT64_DMAIsDone (GT64_HANDLE hGT, GT64_DMA_HANDLE hDma)
{
    return (GT64_ReadReg (hGT, GT64_CHANNEL_0_CONTROL + hDma->dmaChannel * GT64_DMA_CHANNEL_SHIFT) & BIT14)==BIT14;
}

void GT64_DMAStart (GT64_HANDLE hGT, GT64_DMA_HANDLE hDma, BOOL fBlocking)
{
    GT64_WriteReg (hGT, GT64_CHANNEL_0_CONTROL + hDma->dmaChannel * GT64_DMA_CHANNEL_SHIFT, hDma->dwDmaControl);

    //Busy wait for GT to finish transfer
    if (fBlocking) 
        while (!GT64_DMAIsDone(hGT, hDma));
}

BOOL GT64_DMAReadWriteBlock (GT64_HANDLE hGT, GT64_ADDR addrSpace, DWORD dwLocalAddrOffset, PVOID buf, 
    DWORD dwBytes, BOOL fIsRead, GT64_DAT_TRANS_LIM lim_mode, GT64_DMA_CHANNEL dmaChannel)
{
    DWORD dwLocalAddr = hGT->addrDesc[addrSpace].dwAddrDirect + dwLocalAddrOffset;
    GT64_DMA_HANDLE hDma;
    if (dwBytes==0) 
        return TRUE;

    hDma = GT64_DMAOpen(hGT, dwLocalAddr, buf, dwBytes, fIsRead, lim_mode, dmaChannel);
    if (!hDma) 
        return FALSE;
    GT64_DMAStart (hGT, hDma, TRUE);

    GT64_DMAClose(hGT, hDma);
    return TRUE;
}