pspan_lib.c

adlink master board 6760 pci driver for control powerspan slave pci driver

        BZERO(trans);
        trans.cmdTrans = WP_DWORD;
        trans.dwPort = dwAddr;
        trans.Data.Dword = data;
        WD_Transfer (hPlx->hWD, &trans);
        
    }
    
}


void PSPAN_ReadWriteSpaceBlock (PSPAN_HANDLE hPlx, DWORD dwOffset, PVOID buf, 
                    DWORD dwBytes, BOOL fIsRead, PSPAN_ADDR addrSpace, PSPAN_MODE mode)
{
    WD_TRANSFER trans;
    DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddr + dwOffset;

    BZERO(trans);

    if (hPlx->addrDesc[addrSpace].fIsMemory) 
    {
        if (fIsRead) 
        {
            if (mode==PSPAN_MODE_BYTE) trans.cmdTrans = RM_SBYTE;
            else if (mode==PSPAN_MODE_WORD) trans.cmdTrans = RM_SWORD;
            else trans.cmdTrans = RM_SDWORD;
        }
        else 
        {
            if (mode==PSPAN_MODE_BYTE) trans.cmdTrans = WM_SBYTE;
            else if (mode==PSPAN_MODE_WORD) trans.cmdTrans = WM_SWORD;
            else trans.cmdTrans = WM_SDWORD;
        }
    }
    else 
    {
        if (fIsRead) 
        {
            if (mode==PSPAN_MODE_BYTE) trans.cmdTrans = RP_SBYTE;
            else if (mode==PSPAN_MODE_WORD) trans.cmdTrans = RP_SWORD;
            else trans.cmdTrans = RP_SDWORD;
        }
        else 
        {
            if (mode==PSPAN_MODE_BYTE) trans.cmdTrans = WP_SBYTE;
            else if (mode==PSPAN_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 PSPAN_ReadSpaceBlock (PSPAN_HANDLE hPlx, DWORD dwOffset, PVOID buf, 
                    DWORD dwBytes, PSPAN_ADDR addrSpace, PSPAN_MODE mode)
{
    PSPAN_ReadWriteSpaceBlock (hPlx, dwOffset, buf, dwBytes, TRUE, addrSpace, mode);
}


void PSPAN_WriteSpaceBlock (PSPAN_HANDLE hPlx, DWORD dwOffset, PVOID buf, 
                     DWORD dwBytes, PSPAN_ADDR addrSpace, PSPAN_MODE mode)
{
    PSPAN_ReadWriteSpaceBlock (hPlx, dwOffset, buf, dwBytes, FALSE, addrSpace, mode);
}


BYTE PSPAN_ReadByte (PSPAN_HANDLE hPlx, PSPAN_ADDR addrSpace, DWORD dwLocalAddr)
{
    DWORD dwOffset = hPlx->addrDesc[addrSpace].dwMask & dwLocalAddr;
    PSPAN_SetMode (hPlx, addrSpace, dwLocalAddr);
    return PSPAN_ReadSpaceByte(hPlx, addrSpace, dwOffset);
}


void PSPAN_WriteByte (PSPAN_HANDLE hPlx, PSPAN_ADDR addrSpace, DWORD dwLocalAddr, BYTE data)
{
    DWORD dwOffset = hPlx->addrDesc[addrSpace].dwMask & dwLocalAddr;
    PSPAN_SetMode (hPlx, addrSpace, dwLocalAddr);
    PSPAN_WriteSpaceByte(hPlx, addrSpace, dwOffset, data);
}


WORD PSPAN_ReadWord (PSPAN_HANDLE hPlx, PSPAN_ADDR addrSpace, DWORD dwLocalAddr)
{
    DWORD dwOffset = hPlx->addrDesc[addrSpace].dwMask & dwLocalAddr;
    PSPAN_SetMode (hPlx, addrSpace, dwLocalAddr);
    return PSPAN_ReadSpaceWord(hPlx, addrSpace, dwOffset);
}


void PSPAN_WriteWord (PSPAN_HANDLE hPlx, PSPAN_ADDR addrSpace, DWORD dwLocalAddr, WORD data)
{
    DWORD dwOffset = hPlx->addrDesc[addrSpace].dwMask & dwLocalAddr;
    PSPAN_SetMode (hPlx, addrSpace, dwLocalAddr);
    PSPAN_WriteSpaceWord(hPlx, addrSpace, dwOffset, data);
}


DWORD PSPAN_ReadDWord (PSPAN_HANDLE hPlx, PSPAN_ADDR addrSpace, DWORD dwLocalAddr)
{
    DWORD dwOffset = hPlx->addrDesc[addrSpace].dwMask & dwLocalAddr;
    PSPAN_SetMode (hPlx, addrSpace, dwLocalAddr);
    return PSPAN_ReadSpaceDWord(hPlx, addrSpace, dwOffset);
}


void PSPAN_WriteDWord (PSPAN_HANDLE hPlx, PSPAN_ADDR addrSpace, DWORD dwLocalAddr, DWORD data)
{
    DWORD dwOffset = hPlx->addrDesc[addrSpace].dwMask & dwLocalAddr;
    PSPAN_SetMode (hPlx, addrSpace, dwLocalAddr);
    PSPAN_WriteSpaceDWord(hPlx, addrSpace, dwOffset, data);
}


void PSPAN_ReadWriteBlock (PSPAN_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
                    DWORD dwBytes, BOOL fIsRead, PSPAN_ADDR addrSpace, PSPAN_MODE mode)
{
    DWORD dwOffset = hPlx->addrDesc[addrSpace].dwMask & dwLocalAddr;
    PSPAN_SetMode (hPlx, addrSpace, dwLocalAddr);
    PSPAN_ReadWriteSpaceBlock(hPlx, dwOffset, buf, dwBytes, fIsRead, addrSpace, mode);
}


void PSPAN_ReadBlock (PSPAN_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
                    DWORD dwBytes, PSPAN_ADDR addrSpace, PSPAN_MODE mode)
{
    PSPAN_ReadWriteBlock (hPlx, dwLocalAddr, buf, dwBytes, TRUE, addrSpace, mode);
}


void PSPAN_WriteBlock (PSPAN_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
                     DWORD dwBytes, PSPAN_ADDR addrSpace, PSPAN_MODE mode)
{
    PSPAN_ReadWriteBlock (hPlx, dwLocalAddr, buf, dwBytes, FALSE, addrSpace, mode);
}



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


void PSPAN_IntHandler (PVOID pData)
{
    
    // Here is the user's interrupt routine
    
    PSPAN_HANDLE hPlx = (PSPAN_HANDLE) pData;
    PSPAN_INT_RESULT intResult;
    DWORD dwIntStatus;
    
    //dwIntStatus = PSPAN_ReadReg (hPlx, PSPAN_INTCSR);
    //PSPAN_WriteReg (hPlx, PSPAN_INTCSR, dwIntStatus & ~BIT6); // put here the data to write to the control register
    
    // here is the user code to do something
    logMsg("Now is in the user's interrupt routine.\n" );
    
    // this physically enables interrupts
    //PSPAN_WriteReg (hPlx, PSPAN_INTCSR, dwIntStatus | BIT6);
       
    return;
    
}


BOOL PSPAN_IntEnable (PSPAN_HANDLE hPlx, PSPAN_INT_HANDLER funcIntHandler)
{
    
    DWORD dwIntStatus;
    DWORD dwAddr;
    
    WD_INT wd_int;

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

    // pgn dwIntStatus = PSPAN_ReadReg (hPlx, PSPAN_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!
    
    // pgn PSPAN_WriteReg (hPlx, PSPAN_INTCSR, dwIntStatus & ~(BIT8) ); // put here the data to write to the control register

    // this calls WD_IntEnable() and creates an interrupt handler thread
    
    wd_int.params = hPlx;   //pgn++
    wd_int.pci = hPlx->pciSlot;
    wd_int.int_routine = funcIntHandler;
    if( WD_IntEnable(hPlx->hWD,&wd_int) != 0 )
    {
    	return FALSE;	
    }
    
    
    hPlx->Int.hThread = ~NULL;

    // this physically enables interrupts
    // pgn PSPAN_WriteReg (hPlx, PSPAN_INTCSR, dwIntStatus | (BIT8) );

    return TRUE;    
    
    
}


void PSPAN_IntDisable (PSPAN_HANDLE hPlx, PSPAN_INT_HANDLER funcIntHandler)
{
      
    DWORD dwIntStatus;
    WD_INT wd_int;

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

    // this disables interrupts
    // pgn dwIntStatus = PSPAN_ReadReg (hPlx, PSPAN_INTCSR);
    // pgn PSPAN_WriteReg (hPlx, PSPAN_INTCSR, dwIntStatus & ~(BIT8));

    // this calls WD_IntDisable()
    wd_int.pci = hPlx->pciSlot;
    wd_int.int_routine = funcIntHandler;
        
    WD_IntDisable(hPlx->hWD,&wd_int);

    hPlx->Int.hThread = NULL;
    
}


void PSPAN_IntSet (PSPAN_HANDLE hPlx)
{
      
    DWORD dwIntStatus;

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

    // this disables interrupts
    dwIntStatus = PSPAN_ReadReg (hPlx, PSPAN_INTCSR);
    PSPAN_WriteReg (hPlx, PSPAN_INTCSR, dwIntStatus | (BIT8) );

}


void PSPAN_IntClear (PSPAN_HANDLE hPlx)
{
      
    DWORD dwIntStatus;

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

    // this disables interrupts
    dwIntStatus = PSPAN_ReadReg (hPlx, PSPAN_INTCSR);
    PSPAN_WriteReg (hPlx, PSPAN_INTCSR, dwIntStatus & ~(BIT8));

}


///////////////////////////////////////////////////////////////
// eeprom begin

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


/******************************************************************************
* NAME: PSPAN_ProgramEeprom
*
* DESCRIPTION: Write a buffer in the eeprom
*
* INPUT PARAMETERS: 
*    buf  : pointer on the first byte of the buffer to write
*    size : size of the buffer (256 bytes max)
*
* OUTPUT PARAMETERS: none
*
* RETURN VALUES: 0
*
*******************************************************************************/
UCHAR PSPAN_ProgramEeprom(PSPAN_HANDLE hPlx, unsigned char * buf, unsigned char size)
{
	unsigned char addr;

	for( addr = 0; addr < size; addr++, buf++) PSPAN_EepromByteWrite (hPlx, addr, *buf);
	return 1;
}


/******************************************************************************
* NAME: PSPAN_ReadEeprom
*
* DESCRIPTION: Read the eeprom
*
* INPUT PARAMETERS: 
*   buf : address where to store eeprom data
*
* OUTPUT PARAMETERS: none
*
* RETURN VALUES: length 
* 
*******************************************************************************/
UCHAR PSPAN_ReadEeprom(PSPAN_HANDLE hPlx, unsigned char *buf)
{
	unsigned short addr, length, v;

	for( addr = 0, length = 0; addr < EEPROM_SIZE; addr++)
	{
		v = PSPAN_EepromByteRead(hPlx, addr);
		if( (*buf++) = v)
           length = addr;
	}
	return length;
}


/******************************************************************************
* NAME: PSPAN_EepromByteWrite
*
* DESCRIPTION: Write a byte in the eeprom, through the powerspan I2C/eeprom
*              interface Control and Status Register
*
* INPUT PARAMETERS:
*   addr :  eeprom offset where write data
*   data : byte to write
*
* OUTPUT PARAMETERS:
*
* RETURN VALUES:
*
*******************************************************************************/
void PSPAN_EepromByteWrite(PSPAN_HANDLE hPlx, unsigned char addr, unsigned char data)
{
	unsigned long v,s;

	v = ((unsigned long) addr)<<24 |((unsigned long) data)<<16 | 0xA100;
	
	while((s = PSPAN_ReadReg (hPlx, T_I2C_CSR)) & 0x80);  /* Wait ACT=0 */

	if (s & 0x40) pspan_lib_printf("e");

	PSPAN_WriteReg (hPlx, T_I2C_CSR, v); // protect by pgn for eeprom contents
}


/******************************************************************************
* NAME: PSPAN_EepromByteRead
*
* DESCRIPTION: Read a byte from the eeprom, through the powerspan I2C/eeprom
*              interface Control and Status Register
*
* INPUT PARAMETERS:
*   addr : eeprom offset where read data
*
* OUTPUT PARAMETERS: none
*
* RETURN VALUES: eeprom byte
*
*******************************************************************************/
UCHAR PSPAN_EepromByteRead(PSPAN_HANDLE hPlx, unsigned char addr)
{
	unsigned long v;

	v = ((unsigned long) addr)<<24 | 0xA000;
      

	while( PSPAN_ReadReg (hPlx, T_I2C_CSR) & 0x80);     /* Wait ACT=0 */

	PSPAN_WriteReg (hPlx, T_I2C_CSR, v);

	do v = PSPAN_ReadReg (hPlx, T_I2C_CSR);
	while( v & 0x80);                                   /* Wait ACT=0 */

	if (v&0x40) pspan_lib_printf("e");

	v >>= 16;
	return (unsigned char) v;
}


/******************************************************************************
* NAME: PSPAN_EepromWordWrite
*
* DESCRIPTION: Write a 2-bytes word in the eeprom
*
* INPUT PARAMETERS:
*   addr :  eeprom offset where write data
*   data : word to write
*
* OUTPUT PARAMETERS:
*
* RETURN VALUES: none
*
*******************************************************************************/
void PSPAN_EepromWordWrite(PSPAN_HANDLE hPlx, unsigned char addr, unsigned short data)
{
	PSPAN_EepromByteWrite(hPlx, addr, data & 0xFF);
	data >>= 8;
	PSPAN_EepromByteWrite(hPlx, addr + 1, data & 0xFF);
}


/******************************************************************************
* NAME: EepromWordRead
*
* DESCRIPTION: Read a 2-bytes word from the eeprom
*
* INPUT PARAMETERS:
*   addr : eeprom offset where read data
*
* OUTPUT PARAMETERS:
*
* RETURN VALUES: eeprom word
*
*******************************************************************************/
UINT PSPAN_EepromWordRead(PSPAN_HANDLE hPlx, unsigned char addr)
{
	unsigned short d;

	d   = (unsigned short) PSPAN_EepromByteRead(hPlx, addr + 1);
	d <<= 8;