ne2000.c

网卡芯片8019在uip+lpc下的驱动程序

//#include "armnet.h"
//#include "44blib.h"
//#include "44b.h"
#include "at91m40800.h"
#include "ne2000.h"
#include "comdef.h"
#include "..\app\lpc_glb.h"

NODE locnode;       //本机的节点信息结构(mac,ip,mask,port)
NICHDR 	nichdr;
#define min(a, b)  (((a) < (b)) ? (a) : (b)) 
#define max(a, b)  (((a) > (b)) ? (a) : (b)) 

#define IP4_ADDR(a,b,c,d) ((unsigned int)(a & 0xff) << 24) | ((unsigned int)(b & 0xff) << 16) | \
                          ((unsigned int)(c & 0xff) << 8) | (unsigned int)(d & 0xff)

//void SwapEther(ETHERFRAME *efp);

void Delay (uint32 dly)
{
	uint32 i;
	
	for ( ; dly>0; dly--)
		for (i=0; i<500; i++);
}
unsigned char default_mac[MACLEN] = {0x12,0x34,0x56,0x78,0x90,0xab};

void NodeInit(void)
{
	locnode.ip = IP4_ADDR(192,168,0,2);
	locnode.mask = IP4_ADDR(255,255,255,0);
	locnode.gate = IP4_ADDR(192,168,0,254);
	memcpy(locnode.mac,default_mac,6);
	locnode.port = 9000;
}


void ResetNic(void)
{
	
	unsigned char temp;

	NodeInit();

//lwm	MA_OUTWM(AIC_IDCR, AIC_IRQ0,AIC_IRQ0);
		AT91C_BASE_AIC->AIC_IDCR = 1 << IRQ0_ID;

//lwm 	MA_OUTWM(PIO_PDR,PIO_9,PIO_9);	
		AT91C_BASE_PIO->PIO_PDR = PIO_9;
	
//lwm 	MA_OUTW(AIC_SMR_IRQ0, 0x40);		
//lwm 	MA_OUTW(AIC_SVR_IRQ0, 0x10000028);	
	
    	EN_CR = ENCR_PAGE0 + ENCR_NODMA + ENCR_START;
//lwm 	Delay(100);		

	/*GPC20	output*/
//lwm 	MA_OUTWM(PIO_PER,PIO_20,PIO_20);	
//lwm 	MA_OUTWM(PIO_OER,PIO_20,PIO_20);	
		AT91C_BASE_PIO->PIO_PER = PIO_20;
		AT91C_BASE_PIO->PIO_OER = PIO_20;
	
	#if NE_WORDMODE
//lwm 		MA_OUTWM(PIO_SODR,PIO_20,PIO_20);
		AT91C_BASE_PIO->PIO_SODR = PIO_20;
	#else
//lwm 		MA_OUTWM(PIO_CODR,PIO_20,PIO_20);
		AT91C_BASE_PIO->PIO_CODR = PIO_20;
	#endif
	Delay(500);
	temp = EN_RESET;
	EN_RESET = temp;
	Delay(500);
//lwm 	MA_OUTWM(PIO_CODR,PIO_20,PIO_20);
	AT91C_BASE_PIO->PIO_CODR = PIO_20;

	//MA_OUTWM(PIO_PDR,PIO_20,PIO_20);	
	
    EN_CR = ENCR_PAGE0 + ENCR_NODMA + ENCR_STOP;
    Delay(100);
    
    if(EN_ISR & ENISR_RESET)
    {
    	;//lwm Uart_Printf("\nNIC Reset OK!\n");
    }
    else
    {
    	;//lwm Uart_Printf("\nNIC Reset Failed!\n");
    	return;
    }
    
    EN_DCR 		= NE_DCRVAL;
    EN_RBCR0 	= 0x00; 				/* MSB remote byte count reg */
    EN_RBCR1 	= 0x00; 				/* LSB remote byte count reg */
    EN_RCR 		= ENRCR_RXOFF; 			/* RX configuration reg    Monitor mode (no packet receive) */
    EN_TCR 		= ENTCR_TXOFF; 			/* TX configuration reg    set internal loopback mode  */
    EN_TPSR     = TX_START_PG;
    EN_PSTART   = RX_START_PG ; 		/* DMA START PAGE 46h */ 
    EN_PSTOP  	= RX_STOP_PG;    		/* Ending page +1 of ring buffer */
    EN_BNRY 	= RX_START_PG;			/* Boundary page of ring buffer */
    EN_ISR      = 0xff; 				/* INTerrupt stauts reg */
    EN_IMR      = ENIMR_RX | ENIMR_RX_ERR | ENIMR_TX | ENIMR_TX_ERR;

    EN_CR = ENCR_PAGE1 + ENCR_NODMA + ENCR_STOP;
    Delay(100);
    EN_PAR0 	= locnode.mac[0];
    EN_PAR1 	= locnode.mac[1];
    EN_PAR2 	= locnode.mac[2];
    EN_PAR3 	= locnode.mac[3];
    EN_PAR4 	= locnode.mac[4];
    EN_PAR5 	= locnode.mac[5];
    EN_MAR0 	= 0xff;  
    EN_MAR1 	= 0xff;
    EN_MAR2 	= 0xff;
    EN_MAR3 	= 0xff;
    EN_MAR4 	= 0xff;
    EN_MAR5 	= 0xff;
    EN_MAR6 	= 0xff;
    EN_MAR7 	= 0xff;
    EN_CURR 	= RX_START_PG + 1; 		/* RX_CURR_PG; Current memory page = RX_CURR_PG  ? */
  
    EN_CR = ENCR_PAGE0 + ENCR_NODMA ;  	/* 00001010B: PS1 PS0 RD2 RD1 RD0 TXP STA STP */
    Delay(100);
    EN_RCR 		= ENRCR_RXCONFIG;   	/* rx on(broadcasts, no multicast,errors   04*/
    EN_TCR 		= ENTCR_TXCONFIG; 		/* xmit on. */
    EN_ISR 		= 0xff; 	 			/* Individual bits are cleared by writing a "1" into it. */
    EN_IMR 		= ENISR_ALL; 			/* INTerrupt mask reg */
    
	EN_CR = ENCR_PAGE0 + ENCR_NODMA + ENCR_START;
}

void getnic(unsigned short addr, unsigned char data[],unsigned short len)
{
	unsigned short count;
	unsigned short * dataw;
	
	count = NE_WORDMODE ? len >> 1 : len;
	
	EN_ISR 	 = ENISR_RDC;							// clear remote dma interrupt flag
  	EN_RBCR0 = (unsigned char)(len & 0xff);			// read length low
	EN_RBCR1 = (unsigned char)(len >> 8);			// read length high
	EN_RSAR0 = (unsigned char)(addr & 0xff);		// read address low
	EN_RSAR1 = (unsigned char)(addr >> 8);			// read address high
	EN_CR  	 = ENCR_RREAD + ENCR_START + ENCR_PAGE0;// do dma read
	
	#if NE_WORDMODE
    	dataw = (unsigned short *)data;				// Use pointer for speed 
    	while(count--)                      		// Get words 
        	*dataw++ = EN_DATAW;
    	if (len & 0x01)                        		// If odd length, do last byte 
        	*(unsigned char *)dataw = EN_DATAB;
	#else
    	while(count--)                      		// Get bytes 
        	*data++ = EN_DATAB;
	#endif
}

void putnic(unsigned short addr, unsigned char data[],unsigned short len)
{
	unsigned short count;
	unsigned short * dataw;
	
	len += len & 0x01;
	count = NE_WORDMODE ? len >> 1 : len;
		
	EN_ISR   = ENISR_RDC;							//clear remote dma interrupt flag
	EN_RBCR0 = (unsigned char)(len & 0xff);
	EN_RBCR1 = (unsigned char)(len >> 8);
	EN_RSAR0 = (unsigned char)(addr & 0xff);
	EN_RSAR1 = (unsigned char)(addr >> 8);
	EN_CR    = ENCR_RWRITE + ENCR_START + ENCR_PAGE0;
	
	#if NE_WORDMODE                            		/* Word transfer? */
    	dataw = (unsigned short *)data;
    	while(count--)
        	EN_DATAW = *dataw++;
	#else
    	while(count--)                  /* O/P bytes */
        	EN_DATAB = *data++;
	#endif
	
    count = 10000;                      /* Done: must ensure DMA complete */
    while(count && (EN_ISR & ENISR_RDC) == 0)
        count--;
}

unsigned char nicwrap(unsigned char page)
{
	if (page >= RX_STOP_PG)
		page += RX_START_PG - RX_STOP_PG;
	else if(page < RX_START_PG)
		page += RX_STOP_PG - RX_START_PG;
	return (page);
}	

unsigned short GetEthernet(ETHERFRAME *efp) 		
{
	unsigned short current_offset;
	unsigned char curr_page;
	unsigned char bnry;
	
	//if (EN_ISR & 0x10) ResetNic();     
								
	EN_CR = ENCR_NODMA + ENCR_PAGE1 + ENCR_START;  
	curr_page = EN_CURR;
	EN_CR = ENCR_NODMA + ENCR_PAGE0 + ENCR_START;
	bnry = EN_BNRY + 1;		
	if (bnry >=RX_STOP_PG) {
		led_on(0);
	  bnry = RX_START_PG;
	}

	if (bnry != curr_page)
    {
		current_offset = (unsigned short)(bnry << 8);
		memset((unsigned char *)&nichdr, 0xee, sizeof(nichdr));
		getnic(current_offset, (unsigned char *)&nichdr, sizeof(nichdr));

		if ((nichdr.stat & 0x01) && nichdr.len >= MINFRAMEC  && nichdr.len<=MAXFRAMEC)
			if(efp)
				getnic(current_offset + sizeof(nichdr), (unsigned char *)efp, nichdr.len - sizeof(nichdr));
		if (nichdr.next >= RX_START_PG && nichdr.next < RX_STOP_PG)
			bnry = nichdr.next;
		else
			bnry = nicwrap(bnry + 1);
		bnry = nicwrap(bnry - 1);
		EN_BNRY = bnry;
		return (nichdr.len - sizeof(nichdr));// - sizeof(ETHERHDR));
	}	
	return (0);
}


unsigned short PutEthernet(ETHERFRAME *efp, unsigned short len)
 {
 	 if  (EN_CR & ENCR_TRANS)
 	     len=0;
 	 else  
 	 {
 	 	len = min(MAXFRAME,max(len,MINFRAME));
 	 	EN_CR = ENCR_PAGE0 + ENCR_NODMA;
 		EN_ISR = ENISR_TX + ENISR_TX_ERR;
 		EN_TBCR0=(unsigned char)(len & 0xff);
 		EN_TBCR1=(unsigned char)(len >> 8);
 		putnic(TX_START_PG << 8, (unsigned char *)efp, len);
 		EN_CR = ENCR_NODMA + ENCR_PAGE0 + ENCR_TRANS;
	 }
	 return(len);
}

void hwsend( unsigned char data[],unsigned short len)
{
	putnic(TX_START_PG << 8, data, len);
}

unsigned short MakeFrame(ETHERFRAME *efp, unsigned char srce[], unsigned char dest[], unsigned short pcol, unsigned short dlen)
{
 	unsigned char i;

    efp->e.ptype = pcol;
    for(i=0;i<MACLEN;i++)
    {
    	efp->e.dest[i] = dest[i];
		efp->e.srce[i] = srce[i];
	}
//	SwapEther(efp);
    dlen += sizeof(ETHERHDR);
    return(dlen);
}

/*
unsigned short swapw(unsigned short w);
unsigned short swapw(unsigned short w)
{	
	unsigned short s_w;
    s_w = ((w<<8)&0xff00) | ((w>>8)&0x00ff);
    return s_w;
}

void SwapEther(ETHERFRAME *efp)
{
    efp->e.ptype = swapw(efp->e.ptype);
}
*/

ETHERFRAME etherframe[4];
	
void  ISR_IRQ0(void)
{
	tag_tcp_buf *psp = &m_tcp_buf;
	unsigned char net_isr;

	//rI_ISPC = BIT_EINT3;
	
    AT91C_BASE_AIC->AIC_IDCR  = 1 << IRQ0_ID;
	EN_CR = ENCR_PAGE0 + ENCR_NODMA + ENCR_STOP;
	net_isr = EN_ISR;
	
	if(net_isr & ENISR_RX)
	{
		INT8U i;
		//DEBUGF(DEMO_DEBUG,("Rtl8019 Interrupted RX\n"));
		EN_ISR |= ENISR_RX;

		//memset((unsigned char *)efp, 0, sizeof(ETHERFRAME));
		//psp->rev_len = GetEthernet(efp);
//		SwapEther(efp);
		//memcpy( psp->rev_buf, (INT8U*)efp, psp->rev_len);

		for ( i = 0; i < 4; i++ ) {
			psp->efp[i] = &etherframe[i];
			psp->rev_len[i] = GetEthernet(psp->efp[i]);
			if ( psp->rev_len[i] == 0 )
				break;
		}

		OSMboxPost(g_glb_buf.mbox_tcp_rev, (void*)1);	//通信请求消息	
	}
	
	if(net_isr & ENISR_RX_ERR)
	{
		//DEBUGF(DEMO_DEBUG,("Rtl8019 Interrupted RX_ERR\n"));
		EN_ISR |= ENISR_RX_ERR;
	}
	
	if(net_isr & ENISR_TX)
	{
		//DEBUGF(DEMO_DEBUG,("Rtl8019 Interrupted TX\n"));
		EN_ISR |= ENISR_TX;
	}
	
	if(net_isr & ENISR_TX_ERR)
	{
		//DEBUGF(DEMO_DEBUG,("Rtl8019 Interrupted TX_ERR\n"));
		EN_ISR |= ENISR_TX_ERR;
	}		
	
	EN_CR = ENCR_PAGE0 + ENCR_NODMA + ENCR_START;
//	NET_INTERRUPT_ENABLE;
    AT91C_BASE_AIC->AIC_EOICR   = 0;                            /* Signal end of interrupt                    */
}