Subversion Repositories openarty

////////////////////////////////////////////////////////////////////////////////
//
// Filename: 	simple-ping.c
//
// Project:	OpenArty, an entirely open SoC based upon the Arty platform
//
// Purpose:	To exercise the network port by ...
//
//	1. Pinging another system, at 1PPS
//	2. Replying to ARP requests
//	3. Replying to external 'pings' requests
//
//	To configure this for your network, you will need to adjust the
//	following constants within this file:
//
//	my_ip_addr
//		This is the (fixed) IP address of your Arty board.  The first
//		octet of the IP address is kept in the high order word.
//
//	my_mac_addr	(unsigned long, 64 bits)
//		This is the fixed MAC address of your Arty board.  The first
//		two octets appear in bits 47:32 (MSB #s are high), and the other
//		four in bits 31:0. Since the Arty PHY does not come with a
//		designated MAC address, I generated one for my PHY using
//		/dev/rand.  The key to this, though, is that the second nibble
//		(bits 8..12) in my_mac_addr[0] must be set to 4'h2 to reflect
//		this fact.
//
//	ping_ip_addr
//		This is the IP address of the computer you wish to ping.
//
//	my_ip_router
//		In case the computer you wish to ping is not your
//		router/gateway, and worse that it is not on your network, then
//		you will need to fill this value in with the IP address of a
//		gateway server that is accessable from this network.  Place
//		that IP address into this variable.
//		
//	my_ip_mask
//		The IP mask is used to determine what is on your subnet, versus
//		what needs to be sent to your router/gateway.  Set this mask
//		such that a '1' is placed in every network bit of your IP
//		address, and '0' in every host bit.  For me, I am using a
//		network of 192.168.10.x, where x is the computer on the network,
//		so I set this to 0xffffff00.
//
//
// Creator:	Dan Gisselquist, Ph.D.
//		Gisselquist Technology, LLC
//
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015-2016, Gisselquist Technology, LLC
//
// This program is free software (firmware): you can redistribute it and/or
// modify it under the terms of  the GNU General Public License as published
// by the Free Software Foundation, either version 3 of the License, or (at
// your option) any later version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY or
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
// for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program.  (It's in the $(ROOT)/doc directory, run make with no
// target there if the PDF file isn't present.)  If not, see
// <http://www.gnu.org/licenses/> for a copy.
//
// License:	GPL, v3, as defined and found on www.gnu.org,
//		http://www.gnu.org/licenses/gpl.html
//
//
////////////////////////////////////////////////////////////////////////////////
//
//
#include "artyboard.h"
#include "zipcpu.h"
#include "zipsys.h"
#define	KTRAPID_SENDPKT	0
#include "etcnet.h"
#include "protoconst.h"
#include "ledcolors.h"
#include "ipcksum.h"
#include "arp.h"
 
#define	sys	_sys
 
unsigned	pkts_received = 0, replies_received=0, arp_requests_received=0,
		arp_pkt_count =0, arp_pkt_invalid =0,
		arp_missed_ip = 0, arp_non_broadcast = 0,
		ip_pkts_received = 0, ip_pkts_invalid = 0,
		icmp_echo_requests=0, icmp_invalid= 0,
		ping_reply_address_not_found = 0, ping_replies_sent = 0,
		ping_reply_err = 0, user_tx_packets = 0,
		user_heartbeats = 0;
 
unsigned long ping_mac_addr;
 
// These two numbers will allow us to keep track of how many ping's we've
// sent and how many we've received the returns for.
unsigned	ping_tx_count = 0, ping_rx_count = 0;
 
// This is a cheater's approach to knowing what IP to ping: we pre-load the
// program with both the IP address to ping, as well as the MAC address
// associated with that IP address.  Future implementations will need to
// 1. Look up the MAC address of the device we wish to ping (assuming our
//	subnet), or
// 2. Later, check if the IP address is not on our subnet, and if not then
//	look up the MAC address of the router and use that MAC address when
//	sending (no change to the IP)
unsigned	ping_ip_addr  = IPADDR(192,168,10,1);
unsigned long	ping_mac_addr = 0;
 
// My network ID.  The 192.168.10 part comes from the fact that this is a
// local network.  The .22 (last octet) is due to the fact that this is
// an unused ID on my network.
unsigned	my_ip_addr  = DEFAULTIP;
// Something from /dev/rand
//	Only ... the second nibble must be two.  Hence we start with d(2)d8.
unsigned long	my_mac_addr = DEFAULTMAC, router_mac_addr = 0;
unsigned	my_ip_mask = LCLNETMASK,
		my_ip_router = DEFAULT_ROUTERIP;
 
unsigned	pkt_id = 0;
 
///////////
//
//
// User tasks and functions (excluding ARP)
//
//
///////////
 
 
//
// We'll give our user 64kW of global variables
//
#define	USER_STACK_SIZE	4096
int	user_stack[USER_STACK_SIZE];
const int *user_sp = &user_stack[USER_STACK_SIZE];
 
 
void	uping_reply(unsigned ipaddr, unsigned *icmp_request) {
	unsigned	pkt[2048];
	unsigned long	hwaddr;
	int		maxsz = 2048;
 
	maxsz = 1<<((sys->io_enet.n_rxcmd>>24)&0x0f);
	if (maxsz > 2048)
		maxsz = 2048;
	int pktln = (icmp_request[0] & 0x0ffff)+8, pktlnw = (pktln+3)>>2;
 
	if (arp_lookup(ipaddr, &hwaddr)!=0) {
		// Couldn't find the address -- don't reply, but send an arp
		// request.
		//
		// ARP request is automatic when the address isn't found,
		// and done by the arp_lookup.
		ping_reply_address_not_found++;
	} else if ((pktlnw < maxsz)
			&&((icmp_request[0]>>24)==0x045)) {
		int		id;
 
		pkt[0] = (unsigned)(hwaddr>>16);
		pkt[1] = ((unsigned)(hwaddr<<16))|ETHERTYPE_IP;
		pkt[2] = icmp_request[0] & 0xff00ffff;
		id = pkt_id + sys->io_b.i_tim.sub;
		pkt[3] = (id&0x0ffff)<<16; // no fragments
		pkt[4] = 0xff010000;//No flags,frag offset=0,ttl=0,proto=1(ICMP)
		pkt[5] = icmp_request[4];	// Swap sender and receiver
		pkt[6] = icmp_request[3];
		for(int k=7; k<pktlnw; k++)
			pkt[k] = icmp_request[k-2];
		pkt[7] = 0;
 
		if ((pktln & 3)!=0)
			pkt[pktlnw-1] &= ~((1<<((4-(pktln&3))<<3))-1);
 
		// Now, let's go fill in the IP and ICMP checksums
		pkt[4] |= ipcksum(5, &pkt[2]);
 
		pkt[7] &= 0xffff0000;
		pkt[7] |= ipcksum(pktlnw-7, &pkt[7]);
 
		ping_replies_sent++;
 
		syscall(KTRAPID_SENDPKT,0,(unsigned)pkt, pktln);
	} else
		ping_reply_err ++;
}
 
unsigned	rxpkt[2048];
void	user_task(void) {
	unsigned	rtc = sys->io_rtc.r_clock;
 
	while(1) {
		do {
			unsigned long	mac;
 
			// Rate limit our ARP searching to one Hz
			rtc = sys->io_rtc.r_clock;
 
			if (arp_lookup(ping_ip_addr, &ping_mac_addr) == 0)
				arp_lookup(my_ip_router, &mac);
 
			while(((sys->io_enet.n_rxcmd & ENET_RXAVAIL)==0)
					&&(sys->io_rtc.r_clock == rtc))
				user_heartbeats++;
		} while((sys->io_enet.n_rxcmd & ENET_RXAVAIL)==0);
 
		// Okay, now we have a receive packet ... let's process it
		int	etype = sys->io_enet_rx[1] & 0x0ffff;
		unsigned *epayload; //  = (unsigned *)&sys->io_enet_rx[2];
		int	invalid = 0;
		int	ln, rxcmd = sys->io_enet.n_rxcmd;
 
		ln = sys->io_enet.n_rxcmd & 0x07ff;
		for(int k=0; k<(ln+3)>>2; k++)
			rxpkt[k] = sys->io_enet_rx[k];
		epayload = &rxpkt[2];
		sys->io_enet.n_rxcmd = ENET_RXCLR|ENET_RXCLRERR;
 
		pkts_received++;
 
		if (etype == ETHERTYPE_IP) {
			unsigned *ip = epayload,
				*ippayload = &ip[(ip[0]>>24)&0x0f];
 
			if (((ip[0]>>28)&15)!=4)
				invalid = 1;
			else if (ip[1] & 0x0bfff)
				// Packet is fragmented--toss it out	
				invalid = 1;
			else if (ip[4] != my_ip_addr)
				invalid = 1;
 
			ip_pkts_received += (invalid^1);
			ip_pkts_invalid  += (invalid);
 
			unsigned ipproto = (ip[2]>>16)&0x0ff;
			if((invalid==0)&&(ipproto == IPPROTO_ICMP)) {
				unsigned icmp_type = ippayload[0]>>24;
				if (icmp_type == ICMP_ECHOREPLY) {
					// We got our ping response
					sys->io_b.i_clrled[3] = LEDC_GREEN;
					sys->io_b.i_leds = 0x80;
					ping_rx_count++;
				} else if (icmp_type == ICMP_ECHO) {
					// Someone is pinging us
					uping_reply(ip[3],ip);
					icmp_echo_requests++;
				} else
					icmp_invalid++;
			}
		} else if (etype == ETHERTYPE_ARP) {
			arp_pkt_count++;
			if (epayload[0] != 0x010800) {
				invalid = 1;
				arp_pkt_invalid++;
			} else if ((epayload[1] == 0x06040001)
				&&(rxcmd & ENET_RXBROADCAST)
				&&(epayload[6] == my_ip_addr))
				{ // ARP Request
				unsigned sha[2], // Senders HW address
					sip, // Senders IP address
					dip; // Desired IP address
				sha[0] = epayload[2];
				sha[1] = epayload[3]>>16;
				sha[1] |= sha[0]<<16;
				sha[0] >>= 16;
				sip = (epayload[3]<<16)|(epayload[4]>>16);
				arp_requests_received++;
				send_arp_reply(sha[0], sha[1], sip);
			} else if ((epayload[1] == 0x06040002) // Reply
				&&((rxcmd & ENET_RXBROADCAST)==0)
				&&(epayload[6] == my_ip_addr)) {
				unsigned	sip;
				unsigned long	sha;
 
				sha = *(unsigned long *)(&epayload[2]);
				sha >>= 16;
				sip = (epayload[3]<<16)|(epayload[4]>>16);
				if (sip == ping_ip_addr)
					ping_mac_addr = sha;
				arp_table_add(sip, sha);
			}
		}
	}
}
 
 
///////////
//
//
// Supervisor tasks and functions
//
//
///////////
 
 
void	send_ping(void) {
	unsigned *pkt;
 
	// If we don't know our destination MAC address yet, just return
	if (ping_mac_addr==0) {
		sys->io_b.i_clrled[1] = LEDC_YELLOW;
		return;
	}
 
	// If the network is busy transmitting, wait for it to finish
	if (sys->io_enet.n_txcmd & ENET_TXBUSY) {
		while(sys->io_enet.n_txcmd & ENET_TXBUSY)
			;
	}
 
	// Form a packet to transmit
	pkt = (unsigned *)&sys->io_enet_tx;
	pkt[0] = (ping_mac_addr>>16);
	pkt[1] = ((unsigned)(ping_mac_addr<<16))|ETHERTYPE_IP;
	pkt[2] = 0x4500001c;
	pkt_id += BIG_PRIME; // A BIG prime number
	pkt[3] = (pkt_id&0x0ffff)<<16;;
	pkt[4] = 0x80010000; // No flags, ragment offset = 0, ttl=0, proto=1(ICMP)
	pkt[5] =   my_ip_addr;
	pkt[6] = ping_ip_addr;
	// Ping payload: type = 0x08 (PING, the response will be zero)
	//	CODE = 0
	//	Checksum will be filled in later
	pkt[7] = 0x08000000;
	pkt_id += BIG_PRIME;
	pkt[8] = (pkt_id + BIG_PRIME);
 
	// Calculate the IP header checksum
	pkt[4] |= ipcksum(5, &pkt[2]);
 
	// Calculate the PING payload checksum
	pkt[7] &= 0xffff0000;
	pkt[7] |= ipcksum(2, &pkt[7]);
 
	// Finally, send the packet -- 9*4 = our total number of octets
	sys->io_enet.n_txcmd = ENET_TXCMD(9*4);
 
	ping_tx_count++;
}
 
 
int	heartbeats = 0, subbeats = 0, gbl_picv = 0;
int main(int argc, char **argv) {
	unsigned	user_context[16];
	int		lastpps;
 
	for(int i=0; i<16; i++)
		user_context[i] = 0;
	user_context[13] = (unsigned)user_sp;
	user_context[15] = (unsigned)user_task;
	restore_context(user_context);
 
	init_arp_table();
 
	for(int i=0; i<4; i++)
		sys->io_b.i_clrled[i] = LEDC_BRIGHTRED;
	sys->io_b.i_leds = 0x0ff;
 
	// Start up the network interface
	if ((sys->io_enet.n_txcmd & ENET_RESET)!=0)
		sys->io_enet.n_txcmd = 0; // Turn on all our features
	{
		volatile unsigned long *emac = (volatile unsigned long *)&sys->io_enet.n_mac;
		*emac = my_mac_addr;
	}
 
	// Turn off our right-hand LED, first part of startup is complete
	sys->io_b.i_leds = 0x010;
	// Turn our first CLR LED green as well
	sys->io_b.i_clrled[0] = LEDC_GREEN;
 
	// Set our timer to have us send a ping 1/sec
	zip->z_tma = CLOCKFREQ_HZ | TMR_INTERVAL;
 
	sys->io_enet.n_rxcmd = ENET_RXCLRERR|ENET_RXCLR;
 
	while(1) {
		unsigned	picv, bmsr;
 
		heartbeats++;
 
		// Wait while the link is being negotiated
		// --- Read the MDIO status register
		bmsr = sys->io_netmdio.e_v[MDIO_BMSR];
		if ((bmsr & 4)==0) {
			// Link is down, do nothing this time through
			sys->io_b.i_clrled[1] = LEDC_BRIGHTRED;
			sys->io_b.i_clrled[2] = LEDC_BRIGHTRED;
			sys->io_b.i_clrled[3] = LEDC_BRIGHTRED;
		} else {
			sys->io_b.i_leds = 0x020;
			sys->io_b.i_clrled[1] = LEDC_GREEN;
			send_ping();
			sys->io_b.i_clrled[2] = LEDC_BRIGHTRED; // Have we received a response?
			sys->io_b.i_clrled[3] = LEDC_BRIGHTRED; // Was it our ping response?
		}
 
		// Clear any timer or PPS interrupts, disable all others
		zip->z_pic = DALLPIC;
		zip->z_pic = EINT(SYSINT_TMA|SYSINT_PPS|SYSINT_ENETRX);
		do {
			if ((zip->z_pic & INTNOW)==0)
				zip_rtu();
			subbeats++;
 
			picv = zip->z_pic;
			gbl_picv = picv;
 
			// Clear the ints we just saw.  Warning, though, we'll
			// need to re-enable them later
			zip->z_pic = (picv & 0x0ffff);
 
			if (zip_ucc() & CC_FAULT) {
				sys->io_b.i_leds = 0x0ff;
				sys->io_b.i_clrled[0] = LEDC_BRIGHTRED;
				sys->io_b.i_clrled[1] = LEDC_BRIGHTRED;
				sys->io_b.i_clrled[2] = LEDC_BRIGHTRED;
				sys->io_b.i_clrled[3] = LEDC_BRIGHTRED;
				zip_halt();
			} else if (zip_ucc() & CC_TRAP) {
				save_context((int *)user_context);
				// R0 = return address
				// R1 = Trap ID, write or send
				// R2 = FD, or socketFD
				// R3 = buffer
				// R4 = count
				// R5 = (flags, i socket)
				unsigned *sptr = (void *)user_context[3], ln;
				ln = user_context[4];
				while(sys->io_enet.n_txcmd & ENET_TXBUSY)
					;
				if (ln < 1400) {
					for(int i=0; i<(ln+3)>>2; i++)
						sys->io_enet_tx[i] = *sptr++;
					sys->io_enet.n_txcmd = ENET_TXCMD(ln);
 
					user_tx_packets++;
					// (Re-)Enable the transmit complete
					// interrupt
					//
					// At this point, we are also ready to
					// receive another packet
					zip->z_pic = EINT(SYSINT_ENETTX|SYSINT_ENETRX);
				}
 
				user_context[14] &= ~CC_TRAP;
				restore_context(user_context);
			} else if ((picv & INTNOW)==0) {
				sys->io_b.i_leds = 0x0ff;
				sys->io_b.i_clrled[0] = LEDC_BRIGHTRED;
				sys->io_b.i_clrled[1] = LEDC_WHITE;
				sys->io_b.i_clrled[2] = LEDC_BRIGHTRED;
				sys->io_b.i_clrled[3] = LEDC_BRIGHTRED;
				zip_halt();
			} else if ((picv & DINT(SYSINT_TMA))==0) {
				sys->io_b.i_leds = 0x0ff;
				sys->io_b.i_clrled[0] = LEDC_BRIGHTRED;
				sys->io_b.i_clrled[1] = LEDC_BRIGHTRED;
				sys->io_b.i_clrled[2] = LEDC_WHITE;
				sys->io_b.i_clrled[3] = LEDC_BRIGHTRED;
				zip_halt();
			} else if ((picv & DINT(SYSINT_PPS))==0) {
				sys->io_b.i_leds = 0x0ff;
				sys->io_b.i_clrled[0] = LEDC_BRIGHTRED;
				sys->io_b.i_clrled[1] = LEDC_BRIGHTRED;
				sys->io_b.i_clrled[2] = LEDC_BRIGHTRED;
				sys->io_b.i_clrled[3] = LEDC_WHITE;
				zip_halt();
			} if (picv & SYSINT_ENETRX) {
				// This will not clear until the packet has
				// been removed and the interface reset.  For
				// now, just double check that the interrupt
				// has been disabled.
				if (picv&(DINT(SYSINT_ENETRX))) {
					zip->z_pic = DINT(SYSINT_ENETRX);
					sys->io_b.i_leds = 0x040;
					sys->io_b.i_clrled[2] = LEDC_GREEN;
				}
			} else
				zip->z_pic = EINT(SYSINT_ENETRX);
			if (picv & SYSINT_ENETTX) {
				// This will also likewise not clear until a 
				// packet has been queued up for transmission.
				// Hence, let's just disable the interrupt.
				if (picv&(DINT(SYSINT_ENETTX)))
					zip->z_pic = DINT(SYSINT_ENETTX);
			} else
				zip->z_pic = EINT(SYSINT_ENETTX);
			// Make certain interrupts remain enabled
			zip->z_pic = EINT(SYSINT_TMA|SYSINT_PPS);
 
			if (picv & SYSINT_TMA) {
				if (lastpps==1)
					lastpps = 2;
				else {
					picv &= ~SYSINT_TMA;
					lastpps = 0;
				}
			}
		} while((picv & (SYSINT_TMA|SYSINT_PPS))==0);
		if (picv & SYSINT_PPS) {
			lastpps = 1;
			zip->z_tma = CLOCKFREQ_HZ | TMR_INTERVAL;
		}
	}
}