p9030_lib.c

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

{
    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 P9030_WriteSpaceDWord (P9030_HANDLE hPlx, P9030_ADDR addrSpace, DWORD dwOffset, DWORD data)
{
    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 P9030_ReadWriteSpaceBlock (P9030_HANDLE hPlx, DWORD dwOffset, PVOID buf, 
                    DWORD dwBytes, BOOL fIsRead, P9030_ADDR addrSpace, P9030_MODE mode)
{
    WD_TRANSFER trans;
    DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddr + dwOffset;

    BZERO(trans);

    if (hPlx->addrDesc[addrSpace].fIsMemory) 
    {
        if (fIsRead) 
        {
            if (mode==P9030_MODE_BYTE) trans.cmdTrans = RM_SBYTE;
            else if (mode==P9030_MODE_WORD) trans.cmdTrans = RM_SWORD;
            else trans.cmdTrans = RM_SDWORD;
        }
        else 
        {
            if (mode==P9030_MODE_BYTE) trans.cmdTrans = WM_SBYTE;
            else if (mode==P9030_MODE_WORD) trans.cmdTrans = WM_SWORD;
            else trans.cmdTrans = WM_SDWORD;
        }
    }
    else 
    {
        if (fIsRead) 
        {
            if (mode==P9030_MODE_BYTE) trans.cmdTrans = RP_SBYTE;
            else if (mode==P9030_MODE_WORD) trans.cmdTrans = RP_SWORD;
            else trans.cmdTrans = RP_SDWORD;
        }
        else 
        {
            if (mode==P9030_MODE_BYTE) trans.cmdTrans = WP_SBYTE;
            else if (mode==P9030_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 P9030_ReadSpaceBlock (P9030_HANDLE hPlx, DWORD dwOffset, PVOID buf, 
                    DWORD dwBytes, P9030_ADDR addrSpace, P9030_MODE mode)
{
    P9030_ReadWriteSpaceBlock (hPlx, dwOffset, buf, dwBytes, TRUE, addrSpace, mode);
}

void P9030_WriteSpaceBlock (P9030_HANDLE hPlx, DWORD dwOffset, PVOID buf, 
                     DWORD dwBytes, P9030_ADDR addrSpace, P9030_MODE mode)
{
    P9030_ReadWriteSpaceBlock (hPlx, dwOffset, buf, dwBytes, FALSE, addrSpace, mode);
}

BYTE P9030_ReadByte (P9030_HANDLE hPlx, P9030_ADDR addrSpace, DWORD dwLocalAddr)
{
    DWORD dwOffset = hPlx->addrDesc[addrSpace].dwMask & dwLocalAddr;
    P9030_SetMode (hPlx, addrSpace, dwLocalAddr);
    return P9030_ReadSpaceByte(hPlx, addrSpace, dwOffset);
}

void P9030_WriteByte (P9030_HANDLE hPlx, P9030_ADDR addrSpace, DWORD dwLocalAddr, BYTE data)
{
    DWORD dwOffset = hPlx->addrDesc[addrSpace].dwMask & dwLocalAddr;
    P9030_SetMode (hPlx, addrSpace, dwLocalAddr);
    P9030_WriteSpaceByte(hPlx, addrSpace, dwOffset, data);
}

WORD P9030_ReadWord (P9030_HANDLE hPlx, P9030_ADDR addrSpace, DWORD dwLocalAddr)
{
    DWORD dwOffset = hPlx->addrDesc[addrSpace].dwMask & dwLocalAddr;
    P9030_SetMode (hPlx, addrSpace, dwLocalAddr);
    return P9030_ReadSpaceWord(hPlx, addrSpace, dwOffset);
}

void P9030_WriteWord (P9030_HANDLE hPlx, P9030_ADDR addrSpace, DWORD dwLocalAddr, WORD data)
{
    DWORD dwOffset = hPlx->addrDesc[addrSpace].dwMask & dwLocalAddr;
    P9030_SetMode (hPlx, addrSpace, dwLocalAddr);
    P9030_WriteSpaceWord(hPlx, addrSpace, dwOffset, data);
}

DWORD P9030_ReadDWord (P9030_HANDLE hPlx, P9030_ADDR addrSpace, DWORD dwLocalAddr)
{
    DWORD dwOffset = hPlx->addrDesc[addrSpace].dwMask & dwLocalAddr;
    P9030_SetMode (hPlx, addrSpace, dwLocalAddr);
    return P9030_ReadSpaceDWord(hPlx, addrSpace, dwOffset);
}

void P9030_WriteDWord (P9030_HANDLE hPlx, P9030_ADDR addrSpace, DWORD dwLocalAddr, DWORD data)
{
    DWORD dwOffset = hPlx->addrDesc[addrSpace].dwMask & dwLocalAddr;
    P9030_SetMode (hPlx, addrSpace, dwLocalAddr);
    P9030_WriteSpaceDWord(hPlx, addrSpace, dwOffset, data);
}

void P9030_ReadWriteBlock (P9030_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
                    DWORD dwBytes, BOOL fIsRead, P9030_ADDR addrSpace, P9030_MODE mode)
{
    DWORD dwOffset = hPlx->addrDesc[addrSpace].dwMask & dwLocalAddr;
    P9030_SetMode (hPlx, addrSpace, dwLocalAddr);
    P9030_ReadWriteSpaceBlock(hPlx, dwOffset, buf, dwBytes, fIsRead, addrSpace, mode);
}

void P9030_ReadBlock (P9030_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
                    DWORD dwBytes, P9030_ADDR addrSpace, P9030_MODE mode)
{
    P9030_ReadWriteBlock (hPlx, dwLocalAddr, buf, dwBytes, TRUE, addrSpace, mode);
}

void P9030_WriteBlock (P9030_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
                     DWORD dwBytes, P9030_ADDR addrSpace, P9030_MODE mode)
{
    P9030_ReadWriteBlock (hPlx, dwLocalAddr, buf, dwBytes, FALSE, addrSpace, mode);
}

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

void P9030_IntHandler (PVOID pData)
{
    P9030_HANDLE hPlx = (P9030_HANDLE) pData;
    P9030_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 P9030_IntEnable (P9030_HANDLE hPlx, P9030_INT_HANDLER funcIntHandler)
{
    WORD wIntStatus;
    DWORD dwAddr;

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

    wIntStatus = P9030_ReadSpaceWord(hPlx, P9030_ADDR_REG, P9030_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[P9030_ADDR_REG].dwAddr + P9030_INTCSR;
    hPlx->Int.Trans[0].cmdTrans = hPlx->addrDesc[P9030_ADDR_REG].fIsMemory ? RM_WORD : RP_WORD;
    hPlx->Int.Trans[0].dwPort = dwAddr;
    hPlx->Int.Trans[1].cmdTrans = hPlx->addrDesc[P9030_ADDR_REG].fIsMemory ? WM_WORD : WP_WORD;
    hPlx->Int.Trans[1].dwPort = dwAddr;
    hPlx->Int.Trans[1].Data.Word = wIntStatus & ~BIT6; // 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;
    if (!InterruptThreadEnable(&hPlx->Int.hThread, hPlx->hWD, &hPlx->Int.Int, P9030_IntHandler, (PVOID) hPlx))
        return FALSE;

    // this physically enables interrupts
    P9030_WriteSpaceWord(hPlx, P9030_ADDR_REG, P9030_INTCSR, wIntStatus | (WORD) BIT6);

    return TRUE;
}

void P9030_IntDisable (P9030_HANDLE hPlx)
{
    DWORD dwIntStatus;

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

    // this disables interrupts
    dwIntStatus = P9030_ReadReg (hPlx, P9030_INTCSR);
    P9030_WriteReg (hPlx, P9030_INTCSR, dwIntStatus & ~BIT6);

    // this calls WD_IntDisable()
    InterruptThreadDisable(hPlx->Int.hThread);

    hPlx->Int.hThread = NULL;
}

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

BOOL P9030_EEPROMValid(P9030_HANDLE hPlx)
{
    return (P9030_ReadReg(hPlx, P9030_CNTRL) & BIT28)==BIT28;
}

void P9030_Sleep(P9030_HANDLE hPlx, DWORD dwMicroSeconds)
{
    WD_SLEEP sleep;

    BZERO (sleep);
    sleep.dwMicroSeconds = dwMicroSeconds;
    WD_Sleep( hPlx->hWD, &sleep);
}

BYTE P9030_EEPROMEnable(P9030_HANDLE hPlx, WORD addr)
{
    BYTE old_val;

    old_val = P9030_ReadSpaceByte(hPlx, P9030_ADDR_REG, P9030_PROT_AREA);
    
    addr /= 4;
    addr &= 0x7f;

    P9030_WriteSpaceByte(hPlx, P9030_ADDR_REG, P9030_PROT_AREA, (BYTE)addr);
    P9030_Sleep(hPlx, 10000);

    return old_val * 4; //expand from dwords to bytes
}

void P9030_EEPROMDataReadWrite(P9030_HANDLE hPlx, BOOL fIsRead, PDWORD pdwData)
{
    WD_PCI_CONFIG_DUMP pciCnf;

    BZERO (pciCnf);
    pciCnf.pciSlot = hPlx->pciSlot;
    pciCnf.pBuffer = pdwData;
    pciCnf.dwOffset = P9030_VPD_DATA;
    pciCnf.dwBytes = 4;
    pciCnf.fIsRead = fIsRead;
    WD_PciConfigDump(hPlx->hWD,&pciCnf);
}

void P9030_EEPROMAddrReadWrite(P9030_HANDLE hPlx, BOOL fIsRead, PWORD pwAddr)
{
    WD_PCI_CONFIG_DUMP pciCnf;

    BZERO (pciCnf);
    pciCnf.pciSlot = hPlx->pciSlot;
    pciCnf.pBuffer = pwAddr;
    pciCnf.dwOffset = P9030_VPD_ADDR;
    pciCnf.dwBytes = 2;
    pciCnf.fIsRead = fIsRead;
    WD_PciConfigDump(hPlx->hWD,&pciCnf);
}

BOOL P9030_EEPROMReadDWord(P9030_HANDLE hPlx, DWORD dwOffset, PDWORD pdwData)
{
    WORD wVal;
    WORD wAddr;
    int i;

    if (dwOffset % 4)
    {
        sprintf (P9030_ErrorString, "The offset is not a multiple of 4\n");
        return FALSE;
    }
    wAddr = (((WORD)dwOffset) & (~BIT15)) ;
 
    for (i=0; i<10; i++)
    {
        P9030_EEPROMAddrReadWrite(hPlx, FALSE, &wAddr);
        P9030_Sleep(hPlx, 10000);
        P9030_EEPROMAddrReadWrite(hPlx, TRUE, &wVal);
        if (wVal & BIT15)
            break;
    }
    
    if (i==10)
    {
        sprintf (P9030_ErrorString, "Acknowledge to EEPROM read was not received\n");
        return FALSE;
    }

    P9030_EEPROMDataReadWrite(hPlx, TRUE, pdwData);

    return TRUE;
}

BOOL P9030_EEPROMReadWord(P9030_HANDLE hPlx, DWORD dwOffset, PWORD pwData)
{
    DWORD dwData;
    DWORD dwAddr;

    if (dwOffset % 2)
    {
        sprintf (P9030_ErrorString, "The offset is not even\n");
        return FALSE;
    }
    dwAddr = dwOffset - (dwOffset % 4);

    if (!P9030_EEPROMReadDWord(hPlx, dwAddr, &dwData))
        return FALSE;

    *pwData = (WORD) (dwData >> ((dwOffset % 4)*8));

    return TRUE;
}

BOOL P9030_EEPROMWriteWord(P9030_HANDLE hPlx, DWORD dwOffset, WORD wData)
{
    DWORD dwData;
    DWORD dwAddr;

    dwAddr = dwOffset - (dwOffset % 4);

    if (!P9030_EEPROMReadDWord(hPlx, dwAddr, &dwData))
        return FALSE;

    switch (dwOffset % 4)
    {
    case 0:
        dwData = (dwData & 0xffff0000) | wData;
        break;
    case 2:
        dwData = (dwData & 0x0000ffff) | (wData << 16);
        break;
    default:
        sprintf (P9030_ErrorString, "The offset is not even\n");
        return FALSE;
    }

    return P9030_EEPROMWriteDWord(hPlx, dwAddr, dwData);
}

BOOL P9030_EEPROMWriteDWord(P9030_HANDLE hPlx, DWORD dwOffset, DWORD dwData)
{
    DWORD dwReadback;
    WORD wAddr;
    WORD wVal;
    int i;
    BOOL fRet;
    BOOL fReadOk = FALSE;
    BYTE bEnableOffset;

    if (dwOffset % 4)
    {
        sprintf (P9030_ErrorString, "The offset is not a multiple of 4\n");
        return FALSE;
    }
    wAddr = (WORD)dwOffset;
    bEnableOffset = P9030_EEPROMEnable(hPlx, wAddr);
    wAddr = wAddr | BIT15;

    for (i=0; i<10; i++)
    {
        P9030_EEPROMDataReadWrite(hPlx, FALSE, &dwData);
        P9030_EEPROMAddrReadWrite(hPlx, FALSE, &wAddr);
        P9030_Sleep(hPlx, 10000);
        P9030_EEPROMAddrReadWrite(hPlx, TRUE, &wVal);
        if ((wVal & (WORD)BIT15) == 0)
            break;
    }

    fReadOk = P9030_EEPROMReadDWord(hPlx, dwOffset, &dwReadback);

    if (fReadOk && dwReadback==dwData)
        fRet = TRUE;
    else
    {
        fRet = FALSE;
        if (fReadOk)
            sprintf (P9030_ErrorString, "Write 0x%08x, Read 0x%08x\n",dwData, dwReadback);
        else
            sprintf (P9030_ErrorString, "Error reading EEPROM\n");
    }
    P9030_EEPROMEnable(hPlx, bEnableOffset); 
    return fRet;
}