p9080_lib.c

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

    hPlx->Int.hThread = NULL;
}

P9080_DMA_HANDLE P9080_DMAOpen (P9080_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
    DWORD dwBytes, BOOL fIsRead, P9080_MODE mode, P9080_DMA_CHANNEL dmaChannel)
{
    DWORD dwDMAMODE, dwDMADPR, dwDMALADR;
    DWORD dwChannelShift = (dmaChannel==P9080_DMA_CHANNEL_0) ? 0 : P9080_DMA_CHANNEL_SHIFT;
    BOOL fAutoinc = TRUE;
    P9080_DMA_HANDLE hDma;
    
    hDma = malloc (sizeof(P9080_DMA_STRUCT));
    if (hDma==NULL)
    {
        sprintf( P9080_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 (hPlx->hWD, &hDma->dma);
    if (!hDma->dma.hDma) 
    {
        sprintf( P9080_ErrorString, "Failed locking the buffer!\n");
        goto Exit;
    }
    if (hDma->dma.dwPages==1)
    {
        //dma of one page ==> direct dma
        dwDMAMODE = 
            (fAutoinc ? 0 : BIT11) 
            | BIT6 
            | (mode==P9080_MODE_BYTE ? 0 : mode==P9080_MODE_WORD ? BIT0 : (BIT1 | BIT0));
        dwDMADPR = BIT0 | (fIsRead ? BIT3 : 0);
        dwDMALADR = dwLocalAddr;

        P9080_WriteReg (hPlx, P9080_DMAMODE + dwChannelShift, dwDMAMODE);
        P9080_WriteReg (hPlx, P9080_DMAPADR + dwChannelShift, (DWORD) hDma->dma.Page[0].pPhysicalAddr);
        P9080_WriteReg (hPlx, P9080_DMALADR + dwChannelShift, dwDMALADR);
        P9080_WriteReg (hPlx, P9080_DMASIZ + dwChannelShift, hDma->dma.Page[0].dwBytes);
        P9080_WriteReg (hPlx, P9080_DMADPR + dwChannelShift, dwDMADPR);
    }
    else
    {
        DWORD dwAlignShift, dwPageNumber, dwMemoryCopied;
        typedef struct {
            DWORD dwPADR;
            DWORD dwLADR;
            DWORD dwSIZ;
            DWORD dwDPR;
        } DMA_LIST;
        DMA_LIST *pList;

        // dma of more then one page ==> chain dma
        // 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;
        WD_DMALock (hPlx->hWD, &hDma->dmaList);
        if (!hDma->dmaList.hDma)
        {
            sprintf (P9080_ErrorString, "Failed locking the chain buffer!\n");
            goto Exit;
        }

        //setting chain of dma pages in the memory
        dwMemoryCopied = 0;
        dwAlignShift = 0x10 - (DWORD) hDma->dmaList.pUserAddr & 0xf;  
        // verification that bits 0-3 are zero (quadword aligned)
        pList = (DMA_LIST *) ((DWORD) hDma->dmaList.pUserAddr + dwAlignShift);
        for (dwPageNumber=0; dwPageNumber<hDma->dma.dwPages; dwPageNumber++)
        {
            pList[dwPageNumber].dwPADR = (DWORD) hDma->dma.Page[dwPageNumber].pPhysicalAddr;
            pList[dwPageNumber].dwLADR = dwLocalAddr + (fAutoinc ? dwMemoryCopied : 0);
            pList[dwPageNumber].dwSIZ = hDma->dma.Page[dwPageNumber].dwBytes;
            pList[dwPageNumber].dwDPR = 
                ((DWORD) hDma->dmaList.Page[0].pPhysicalAddr + dwAlignShift + sizeof(DMA_LIST)*(dwPageNumber+1))
                | BIT0 | (fIsRead ? BIT3 : 0);
            dwMemoryCopied += hDma->dma.Page[dwPageNumber].dwBytes;
        }
        pList[dwPageNumber - 1].dwDPR |= BIT1; // mark end of chain
    
        dwDMAMODE = (fAutoinc ? 0 : BIT11) 
                    | BIT6
                    | BIT9        // chain transfer
                    | (mode==P9080_MODE_BYTE ? 0 : mode==P9080_MODE_WORD ? BIT0 : (BIT1 | BIT0));
        dwDMADPR = ((DWORD)hDma->dmaList.Page[0].pPhysicalAddr + dwAlignShift) | BIT0; 
        // starting the dma
        P9080_WriteReg (hPlx, P9080_DMAMODE + dwChannelShift, dwDMAMODE);
        P9080_WriteReg (hPlx, P9080_DMADPR + dwChannelShift, dwDMADPR);
    }

    return hDma;

Exit:
    if (hDma!=NULL)
        P9080_DMAClose(hPlx,hDma);
    return NULL;
}

void P9080_DMAClose (P9080_HANDLE hPlx, P9080_DMA_HANDLE hDma)
{
    if (hDma->dma.hDma)
        WD_DMAUnlock(hPlx->hWD, &hDma->dma);
    if (hDma->dmaList.hDma)
        WD_DMAUnlock(hPlx->hWD, &hDma->dmaList);
    free (hDma);
}

BOOL P9080_DMAIsDone (P9080_HANDLE hPlx, P9080_DMA_HANDLE hDma)
{
    return (P9080_ReadByte(hPlx, P9080_ADDR_REG, P9080_DMACSR + 
        hDma->dmaChannel) & BIT4) == BIT4;
}

void P9080_DMAStart (P9080_HANDLE hPlx, P9080_DMA_HANDLE hDma, BOOL fBlocking)
{
    P9080_WriteByte(hPlx, P9080_ADDR_REG, P9080_DMACSR + hDma->dmaChannel, 
        BIT0 | BIT1);

    //Busy wait for plx to finish transfer
    if (fBlocking) 
        while (!P9080_DMAIsDone(hPlx, hDma));
}

BOOL P9080_DMAReadWriteBlock (P9080_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
    DWORD dwBytes, BOOL fIsRead, P9080_MODE mode, P9080_DMA_CHANNEL dmaChannel)
{
    P9080_DMA_HANDLE hDma;
    if (dwBytes==0) 
        return TRUE;

    hDma = P9080_DMAOpen(hPlx, dwLocalAddr, buf, dwBytes, fIsRead, mode, dmaChannel);
    if (!hDma) 
        return FALSE;

    P9080_DMAStart(hPlx, hDma, TRUE);
    P9080_DMAClose(hPlx, hDma);
    return TRUE;
}

void P9080_EEPROMDelay(P9080_HANDLE hPlx)
{
    WD_SLEEP sleep;
    BZERO (sleep);
    sleep.dwMicroSeconds = 500;
    WD_Sleep( hPlx->hWD, &sleep);
}

void P9080_EEPROMChipSelect(P9080_HANDLE hPlx, BOOL fSelect)
{
    DWORD dwCNTRL = P9080_ReadReg(hPlx, P9080_CNTRL);
    if (fSelect)
        dwCNTRL |= BIT25;
    else
        dwCNTRL &= ~BIT25;
    P9080_WriteReg(hPlx, P9080_CNTRL, dwCNTRL);
    P9080_EEPROMDelay(hPlx);
}

BOOL P9080_EEPROMValid(P9080_HANDLE hPlx)
{
    return (P9080_ReadReg(hPlx, P9080_CNTRL) & BIT28)==BIT28;
}

void P9080_EEPROMWriteBit(P9080_HANDLE hPlx, BOOL fBit)
{
    DWORD dwCNTRL = P9080_ReadReg(hPlx, P9080_CNTRL);

    dwCNTRL &= ~BIT24;
    if (fBit) // data
        dwCNTRL |= BIT26;
    else
        dwCNTRL &= ~BIT26;
    P9080_WriteReg( hPlx, P9080_CNTRL, dwCNTRL);
    P9080_EEPROMDelay(hPlx);

    dwCNTRL |= BIT24; // clock
    P9080_WriteReg( hPlx, P9080_CNTRL, dwCNTRL);
    P9080_EEPROMDelay(hPlx);

    dwCNTRL &= ~BIT24;
    P9080_WriteReg( hPlx, P9080_CNTRL, dwCNTRL);
    P9080_EEPROMDelay(hPlx);
}

BOOL P9080_EEPROMReadBit(P9080_HANDLE hPlx)
{
    BOOL fRet;
    DWORD dwCNTRL = P9080_ReadReg(hPlx, P9080_CNTRL);

    dwCNTRL &= ~BIT24;
    P9080_WriteReg( hPlx, P9080_CNTRL, dwCNTRL);
    P9080_EEPROMDelay(hPlx);

    dwCNTRL |= BIT24; // clock
    P9080_WriteReg( hPlx, P9080_CNTRL, dwCNTRL);
    P9080_EEPROMDelay(hPlx);

    dwCNTRL &= ~BIT24;
    P9080_WriteReg( hPlx, P9080_CNTRL, dwCNTRL);
    P9080_EEPROMDelay(hPlx);

    fRet = (P9080_ReadReg( hPlx, P9080_CNTRL) & BIT27)==BIT27;

    return fRet;
}

void P9080_EEPROMWriteEnableDisable(P9080_HANDLE hPlx, BOOL fEnable)
{
    P9080_EEPROMChipSelect(hPlx, TRUE);

    // send a WEN instruction
    P9080_EEPROMWriteBit(hPlx, 1);
    P9080_EEPROMWriteBit(hPlx, 0);
    P9080_EEPROMWriteBit(hPlx, 0);
    P9080_EEPROMWriteBit(hPlx, fEnable ? 1 : 0);
    P9080_EEPROMWriteBit(hPlx, fEnable ? 1 : 0);

    P9080_EEPROMWriteBit(hPlx, 0);
    P9080_EEPROMWriteBit(hPlx, 0);
    P9080_EEPROMWriteBit(hPlx, 0);
    P9080_EEPROMWriteBit(hPlx, 0);

    P9080_EEPROMChipSelect(hPlx, FALSE);
}

BOOL P9080_EEPROMReadWord(P9080_HANDLE hPlx, DWORD dwOffset, PWORD pwData)
{
    DWORD dwAddr = dwOffset >> 1;
    DWORD i;

    *pwData = 0;

    P9080_EEPROMChipSelect(hPlx, TRUE);
    P9080_EEPROMWriteBit(hPlx, 1);
    P9080_EEPROMWriteBit(hPlx, 1);
    P9080_EEPROMWriteBit(hPlx, 0);
    // if it's a CS46 EEPROM send only 5 bit address
    for ( i = hPlx->fUseCS46EEPROM ? BIT5 : BIT7; i; i = i>>1)
    {
        P9080_EEPROMWriteBit(hPlx, (dwAddr & i) == i);
    }
    for (i=BIT15; i; i = i>>1)
    {
        *pwData |= P9080_EEPROMReadBit(hPlx) ? i : 0;
    }

    P9080_EEPROMWriteEnableDisable(hPlx, FALSE);
    
    return TRUE;
}

BOOL P9080_EEPROMWriteWord(P9080_HANDLE hPlx, DWORD dwOffset, WORD wData)
{
    DWORD dwAddr = dwOffset >> 1;
    DWORD i;
    WORD readback;

    P9080_EEPROMWriteEnableDisable(hPlx, TRUE);

    P9080_EEPROMChipSelect(hPlx, TRUE);

    // send a PRWRITE instruction
    P9080_EEPROMWriteBit(hPlx, 1);
    P9080_EEPROMWriteBit(hPlx, 0);
    P9080_EEPROMWriteBit(hPlx, 1);
    // if it's a CS46 EEPROM send only a 6 bit address
    for ( i = hPlx->fUseCS46EEPROM ? BIT5 : BIT7; i; i = i>>1)
    {
        P9080_EEPROMWriteBit(hPlx, (dwAddr & i) == i);
    }
    for (i=BIT15; i; i = i>>1)
    {
        P9080_EEPROMWriteBit(hPlx, (wData & i) == i);
    }

    P9080_EEPROMChipSelect(hPlx, FALSE);
    
    P9080_EEPROMWriteEnableDisable(hPlx, FALSE);

    if (P9080_EEPROMReadWord(hPlx, dwOffset, &readback))
    {
        if (wData != readback)
        {
            sprintf( P9080_ErrorString, "Write 0x%04x, Read 0x%04x\n", wData, readback);
            return FALSE;
        }
    }
    else
        return FALSE;

    return TRUE;
}

BOOL P9080_EEPROMReadDWord(P9080_HANDLE hPlx, DWORD dwOffset, PDWORD pdwData)
{
    WORD wData1, wData2;
    if (dwOffset % 4)
    {
        sprintf( P9080_ErrorString, "The offset is not a multiple of 4\n");
        return FALSE;
    }

    if (!P9080_EEPROMReadWord(hPlx, dwOffset, &wData1))
        return FALSE;
    if (!P9080_EEPROMReadWord(hPlx, dwOffset+2, &wData2))
        return FALSE;

    *pdwData = (DWORD) ((wData1 << 16) + wData2);
    return TRUE;
}

BOOL P9080_EEPROMWriteDWord(P9080_HANDLE hPlx, DWORD dwOffset, DWORD dwData)
{
    WORD wData1, wData2;

    if (dwOffset % 4)
    {
        sprintf( P9080_ErrorString, "The offset is not a multiple of 4\n");
        return FALSE;
    }

    wData1 = (WORD) (dwData >> 16);
    wData2 = (WORD) (dwData & 0xffff);

    if (!P9080_EEPROMWriteWord(hPlx, dwOffset, wData1))
        return FALSE;
    if (!P9080_EEPROMWriteWord(hPlx, dwOffset+2, wData2))
        return FALSE;

    return TRUE;
}