p9050_lib.c

powerspan pci slave device driver

    trans.dwOptions = 0;
    trans.Data.pBuffer = buf;
    WD_Transfer (hPlx->hWD, &trans);
}


void P9050_ReadSpaceBlock (P9050_HANDLE hPlx, DWORD dwOffset, PVOID buf, 
                    DWORD dwBytes, P9050_ADDR addrSpace, P9050_MODE mode)
{
    P9050_ReadWriteSpaceBlock (hPlx, dwOffset, buf, dwBytes, TRUE, addrSpace, mode);
}


void P9050_WriteSpaceBlock (P9050_HANDLE hPlx, DWORD dwOffset, PVOID buf, 
                     DWORD dwBytes, P9050_ADDR addrSpace, P9050_MODE mode)
{
    P9050_ReadWriteSpaceBlock (hPlx, dwOffset, buf, dwBytes, FALSE, addrSpace, mode);
}


BYTE P9050_ReadByte (P9050_HANDLE hPlx, P9050_ADDR addrSpace, DWORD dwLocalAddr)
{
    DWORD dwOffset = hPlx->addrDesc[addrSpace].dwMask & dwLocalAddr;
    P9050_SetMode (hPlx, addrSpace, dwLocalAddr);
    return P9050_ReadSpaceByte(hPlx, addrSpace, dwOffset);
}


void P9050_WriteByte (P9050_HANDLE hPlx, P9050_ADDR addrSpace, DWORD dwLocalAddr, BYTE data)
{
    DWORD dwOffset = hPlx->addrDesc[addrSpace].dwMask & dwLocalAddr;
    P9050_SetMode (hPlx, addrSpace, dwLocalAddr);
    P9050_WriteSpaceByte(hPlx, addrSpace, dwOffset, data);
}


WORD P9050_ReadWord (P9050_HANDLE hPlx, P9050_ADDR addrSpace, DWORD dwLocalAddr)
{
    DWORD dwOffset = hPlx->addrDesc[addrSpace].dwMask & dwLocalAddr;
    P9050_SetMode (hPlx, addrSpace, dwLocalAddr);
    return P9050_ReadSpaceWord(hPlx, addrSpace, dwOffset);
}


void P9050_WriteWord (P9050_HANDLE hPlx, P9050_ADDR addrSpace, DWORD dwLocalAddr, WORD data)
{
    DWORD dwOffset = hPlx->addrDesc[addrSpace].dwMask & dwLocalAddr;
    P9050_SetMode (hPlx, addrSpace, dwLocalAddr);
    P9050_WriteSpaceWord(hPlx, addrSpace, dwOffset, data);
}


DWORD P9050_ReadDWord (P9050_HANDLE hPlx, P9050_ADDR addrSpace, DWORD dwLocalAddr)
{
    DWORD dwOffset = hPlx->addrDesc[addrSpace].dwMask & dwLocalAddr;
    P9050_SetMode (hPlx, addrSpace, dwLocalAddr);
    return P9050_ReadSpaceDWord(hPlx, addrSpace, dwOffset);
}


void P9050_WriteDWord (P9050_HANDLE hPlx, P9050_ADDR addrSpace, DWORD dwLocalAddr, DWORD data)
{
    DWORD dwOffset = hPlx->addrDesc[addrSpace].dwMask & dwLocalAddr;
    P9050_SetMode (hPlx, addrSpace, dwLocalAddr);
    P9050_WriteSpaceDWord(hPlx, addrSpace, dwOffset, data);
}


void P9050_ReadWriteBlock (P9050_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
                    DWORD dwBytes, BOOL fIsRead, P9050_ADDR addrSpace, P9050_MODE mode)
{
    DWORD dwOffset = hPlx->addrDesc[addrSpace].dwMask & dwLocalAddr;
    P9050_SetMode (hPlx, addrSpace, dwLocalAddr);
    P9050_ReadWriteSpaceBlock(hPlx, dwOffset, buf, dwBytes, fIsRead, addrSpace, mode);
}


void P9050_ReadBlock (P9050_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
                    DWORD dwBytes, P9050_ADDR addrSpace, P9050_MODE mode)
{
    P9050_ReadWriteBlock (hPlx, dwLocalAddr, buf, dwBytes, TRUE, addrSpace, mode);
}


void P9050_WriteBlock (P9050_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
                     DWORD dwBytes, P9050_ADDR addrSpace, P9050_MODE mode)
{
    P9050_ReadWriteBlock (hPlx, dwLocalAddr, buf, dwBytes, FALSE, addrSpace, mode);
}



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


void P9050_IntHandler (PVOID pData)
{
    P9050_HANDLE hPlx = (P9050_HANDLE) pData;
    P9050_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 P9050_IntEnable (P9050_HANDLE hPlx, P9050_INT_HANDLER funcIntHandler)
{
    DWORD dwIntStatus;
    DWORD dwAddr;

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

    dwIntStatus = P9050_ReadReg (hPlx, P9050_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[P9050_ADDR_REG].dwAddr + P9050_INTCSR;
    hPlx->Int.Trans[0].cmdTrans = hPlx->addrDesc[P9050_ADDR_REG].fIsMemory ? RM_DWORD : RP_DWORD;
    hPlx->Int.Trans[0].dwPort = dwAddr;
    hPlx->Int.Trans[1].cmdTrans = hPlx->addrDesc[P9050_ADDR_REG].fIsMemory ? WM_DWORD : WP_DWORD;
    hPlx->Int.Trans[1].dwPort = dwAddr;
    hPlx->Int.Trans[1].Data.Dword = dwIntStatus & ~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, P9050_IntHandler, (PVOID) hPlx))
        return FALSE;

    // this physically enables interrupts
    P9050_WriteReg (hPlx, P9050_INTCSR, dwIntStatus | BIT6);

    return TRUE;
}


void P9050_IntDisable (P9050_HANDLE hPlx)
{
    DWORD dwIntStatus;

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

    // this disables interrupts
    dwIntStatus = P9050_ReadReg (hPlx, P9050_INTCSR);
    P9050_WriteReg (hPlx, P9050_INTCSR, dwIntStatus & ~BIT6);

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

    hPlx->Int.hThread = NULL;
}


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


void P9050_EEPROMChipSelect(P9050_HANDLE hPlx, BOOL fSelect)
{
    DWORD dwCNTRL = P9050_ReadReg(hPlx, P9050_CNTRL);
    if (fSelect)
        dwCNTRL |= BIT25;
    else
        dwCNTRL &= ~BIT25;
    P9050_WriteReg(hPlx, P9050_CNTRL, dwCNTRL);
    P9050_EEPROMDelay(hPlx);
}


BOOL P9050_EEPROMValid(P9050_HANDLE hPlx)
{
    return (P9050_ReadReg(hPlx, P9050_CNTRL) & BIT28)==BIT28;
}


void P9050_EEPROMWriteBit(P9050_HANDLE hPlx, BOOL fBit)
{
    DWORD dwCNTRL = P9050_ReadReg(hPlx, P9050_CNTRL);

    dwCNTRL &= ~BIT24;
    if (fBit) // data
        dwCNTRL |= BIT26;
    else
        dwCNTRL &= ~BIT26;
    P9050_WriteReg( hPlx, P9050_CNTRL, dwCNTRL);
    P9050_EEPROMDelay(hPlx);

    dwCNTRL |= BIT24; // clock
    P9050_WriteReg( hPlx, P9050_CNTRL, dwCNTRL);
    P9050_EEPROMDelay(hPlx);

    dwCNTRL &= ~BIT24;
    P9050_WriteReg( hPlx, P9050_CNTRL, dwCNTRL);
    P9050_EEPROMDelay(hPlx);
}


BOOL P9050_EEPROMReadBit(P9050_HANDLE hPlx)
{
    BOOL fRet;
    DWORD dwCNTRL = P9050_ReadReg(hPlx, P9050_CNTRL);

    dwCNTRL &= ~BIT24;
    P9050_WriteReg( hPlx, P9050_CNTRL, dwCNTRL);
    P9050_EEPROMDelay(hPlx);

    dwCNTRL |= BIT24; // clock
    P9050_WriteReg( hPlx, P9050_CNTRL, dwCNTRL);
    P9050_EEPROMDelay(hPlx);

    dwCNTRL &= ~BIT24;
    P9050_WriteReg( hPlx, P9050_CNTRL, dwCNTRL);
    P9050_EEPROMDelay(hPlx);

    fRet = (P9050_ReadReg( hPlx, P9050_CNTRL) & BIT27)==BIT27;

    return fRet;
}


void P9050_EEPROMWriteEnableDisable(P9050_HANDLE hPlx, BOOL fEnable)
{
    P9050_EEPROMChipSelect(hPlx, TRUE);

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

    P9050_EEPROMWriteBit(hPlx, 0);
    P9050_EEPROMWriteBit(hPlx, 0);
    P9050_EEPROMWriteBit(hPlx, 0);
    P9050_EEPROMWriteBit(hPlx, 0);

    P9050_EEPROMChipSelect(hPlx, FALSE);
}


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

    *pwData = 0;

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

    P9050_EEPROMWriteEnableDisable(hPlx, FALSE);
    
    return TRUE;
}


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

    P9050_EEPROMWriteEnableDisable(hPlx, TRUE);

    P9050_EEPROMChipSelect(hPlx, TRUE);

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

    P9050_EEPROMChipSelect(hPlx, FALSE);
    
    P9050_EEPROMWriteEnableDisable(hPlx, FALSE);

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

    return TRUE;
}


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

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

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


BOOL P9050_EEPROMWriteDWord(P9050_HANDLE hPlx, DWORD dwOffset, DWORD dwData)
{
    WORD wData1, wData2;

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

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

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

    return TRUE;
}