net_core.c

关于s3c2440之bootloader的源代码

/*
 * vivi/net/net_core.c 
 *
 * Based on u-boot
 *
 * $Id: net_core.c,v 1.0 2004/08/12 11:14:01 kingmonkey Exp $
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * Description: some functions for  net routines .
 *
 */ 
#include "config.h" 
#include "machine.h"
#include "printk.h"
#include "bootp.h"
#include "tftp.h"
#include "rarp.h"
#include "nfs.h"
#include "time.h"
#include "net.h"
#include <string.h>
#include <types.h>

//#define ET_DEBUG 0

#define ARP_TIMEOUT		50		/* Seconds before trying ARP again */

#ifndef	CONFIG_NET_RETRY_COUNT
#define ARP_TIMEOUT_COUNT	100		/* # of timeouts before giving up  */
#else
#define ARP_TIMEOUT_COUNT  (CONFIG_NET_RETRY_COUNT)
#endif


net_config *global_bd = (net_config *)(VIVI_PRIV_RAM_BASE + NET_CONFIG_OFFSET + 8);		/* gloable config info from flash*/
ulong downfilesize;
ulong downfileaddr;

/** BOOTP EXTENTIONS **/
IPaddr_t	NetOurSubnetMask=0;		/* Our subnet mask (0=unknown)	*/
IPaddr_t	NetOurGatewayIP=0;		/* Our gateways IP address	*/
IPaddr_t	NetOurDNSIP=0;			/* Our DNS IP address		*/

#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_DNS2)
IPaddr_t	NetOurDNS2IP=0;			/* Our 2nd DNS IP address	*/
#endif

char		NetOurNISDomain[32]={0,};	/* Our NIS domain		*/
char		NetOurHostName[32]={0,};	/* Our hostname			*/
char		NetOurRootPath[64]={0,};	/* Our bootpath			*/
ushort		NetBootFileSize=0;		/* Our bootfile size in blocks	*/

/** END OF BOOTP EXTENTIONS **/

ulong		NetBootFileXferSize;	/* The actual transferred size of the bootfile (in bytes) */
uchar		NetOurEther[6];		/* Our ethernet address			*/
uchar		NetServerEther[6] =	/* Boot server enet address		*/
			{ 0, 0, 0, 0, 0, 0 };
IPaddr_t	NetOurIP=0;		/* Our IP addr (0 = unknown)		*/
IPaddr_t	NetServerIP=0;		/* Our IP addr (0 = unknown)		*/
volatile uchar *NetRxPkt;		/* Current receive packet		*/
int		NetRxPktLen=0;		/* Current rx packet length		*/
unsigned	NetIPID=0;		/* IP packet ID				*/
uchar		NetBcastAddr[6] ={ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };	/* Ethernet bcast address		*/
uchar		NetEtherNullAddr[6] = { 0, 0, 0, 0, 0, 0 };

#ifdef CONFIG_CMD_CDP
uchar		NetCDPAddr[6] =	{ 0x01, 0x00, 0x0c, 0xcc, 0xcc, 0xcc };	/* Ethernet bcast address		*/
#endif

int		NetState=0;		/* Network loop state			*/

/* XXX in both little & big endian machines 0xFFFF == ntohs(-1) */
ushort		NetOurVLAN = 0xFFFF;		/* default is without VLAN	*/
ushort		NetOurNativeVLAN = 0xFFFF;	/* ditto			*/

char		BootFile[128]={0,};		/* Boot File name			*/

#ifdef CONFIG_CMD_PING
IPaddr_t	NetPingIP=0;		/* the ip address to ping 		*/
static void PingStart(void);
#endif

#ifdef  CONFIG_CMD_CDP
static void CDPStart(void);
#endif

volatile uchar	PktBuf[(PKTBUFSRX+1) * PKTSIZE_ALIGN + PKTALIGN];

volatile uchar *NetRxPackets[PKTBUFSRX]; /* Receive packets			*/

static rxhand_f *packetHandler;		/* Current RX packet handler		*/
static thand_f *timeHandler;		/* Current timeout handler		*/
static ulong	timeStart;		/* Time base value			*/
static ulong	timeDelta;		/* Current timeout value		*/
volatile uchar *NetTxPacket = 0;	/* THE transmit packet			*/

static int net_check_prereq (proto_t protocol);

/**********************************************************************/

IPaddr_t	NetArpWaitPacketIP;
IPaddr_t	NetArpWaitReplyIP;
uchar	       *NetArpWaitPacketMAC;	/* MAC address of waiting packet's destination	*/
uchar          *NetArpWaitTxPacket;	/* THE transmit packet			*/
int		NetArpWaitTxPacketSize;
uchar 		NetArpWaitPacketBuf[PKTSIZE_ALIGN + PKTALIGN];
ulong		NetArpWaitTimerStart;
int		NetArpWaitTry;


extern int eth_init(net_config *bis);			/* Initialize the device	*/

extern int eth_send(volatile void *packet, int length);	   /* Send a packet	*/
extern int eth_rx(void);			/* Check for received packets	*/
extern void eth_halt(void);			/* stop SCC			*/
extern char *eth_get_name(void);		/* get name of current device	*/

void ArpRequest (void)
{
	int i;
	volatile uchar *pkt;
	ARP_t *arp;

//	printk("ARP broadcast %d\n", NetArpWaitTry);

	pkt = NetTxPacket;

	pkt += NetSetEther (pkt, NetBcastAddr, PROT_ARP);

	arp = (ARP_t *) pkt;

	arp->ar_hrd = htons (ARP_ETHER);
	arp->ar_pro = htons (PROT_IP);
	arp->ar_hln = 6;
	arp->ar_pln = 4;
	arp->ar_op = htons (ARPOP_REQUEST);

	memcpy (&arp->ar_data[0], NetOurEther, 6);		/* source ET addr       */
	NetWriteIP ((uchar *) & arp->ar_data[6], NetOurIP);	/* source IP addr       */
	for (i = 10; i < 16; ++i) {
		arp->ar_data[i] = 0;				/* dest ET addr = 0     */
	}

	if ((NetArpWaitPacketIP & NetOurSubnetMask) !=
	    (NetOurIP & NetOurSubnetMask)) {
		if (NetOurGatewayIP == 0) {
			printk("## Warning: gatewayip needed but not set\n");
		}
		NetArpWaitReplyIP = NetOurGatewayIP;
	} else {
		NetArpWaitReplyIP = NetArpWaitPacketIP;
	}

	NetWriteIP ((uchar *) & arp->ar_data[16], NetArpWaitReplyIP);
	(void) eth_send (NetTxPacket, (pkt - NetTxPacket) + ARP_HDR_SIZE);
}

void ArpTimeoutCheck(void)
{
	ulong t;
	if (!NetArpWaitPacketIP)
		return;
	
	t = get_timer(0);

	/* check for arp timeout */
	if ((t - NetArpWaitTimerStart) > ARP_TIMEOUT * CFG_HZ) {
		NetArpWaitTry++;

		if (NetArpWaitTry >= ARP_TIMEOUT_COUNT) {
			printk("\nARP Retry count exceeded; starting again\n");
			NetArpWaitTry = 0;
			NetStartAgain();
		} else {
			NetArpWaitTimerStart = t;
			ArpRequest();
		}
	}
}

/**********************************************************************/
/*
 *	Main network processing loop.
 */

int
NetLoop(proto_t protocol)
{
	
	net_config *bd = global_bd;

	downfilesize = 0;

	/* XXX problem with bss workaround */
	NetArpWaitPacketMAC = NULL;
	NetArpWaitTxPacket = NULL;
	NetArpWaitPacketIP = 0;
	NetArpWaitReplyIP = 0;
	NetArpWaitTxPacket = NULL;
	NetTxPacket = NULL;

	if (!NetTxPacket) {
		int	i;
		/*
		 *	Setup packet buffers, aligned correctly.
		 */
		NetTxPacket = &PktBuf[0] + (PKTALIGN - 1);
		NetTxPacket -= (ulong)NetTxPacket % PKTALIGN;
		for (i = 0; i < PKTBUFSRX; i++) {
			NetRxPackets[i] = NetTxPacket + (i+1)*PKTSIZE_ALIGN;
		}
	}

	if (!NetArpWaitTxPacket) {
		NetArpWaitTxPacket = &NetArpWaitPacketBuf[0] + (PKTALIGN - 1);
		NetArpWaitTxPacket -= (ulong)NetArpWaitTxPacket % PKTALIGN;
		NetArpWaitTxPacketSize = 0;
	}

	eth_halt();

	if (eth_init(bd) < 0)
		return(-1);

restart:

	memcpy (NetOurEther, bd->bi_enetaddr, 6);

	NetState = NETLOOP_CONTINUE;

	/*
	 *	Start the ball rolling with the given start function.  From
	 *	here on, this code is a state machine driven by received
	 *	packets and timer events.
	 */

	switch (protocol) {
	case NFS:
	case PING:
	case TFTP:
/*		
		NetCopyIP(&NetOurIP, &bd->bi_ip_addr);
		NetCopyIP(&NetOurGatewayIP, &bd->gatewayip);
		NetCopyIP(&NetOurSubnetMask, &bd->netmask);
		NetCopyVLAN(&NetOurVLAN, &bd->vlan);
		NetCopyVLAN(&NetOurNativeVLAN, &bd->nvlan);

		NetOurIP=htonl(bd->bi_ip_addr);
		NetOurGatewayIP=htonl(bd->gatewayip);
		NetOurSubnetMask=htonl(bd->netmask);
		NetOurVLAN=htonl(bd->vlan);
		NetOurNativeVLAN=htonl(bd->nvlan);
*/

		NetOurIP=bd->bi_ip_addr;
		NetOurGatewayIP=bd->gatewayip;
		NetOurSubnetMask=bd->netmask;
		NetOurVLAN=bd->vlan;
		NetOurNativeVLAN=bd->nvlan;
		
		switch (protocol) {
		case NFS:
		case TFTP:
//			NetCopyIP(&NetServerIP, &bd->serverip);
//			NetServerIP=htonl(bd->serverip);
			NetServerIP=bd->serverip;
			break;

		case PING:
			/* nothing */
			break;

		default:
			break;
		}

		break;
	case BOOTP:
	case RARP:
		/*
		 * initialize our IP addr to 0 in order to accept ANY
		 * IP addr assigned to us by the BOOTP / RARP server
		 */
		NetOurIP = 0;
		NetCopyIP(&NetServerIP, &bd->serverip);
		NetCopyVLAN(&NetOurVLAN, &bd->vlan);
		NetCopyVLAN(&NetOurNativeVLAN, &bd->nvlan);
 	case CDP:
		NetCopyVLAN(&NetOurVLAN, &bd->vlan);
		NetCopyVLAN(&NetOurNativeVLAN, &bd->nvlan);

		break;
	default:
		break;
	}

	switch (net_check_prereq (protocol)) {
	case 1:
		/* network not configured */
		return (-1);

	case 0:
		switch (protocol) {
		case TFTP:
		#ifdef CONFIG_CMD_TFTP
			/* always use ARP to get server ethernet address */
			TftpStart();
		#endif
			break;

		case DHCP:
			/* Start with a clean slate... */
			NetOurIP = 0;
			NetCopyIP(&NetServerIP, &bd->serverip);
		#ifdef CONFIG_CMD_DHCP
			DhcpRequest();		/* Basically same as BOOTP */
		#endif
			break;

		case BOOTP:
		#ifdef CONFIG_CMD_BOOTP
			BootpTry = 0;
			BootpRequest ();
		#endif
			break;

		case RARP:
		#ifdef CONFIG_CMD_RARP
			RarpTry = 0;
			RarpRequest ();
		#endif
			break;

		case PING:
		#ifdef  CONFIG_CMD_PING
			PingStart();
		#endif
			break;

		case NFS:
		#ifdef CONFIG_CMD_NFS
			NfsStart();
		#endif
			break;

		case CDP:
		#ifdef CONFIG_CMD_CDP
			CDPStart();
		#endif
			break;

		default:
			break;
		}

		NetBootFileXferSize = 0;
		break;
	}

	/*
	 *	Main packet reception loop.  Loop receiving packets until
	 *	someone sets `NetQuit'.
	 */

	for (;;) {
	//	PingStart();
//	printk("here for netloop\n");
		/*
		 *	Check the ethernet for a new packet.  The ethernet
		 *	receive routine will process it.
		 */
		eth_rx();

		/*
		 *	Abort if ctrl-c was pressed.
		 */
/*		if (ctrlc()) {
			eth_halt();
			printk("\nAbort\n");
			return (-1);
		}
*/
		ArpTimeoutCheck();

		/*
		 *	Check for a timeout, and run the timeout handler
		 *	if we have one.
		 */

		if (timeHandler && ((get_timer(0) - timeStart) > timeDelta)) {
			thand_f *x;

			x = timeHandler;
			timeHandler = (thand_f *)0;
			(*x)();
		}

		switch (NetState) {

		case NETLOOP_RESTART:
			printk("goto restart\n");
			goto restart;

		case NETLOOP_SUCCESS:
			if (NetBootFileXferSize > 0) {
				printk("Bytes transferred = %ld (%lx hex)\n",NetBootFileXferSize,NetBootFileXferSize);
				downfilesize = NetBootFileXferSize;
			}
			eth_halt();

			return NetBootFileXferSize;

		case NETLOOP_FAIL:
			return (-1);
		}
	}
}

/**********************************************************************/

static void
startAgainTimeout(void)
{
	NetState = NETLOOP_RESTART;
}

static void
startAgainHandler(uchar * pkt, unsigned dest, unsigned src, unsigned len)
{
	/* Totally ignore the packet */
	return ;
}

void NetStartAgain (void)
{	
//	eth_halt ();
//	NetState = NETLOOP_FAIL;
	
	NetSetTimeout (10 * CFG_HZ, startAgainTimeout);
	NetSetHandler (startAgainHandler);
		return;	
}

/**********************************************************************/
/*
 *	Miscelaneous bits.
 */

void
NetSetHandler(rxhand_f * f)
{
	packetHandler = f;
}


void
NetSetTimeout(int iv, thand_f * f)
{
	if (iv == 0) {
		timeHandler = (thand_f *)0;
	} else {
		timeHandler = f;
		timeStart = get_timer(0);
		timeDelta = iv;
	}
}


void
NetSendPacket(volatile uchar * pkt, int len)
{
	(void) eth_send(pkt, len);
}

int
NetSendUDPPacket(uchar *ether, IPaddr_t dest, int dport, int sport, int len)
{
	uchar *pkt;

	/* convert to new style broadcast */
	if (dest == 0)
		dest = 0xFFFFFFFF;

	/* if broadcast, make the ether address a broadcast and don't do ARP */
	if (dest == 0xFFFFFFFF)
		ether = NetBcastAddr;

	/* if MAC address was not discovered yet, save the packet and do an ARP request */
	if (memcmp(ether, NetEtherNullAddr, 6) == 0) {


//		printk("sending ARP for "); print_IPaddr(dest); printk("\n");

		NetArpWaitPacketIP = dest;
		NetArpWaitPacketMAC = ether;