cs8900.c

2440的又一BSP

/*++
THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.
Copyright (c) 1995-1998  Microsoft Corporation

Module Name:

    cs8900.c

Abstract:

    Card-specific functions for the NDIS 3.0 CS8900 driver.
    
Updates:

	2003.10.24	jylee	changes on interrupt registration for NDIS
	

--*/

#include "precomp.h"


// CS8900 signature read from PacketPage Pointer port at reset
#define CS8900_SIGNATURE                0x3000
// CS8900 EISA number
#define CS8900_EISA_NUMBER              0x630e
// CS8900 product ID
#define CS8900_PRDCT_ID                 0x0000
#define CS8900_PRDCT_ID_MASK            0xe0ff

#define PKTPG_EISA_NUMBER               0x0000
#define PKTPG_PRDCT_ID_CODE             0x0002

volatile unsigned char *EthCommand;
volatile S3C2440A_INTR_REG *v_pINTRegs;
volatile S3C2440A_IOPORT_REG *v_pIOPRegs;
volatile S3C2440A_MEMCTRL_REG *v_pMEMRegs;

unsigned short GetD_SlowIO(unsigned long regaddrs)
{
	return (*(volatile unsigned short *)regaddrs);
}

void SetD_SlowIO(unsigned long regaddrs, unsigned short regvalue)
{
	*(volatile unsigned short *)regaddrs = regvalue;
}

//Read data from a PacketPage register.
unsigned short CS8900ReadRegister(unsigned short offset)
{
	writeIoPort(IO_PACKET_PAGE_POINTER, offset);
	return readIoPort(IO_PACKET_PAGE_DATA_0);
}

// Write data to a PacketPage register.
void CS8900WriteRegister(unsigned short offset, unsigned short data)
{
	writeIoPort(IO_PACKET_PAGE_POINTER, offset);
	writeIoPort(IO_PACKET_PAGE_DATA_0, data);
}

int findCS(void)
{
	unsigned short sg;

	/* Check the signature. */
	if ((sg = readIoPort(IO_PACKET_PAGE_POINTER)) != CS8900_SIGNATURE)
	{
		DEBUGMSG(1, (TEXT("Signature Error %x\n"), sg));
//		return FALSE;
	}

	/* Check the EISA registration number. */
	if (CS8900ReadRegister(PKTPG_EISA_NUMBER) != CS8900_EISA_NUMBER)
	{
		DEBUGMSG(1, (TEXT("Eisa Number Error\n")));
		return FALSE;
	}

	/* Check the Product ID. */
	if ((CS8900ReadRegister(PKTPG_PRDCT_ID_CODE) & CS8900_PRDCT_ID_MASK)
		!= CS8900_PRDCT_ID)
	{
		DEBUGMSG(1, (TEXT("Product ID Error\n")));
		return FALSE;
	}

	DEBUGMSG(1, (TEXT("Product ID = %x\n"), CS8900ReadRegister(PKTPG_PRDCT_ID_CODE)));


	return TRUE;
}

//Reset CS8900 chip.
#define MAX_COUNT	0x100000
int resetCS(void)
{
	int i;
	unsigned short dummy;

    // nGCS3=nUB/nLB(nSBHE),nWAIT,16-bit
    v_pMEMRegs->BWSCON = (v_pMEMRegs->BWSCON&~(0xf<<12))|(0xd<<12);	
    // BANK3 access timing
	v_pMEMRegs->BANKCON3=((CS8900_Tacs<<13)+(CS8900_Tcos<<11)+(CS8900_Tacc<<8)+(CS8900_Tcoh<<6)\
		+(CS8900_Tah<<4)+(CS8900_Tacp<<2)+(CS8900_PMC));
	v_pIOPRegs->EXTINT1 = (v_pIOPRegs->EXTINT1 & ~(7<<4)) | (4<<4);

    /* Issue a reset command to the chip */	
    CS8900WriteRegister(PKTPG_SELF_CTL, SELF_CTL_RESET);

    /* Delay for 125 micro-seconds */
	Sleep(10);

    /* Transition SBHE to switch chip from 8-bit to 16-bit */

#if	0
	*(volatile unsigned char *)&EthCommand[IO_PACKET_PAGE_POINTER];
	*(volatile unsigned char *)&EthCommand[IO_PACKET_PAGE_POINTER+1];
	*(volatile unsigned char *)&EthCommand[IO_PACKET_PAGE_POINTER];
	*(volatile unsigned char *)&EthCommand[IO_PACKET_PAGE_POINTER+1];
#endif

    /* Wait until initialization is done */
	Sleep(100);

	/* Wait until INITD bit of SelfST register is set. */
	i = 0;
	while (((dummy = CS8900ReadRegister(PKTPG_SELF_ST)) &
		SELF_ST_INITD) == 0)
	{
		if (++i > MAX_COUNT)
		{
			DEBUGMSG(1, (TEXT("resetCs8900 failed 1\n")));
			return FALSE;
		}
	}

	/* Wait until SIBUSY bit of SelfST register is cleared. */
	i = 0;
	while (((dummy = CS8900ReadRegister(PKTPG_SELF_ST)) &
		SELF_ST_SIBUSY) != 0)
	{
		if (++i > MAX_COUNT)
		{
			DEBUGMSG(1, (TEXT("resetCs8900 failed 2\n")));
			return FALSE;
		}
	}

	return TRUE;
}

void initIrq(void)
{
	unsigned short rdata;

	// interrupt enabling....  
	CS8900WriteRegister(PKTPG_INTERRUPT_NUMBER,INTERRUPT_NUMBER);
        
	rdata = CS8900ReadRegister(PKTPG_BUS_CTL) | BUS_CTL_ENABLE_IRQ;
	CS8900WriteRegister(PKTPG_BUS_CTL, rdata);

	rdata = CS8900ReadRegister(PKTPG_LINE_CTL) | LINE_CTL_RX_ON | LINE_CTL_TX_ON;

	CS8900WriteRegister(PKTPG_LINE_CTL, rdata);
}


//Initialize CS8900 chip.
int initCS()
{	
    HKEY hKey;
    DWORD dwSize, dwAngle1, dwAngle2, dwAngle3, dwType;
	DWORD tmp,tmph,tmpl;

    if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("Drivers\\CS8900"), 0, 0, &hKey))
    {
        dwSize = sizeof(DWORD);
        if (ERROR_SUCCESS == RegQueryValueEx(hKey,
                                             TEXT("MACAddress1"),
                                             NULL,
                                             &dwType,
                                             (LPBYTE)&dwAngle1,
                                             &dwSize))
        {
            tmpl = dwAngle1&0xff;
			tmph = (dwAngle1>>8)&0xff;
            dwAngle1=((tmpl<<8)&0xff00)|tmph;
        }
		if (ERROR_SUCCESS == RegQueryValueEx(hKey,
                                             TEXT("MACAddress2"),
                                             NULL,
                                             &dwType,
                                             (LPBYTE)&dwAngle2,
                                             &dwSize))
        { 
            tmpl = dwAngle2&0xff;
			tmph = (dwAngle2>>8)&0xff;
            dwAngle2=((tmpl<<8)&0xff00)|tmph;
        }
		if (ERROR_SUCCESS == RegQueryValueEx(hKey,
                                             TEXT("MACAddress3"),
                                             NULL,
                                             &dwType,
                                             (LPBYTE)&dwAngle3,
                                             &dwSize))
        {
            tmpl = dwAngle3&0xff;
			tmph = (dwAngle3>>8)&0xff;
            dwAngle3=((tmpl<<8)&0xff00)|tmph;
        }

        RegCloseKey(hKey);
    }





	CS8900WriteRegister(PKTPG_LINE_CTL, LINE_CTL_10_BASE_T);

	CS8900WriteRegister(PKTPG_RX_CFG, RX_CFG_RX_OK_I_E);

	CS8900WriteRegister(PKTPG_RX_CTL,
		RX_CTL_RX_OK_A | RX_CTL_IND_ADDR_A |
		RX_CTL_BROADCAST_A);

	CS8900WriteRegister(PKTPG_TX_CFG, 0); 

	CS8900WriteRegister(PKTPG_BUF_CFG, 0); 
	
	CS8900WriteRegister(PKTPG_INDIVISUAL_ADDR, dwAngle1);
	CS8900WriteRegister(PKTPG_INDIVISUAL_ADDR + 2, dwAngle2);
	CS8900WriteRegister(PKTPG_INDIVISUAL_ADDR + 4, dwAngle3);

	initIrq();

	return TRUE;
}

int CSInit()
{
	// Find CS8900 chip. 
	if (findCS() == FALSE)
		return FALSE;

	DEBUGMSG(1, (TEXT("Find CS8900 OK\r\n")));

	/* Reset CS8900 chip. */
	if (resetCS() == FALSE)
		return FALSE;

	DEBUGMSG(1, (TEXT("reset CS8900 OK\r\n")));

	/* Initialize CS8900 chip. */
	if (initCS() == FALSE)
		return FALSE;

	DEBUGMSG(1, (TEXT("CS8900 init OK\r\n")));

	return TRUE;		
}