iop480_lib.c

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

    WD_Close(hPlx->hWD);

    free (hPlx);
}

BOOL IOP480_IsAddrSpaceActive(IOP480_HANDLE hPlx, IOP480_ADDR addrSpace)
{
    return hPlx->addrDesc[addrSpace].dwAddr!=0;
}

DWORD IOP480_ReadReg (IOP480_HANDLE hPlx, DWORD dwReg)
{
    return IOP480_ReadDWord(hPlx, IOP480_ADDR_REG, dwReg);
}

void IOP480_WriteReg (IOP480_HANDLE hPlx, DWORD dwReg, DWORD dwData)
{
    IOP480_WriteDWord(hPlx, IOP480_ADDR_REG, dwReg, dwData);
}

BYTE IOP480_ReadByte (IOP480_HANDLE hPlx, IOP480_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 IOP480_WriteByte (IOP480_HANDLE hPlx, IOP480_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 IOP480_ReadWord (IOP480_HANDLE hPlx, IOP480_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 IOP480_WriteWord (IOP480_HANDLE hPlx, IOP480_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 IOP480_ReadDWord (IOP480_HANDLE hPlx, IOP480_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 IOP480_WriteDWord (IOP480_HANDLE hPlx, IOP480_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 IOP480_ReadWriteBlock (IOP480_HANDLE hPlx, DWORD dwOffset, PVOID buf, 
                    DWORD dwBytes, BOOL fIsRead, IOP480_ADDR addrSpace, IOP480_MODE mode)
{
    DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddr + dwOffset;
    WD_TRANSFER trans;

    BZERO(trans);

    if (hPlx->addrDesc[addrSpace].fIsMemory) 
    {
        if (fIsRead) 
        {
            if (mode==IOP480_MODE_BYTE) trans.cmdTrans = RM_SBYTE;
            else if (mode==IOP480_MODE_WORD) trans.cmdTrans = RM_SWORD;
            else trans.cmdTrans = RM_SDWORD;
        }
        else 
        {
            if (mode==IOP480_MODE_BYTE) trans.cmdTrans = WM_SBYTE;
            else if (mode==IOP480_MODE_WORD) trans.cmdTrans = WM_SWORD;
            else trans.cmdTrans = WM_SDWORD;
        }
    }
    else 
    {
        if (fIsRead) 
        {
            if (mode==IOP480_MODE_BYTE) trans.cmdTrans = RP_SBYTE;
            else if (mode==IOP480_MODE_WORD) trans.cmdTrans = RP_SWORD;
            else trans.cmdTrans = RP_SDWORD;
        }
        else 
        {
            if (mode==IOP480_MODE_BYTE) trans.cmdTrans = WP_SBYTE;
            else if (mode==IOP480_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 IOP480_ReadBlock (IOP480_HANDLE hPlx, DWORD dwOffset, PVOID buf, 
                    DWORD dwBytes, IOP480_ADDR addrSpace, IOP480_MODE mode)
{
    IOP480_ReadWriteBlock (hPlx, dwOffset, buf, dwBytes, TRUE, addrSpace, mode);
}

void IOP480_WriteBlock (IOP480_HANDLE hPlx, DWORD dwOffset, PVOID buf, 
                     DWORD dwBytes, IOP480_ADDR addrSpace, IOP480_MODE mode)
{
    IOP480_ReadWriteBlock (hPlx, dwOffset, buf, dwBytes, FALSE, addrSpace, mode);
}

void IOP480_SetMode (IOP480_HANDLE hPlx, IOP480_ADDR addrSpace, DWORD dwLocalAddr)
{
    DWORD dwRegOffset = 8*(addrSpace-IOP480_ADDR_SPACE0);
    IOP480_ADDR_DESC *addrDesc = &hPlx->addrDesc[addrSpace];
    addrDesc->dwLocalBase = dwLocalAddr & addrDesc->dwMask;
    addrDesc->dwLocalBase |= BIT0;
    IOP480_WriteReg (hPlx, IOP480_LAS0BA + dwRegOffset, addrDesc->dwLocalBase);
}

BYTE IOP480_ReadByteLocal (IOP480_HANDLE hPlx, DWORD dwLocalAddr)
{
    DWORD dwOffset = hPlx->addrDesc[hPlx->addrSpace].dwMask & dwLocalAddr;
    IOP480_SetMode (hPlx, IOP480_ADDR_SPACE0, dwLocalAddr);
    return IOP480_ReadByte(hPlx, hPlx->addrSpace, dwOffset);
}

void IOP480_WriteByteLocal (IOP480_HANDLE hPlx, DWORD dwLocalAddr, BYTE data)
{
    DWORD dwOffset = hPlx->addrDesc[hPlx->addrSpace].dwMask & dwLocalAddr;
    IOP480_SetMode (hPlx, IOP480_ADDR_SPACE0, dwLocalAddr);
    IOP480_WriteByte(hPlx, hPlx->addrSpace, dwOffset, data);
}

WORD IOP480_ReadWordLocal (IOP480_HANDLE hPlx, DWORD dwLocalAddr)
{
    DWORD dwOffset = hPlx->addrDesc[hPlx->addrSpace].dwMask & dwLocalAddr;
    IOP480_SetMode (hPlx, IOP480_ADDR_SPACE0, dwLocalAddr);
    return IOP480_ReadWord(hPlx, hPlx->addrSpace, dwOffset);
}

void IOP480_WriteWordLocal (IOP480_HANDLE hPlx, DWORD dwLocalAddr, WORD data)
{
    DWORD dwOffset = hPlx->addrDesc[hPlx->addrSpace].dwMask & dwLocalAddr;
    IOP480_SetMode (hPlx, IOP480_ADDR_SPACE0, dwLocalAddr);
    IOP480_WriteWord(hPlx, hPlx->addrSpace, dwOffset, data);
}

DWORD IOP480_ReadDWordLocal (IOP480_HANDLE hPlx, DWORD dwLocalAddr)
{
    DWORD dwOffset = hPlx->addrDesc[hPlx->addrSpace].dwMask & dwLocalAddr;
    IOP480_SetMode (hPlx, IOP480_ADDR_SPACE0, dwLocalAddr);
    return IOP480_ReadDWord(hPlx, hPlx->addrSpace, dwOffset);
}

void IOP480_WriteDWordLocal (IOP480_HANDLE hPlx, DWORD dwLocalAddr, DWORD data)
{
    DWORD dwOffset = hPlx->addrDesc[hPlx->addrSpace].dwMask & dwLocalAddr;
    IOP480_SetMode (hPlx, IOP480_ADDR_SPACE0, dwLocalAddr);
    IOP480_WriteDWord(hPlx, hPlx->addrSpace, dwOffset, data);
}

void IOP480_ReadWriteBlockLocal (IOP480_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
                    DWORD dwBytes, BOOL fIsRead, IOP480_MODE mode)
{
    DWORD dwOffset = hPlx->addrDesc[hPlx->addrSpace].dwMask & dwLocalAddr;
    IOP480_SetMode (hPlx, IOP480_ADDR_SPACE0, dwLocalAddr);
    IOP480_ReadWriteBlock(hPlx, dwOffset, buf, dwBytes, fIsRead, hPlx->addrSpace, mode);
}

void IOP480_ReadBlockLocal (IOP480_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
                    DWORD dwBytes, IOP480_MODE mode)
{
    IOP480_ReadWriteBlockLocal (hPlx, dwLocalAddr, buf, dwBytes, TRUE, mode);
}

void IOP480_WriteBlockLocal (IOP480_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
                     DWORD dwBytes, IOP480_MODE mode)
{
    IOP480_ReadWriteBlockLocal (hPlx, dwLocalAddr, buf, dwBytes, FALSE, mode);
}

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

VOID IOP480_IntHandler (PVOID pData)
{
    IOP480_HANDLE hPlx = (IOP480_HANDLE) pData;
    IOP480_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 IOP480_IntEnable (IOP480_HANDLE hPlx, IOP480_INT_HANDLER funcIntHandler)
{
    DWORD dwIntStatus;
    DWORD dwIntEnbAddr, dwIntStatAddr;

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

    dwIntStatus = IOP480_ReadReg (hPlx, IOP480_PINTENB);

    BZERO(hPlx->Int.Trans);
    // This is a sample of handling interrupts:
    // Two transfer commands are issued. First the value of the interrupt status
    // register is read.
    // The second 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!
    dwIntEnbAddr = hPlx->addrDesc[IOP480_ADDR_REG].dwAddr + IOP480_PINTENB;
    dwIntStatAddr = hPlx->addrDesc[IOP480_ADDR_REG].dwAddr + IOP480_PINTSTAT;
    hPlx->Int.Trans[0].cmdTrans = hPlx->addrDesc[IOP480_ADDR_REG].fIsMemory ? RM_DWORD : RP_DWORD;
    hPlx->Int.Trans[0].dwPort = dwIntStatAddr;
    hPlx->Int.Trans[1].cmdTrans = hPlx->addrDesc[IOP480_ADDR_REG].fIsMemory ? WM_DWORD : WP_DWORD;
    hPlx->Int.Trans[1].dwPort = dwIntEnbAddr;
    hPlx->Int.Trans[1].Data.Dword = dwIntStatus & ~BIT0; // 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, IOP480_IntHandler, (PVOID) hPlx))
        return FALSE;

    // this physically enables interrupts
    IOP480_WriteReg (hPlx, IOP480_PINTENB, BIT0|BIT8|BIT9|BIT10|BIT11|BIT12|BIT13);

    return TRUE;
}

void IOP480_IntDisable (IOP480_HANDLE hPlx)
{
    DWORD dwIntStatus;

    if (!hPlx->Int.hThread)