cs8900.c

该原码包含有wince 和 linux 的移植和应用原码

/****************************************************************************
【文  件  名  称】CS8900.C
【功  能  描  述】CS8900网口驱动程序代码
【程  序  版  本】4.0
【创建人及创建日期】龚俊//2002年11月19日19:26
【修改人及修改日期】龚俊//2004-12-8 17:25
****************************************************************************/

//***************************************************************************
#include "def.h"
#include "44b.h"
#include "utils.h"

#include "Emac.h"
#include "eth.h"
#include "mac.h"
#include "CS8900.h"

#define IO_BASE_ADDR   ( 0x6000000 )
static U8 EmacAddr[ETH_ALEN] = {0x00,0x80,0x48,0x12,0x34,0x56};
//static U8 DstMacID[ETH_ALEN];

#define IOREAD(o)					( *( (volatile U16 *)(dwEthernetIOBase + (o)) ) )
#define IOWRITE(o, d)				*((volatile U16 *)(dwEthernetIOBase + (o))) = (U16)(d)

#define MEMREAD(o)					( *((volatile U16 *)(dwEthernetMemBase + (o))))
#define MEMWRITE(o, d)				*((volatile U16 *)(dwEthernetMemBase + (o))) = (U16)(d)

//#define	DEBUG_CS8900

#ifdef	DEBUG_CS8900
	#define	DBGMSG						printf
#else
	#define DBGMSG(...)
#endif

#define MAX_COUNT					0x100000

static U32 dwEthernetIOBase;
static U32 dwEthernetMemBase;

//#define CS8900_MEM_MODE

#ifdef	CS8900_MEM_MODE
	#define READ_REG1					ReadReg
	#define READ_REG2					MEMREAD
	
	#define WRITE_REG1					WriteReg
	#define WRITE_REG2					MEMWRITE
#else
	#define READ_REG1					ReadReg
	#define READ_REG2					ReadReg
	
	#define WRITE_REG1					WriteReg
	#define WRITE_REG2					WriteReg
#endif

static	int bIsPacket;

static U16 ReadReg(U16 offset)
{
	IOWRITE(IO_PACKET_PAGE_POINTER, offset);
	return IOREAD(IO_PACKET_PAGE_DATA_0);
}

static void WriteReg(U16 offset, U16 data)
{
	IOWRITE(IO_PACKET_PAGE_POINTER, offset);
	IOWRITE(IO_PACKET_PAGE_DATA_0 , data);
}

static int CS8900_Probe(int iobase, int membase)
{
	int r = FALSE;
	U16 sig=0;

	DBGMSG("CS8900 CS8900_Probe\n");

	dwEthernetIOBase  = iobase;
	dwEthernetMemBase = membase;
	
	do 
	{
		
		sig = IOREAD(IO_PACKET_PAGE_POINTER);

		if ( (sig & CS8900_SIGMSK) != CS8900_SIGNATURE )
		{
			DBGMSG("Signature Error\n");
			DBGMSG("Signature Read = 0x%04x\n", sig);
			break;
		}
		
		/* Check the EISA registration number.	*/
		sig = READ_REG1(PKTPG_EISA_NUMBER);
		if (sig != CS8900_EISA_NUMBER)
		{
			DBGMSG("EISA Number Error\n");
			DBGMSG("EISA Number Read = 0x%04x\n", sig);
			break;
		}
		
		/* Check the Product ID.				*/
		sig = READ_REG1(PKTPG_PRDCT_ID_CODE);
		if ((sig & CS8900_PRDCT_ID_MASK) != CS8900_PRDCT_ID )
		{
			DBGMSG("Product ID Error\n");
			DBGMSG("Product ID Read = 0x%04x\n", sig);
			break;
		}
	   
		DBGMSG("CS8900 is Detected!\n");
		r = TRUE;
	} while (0);

	return r;
}

static int CS8900_Reset(void)
{
	int r = FALSE;
	U16 dummy;
	int i;
											/* Set RESET bit of SelfCTL register.	*/
	do 
	{
		WRITE_REG1(PKTPG_SELF_CTL, SELF_CTL_RESET | SELF_CTL_LOW_BITS);

								/* Wait until INITD bit of SelfST register is set.	*/
		for (i = 0; i < MAX_COUNT; i++)
		{
			dummy = READ_REG1(PKTPG_SELF_ST);
			if (dummy & SELF_ST_INITD) break;
		}

		if (i >= MAX_COUNT)
		{
			DBGMSG("Reset failed (SelfST) \n");
			break;
		}

						/* Wait until SIBUSY bit of SelfST register is cleared.		*/
		for (i = 0; i < MAX_COUNT; i++)
		{
			dummy = READ_REG1(PKTPG_SELF_ST);
			if ((dummy & SELF_ST_SIBUSY) == 0) break;
		}

		if (i >= MAX_COUNT)
		{
			DBGMSG("Reset failed (SIBUSY) \n");
			break;
		}
		
		r = TRUE;
		DBGMSG("Reset Success!!\n");

	} while (0);

	return r;
}


static void EnableIRQ(void)
{
	U16 temp;
						/* If INTERRUPT_NUMBER is 0,							*/
						/*	Interrupt request will be generated from INTRQ0 pin */
	WRITE_REG2(PKTPG_INTERRUPT_NUMBER, INTERRUPT_NUMBER);

	temp = READ_REG2(PKTPG_BUS_CTL) | BUS_CTL_ENABLE_IRQ;

	WRITE_REG2(PKTPG_BUS_CTL, temp);

	temp = READ_REG2(PKTPG_LINE_CTL) | LINE_CTL_RX_ON | LINE_CTL_TX_ON;
	WRITE_REG2(PKTPG_LINE_CTL,temp);
}


static int Init(U16 *mac)
{
	U16 temp;

#ifdef CS8900_MEM_MODE

	WRITE_REG1(PKTPG_MEMORY_BASE_ADDR     , (U16)(dwEthernetMemBase & 0xffff));
	WRITE_REG1(PKTPG_MEMORY_BASE_ADDR + 2 , (U16)(dwEthernetMemBase >> 16   ));
	WRITE_REG1(PKTPG_BUS_CTL              ,  BUS_CTL_MEMORY_E | BUS_CTL_LOW_BITS);

#endif

	temp = READ_REG2(PKTPG_LINE_CTL) | LINE_CTL_10_BASE_T | LINE_CTL_MOD_BACKOFF;
	WRITE_REG2(	PKTPG_LINE_CTL, temp);
						
	WRITE_REG2(PKTPG_RX_CFG, RX_CFG_RX_OK_I_E | RX_CFG_LOW_BITS);

	WRITE_REG2(PKTPG_RX_CTL,
		            RX_CTL_RX_OK_A | RX_CTL_IND_ADDR_A | RX_CTL_BROADCAST_A | RX_CTL_LOW_BITS);

	WRITE_REG2(PKTPG_INDIVISUAL_ADDR + 0, *mac++);
	WRITE_REG2(PKTPG_INDIVISUAL_ADDR + 2, *mac++);
	WRITE_REG2(PKTPG_INDIVISUAL_ADDR + 4, *mac  );

	WRITE_REG2(PKTPG_TX_CFG, TX_CFG_LOW_BITS);

	EnableIRQ();
			
	DBGMSG("CS8900_Init OK.\n");
	return TRUE;
}

static int RcvPkt(char *pbData, int dwLength)
{
					/* use int rather than short for the reason of performance	*/
	int   length;
	int   rlen = 0;
	U16 *bp;
	U16	data;

														/* Discard RxStatus		*/
	data   = IOREAD(IO_RX_TX_DATA_0);
												/* Read the frame's length.		*/
	length = IOREAD(IO_RX_TX_DATA_0);

	if (length > dwLength) length = 0;

	bp    = (U16 *)pbData;

	rlen = length;

	while (rlen)
	{
		data = IOREAD(IO_RX_TX_DATA_0);

		if (rlen == 1)
		{
			*((char *)bp) = (char)data;
			rlen--;
		}
		else
		{
			*bp++ = data;
			rlen -= 2;
		}
	}

	return length;
}


static U16 TransmitPkt(char *pbData, U16 slen)
{
	U16 * bp;
	U16   data;
	int	 i;

	/* Send Command */
	IOWRITE(IO_TX_CMD, TX_CMD_START_ALL | TX_CMD_LOW_BITS);
	IOWRITE(IO_TX_LENGTH, slen);

	/* Wait			*/
	for (i = 0; i < MAX_COUNT; i++)
	{
		data = READ_REG2(PKTPG_BUS_ST);
		if (data & BUS_ST_RDY_4_TX_NOW) break;
	} 

	if (i >= MAX_COUNT) return 1;

	bp = (U16 *)pbData;

	while (slen)
	{			
		IOWRITE(IO_RX_TX_DATA_0, *bp++);
		slen--;
			
		if (slen) slen--;		
	}

	return 0;
}

/****************************************************************************
【功能说明】Received Packet
****************************************************************************/
int CS8900DBG_IsReceivedPacket(void)
{
	U16 event;
	int   r = FALSE;

	event = IOREAD(IO_ISQ);
		
//	DBGMSG("%x\n", event);

	if ( ((event & ISQ_REG_NUM   )    == REG_NUM_RX_EVENT ) &&
		 ((event & RX_EVENT_RX_OK)    == RX_EVENT_RX_OK   ) &&
		 ((event & RX_EVENT_IND_ADDR) | (event & RX_CTL_BROADCAST_A))) 
	{
		r = bIsPacket = TRUE;
//		DBGMSG("%x\n", event);
	}
	else
		bIsPacket = FALSE;

	return r;
}

/****************************************************************************
【功能说明】CS8900 initial
****************************************************************************/
int board_eth_init(void)
{	
	int r;

	bIsPacket = FALSE;
    
    DBGMSG("CS8900_Initial\n");
    
	DBGMSG("CS8900 Mac Address: %x:%x:%x:%x:%x:%x\r\n",
			  EmacAddr[0], EmacAddr[1],
			  EmacAddr[2], EmacAddr[3],
			  EmacAddr[4], EmacAddr[5]);
	r = -1; 
    do {
		if (!CS8900_Probe(IO_BASE_ADDR, 0))		break;
		if (!CS8900_Reset())				break;
		if (!Init((U16 *)EmacAddr))	break;
		r = 0;
	} while (0);
	return r;
}

/****************************************************************************
【功能说明】返回联接状态
****************************************************************************/
int board_eth_lnk_stat(void)
{
	return 0;
}

/****************************************************************************
【功能说明】发送数据
****************************************************************************/
int board_eth_send(unsigned char *data, unsigned int len)
{		
	return TransmitPkt((char *)data, len);
}

/****************************************************************************
【功能说明】接收数据
****************************************************************************/
int board_eth_rcv(unsigned char *data, unsigned int *len)
{
	int r = -1;
	
	if(CS8900DBG_IsReceivedPacket()) {
		U16 size;
			
		bIsPacket = FALSE;
//		DBGMSG("%x,", IOREAD(IO_RX_TX_DATA_0));
//		DBGMSG("%x,", IOREAD(IO_RX_TX_DATA_0));
		size = RcvPkt((char *)data, 1532);
		*len = size;
//		DBGMSG("received date %d\n", size);
//		RcvPkt((char *)data, size);
		r = 0;			
	}	

	return r;
}

/****************************************************************************
【功能说明】获取网口地址
****************************************************************************/
int board_eth_get_addr(unsigned char *addr)
{
	memcpy(addr, EmacAddr, ETH_ALEN);
	return 0;
}