[thirdparty/u-boot.git] / drivers / netconsole.c

/*
 * (C) Copyright 2004
 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
 *
 * See file CREDITS for list of people who contributed to this
 * project.
 *
 * This program is free software; 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 2 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
 * MERCHANTABILITY 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; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307 USA
 */

#include <common.h>

#ifdef CONFIG_NETCONSOLE

#include <command.h>
#include <devices.h>
#include <net.h>

#ifndef CONFIG_NET_MULTI
#error define CONFIG_NET_MULTI to use netconsole
#endif

static char input_buffer[512];
static int input_size = 0;		/* char count in input buffer */
static int input_offset = 0;		/* offset to valid chars in input buffer */
static int input_recursion = 0;
static int output_recursion = 0;
static int net_timeout;
static uchar nc_ether[6];		/* server enet address */
static IPaddr_t nc_ip;			/* server ip */
static short nc_port;			/* source/target port */
static const char *output_packet;	/* used by first send udp */
static int output_packet_len = 0;

static void nc_wait_arp_handler (uchar * pkt, unsigned dest, unsigned src,
				 unsigned len)
{
	NetState = NETLOOP_SUCCESS;	/* got arp reply - quit net loop */
}

static void nc_handler (uchar * pkt, unsigned dest, unsigned src,
			unsigned len)
{
	if (input_size)
		NetState = NETLOOP_SUCCESS;	/* got input - quit net loop */
}

static void nc_timeout (void)
{
	NetState = NETLOOP_SUCCESS;
}

void NcStart (void)
{
	if (!output_packet_len || memcmp (nc_ether, NetEtherNullAddr, 6)) {
		/* going to check for input packet */
		NetSetHandler (nc_handler);
		NetSetTimeout (net_timeout, nc_timeout);
	} else {
		/* send arp request */
		uchar *pkt;
		NetSetHandler (nc_wait_arp_handler);
		pkt = (uchar *) NetTxPacket + NetEthHdrSize () + IP_HDR_SIZE;
		memcpy (pkt, output_packet, output_packet_len);
		NetSendUDPPacket (nc_ether, nc_ip, nc_port, nc_port, output_packet_len);
	}
}

int nc_input_packet (uchar * pkt, unsigned dest, unsigned src, unsigned len)
{
	int end, chunk;

	if (dest != nc_port || !len)
		return 0;		/* not for us */

	if (input_size == sizeof input_buffer)
		return 1;		/* no space */
	if (len > sizeof input_buffer - input_size)
		len = sizeof input_buffer - input_size;

	end = input_offset + input_size;
	if (end > sizeof input_buffer)
		end -= sizeof input_buffer;

	chunk = len;
	if (end + len > sizeof input_buffer) {
		chunk = sizeof input_buffer - end;
		memcpy(input_buffer, pkt + chunk, len - chunk);
	}
	memcpy (input_buffer + end, pkt, chunk);

	input_size += len;

	return 1;
}

static void nc_send_packet (const char *buf, int len)
{
	DECLARE_GLOBAL_DATA_PTR;

	struct eth_device *eth;
	int inited = 0;
	uchar *pkt;
	uchar *ether;
	IPaddr_t ip;

	if ((eth = eth_get_dev ()) == NULL) {
		return;
	}

	if (!memcmp (nc_ether, NetEtherNullAddr, 6)) {
		if (eth->state == ETH_STATE_ACTIVE)
			return;	/* inside net loop */
		output_packet = buf;
		output_packet_len = len;
		NetLoop (NETCONS);	/* wait for arp reply and send packet */
		output_packet_len = 0;
		return;
	}

	if (eth->state != ETH_STATE_ACTIVE) {
		if (eth_init (gd->bd) < 0)
			return;
		inited = 1;
	}
	pkt = (uchar *) NetTxPacket + NetEthHdrSize () + IP_HDR_SIZE;
	memcpy (pkt, buf, len);
	ether = nc_ether;
	ip = nc_ip;
	NetSendUDPPacket (ether, ip, nc_port, nc_port, len);

	if (inited)
		eth_halt ();
}

int nc_start (void)
{
	int netmask, our_ip;

	nc_port = 6666;		/* default port */

	if (getenv ("ncip")) {
		nc_ip = getenv_IPaddr ("ncip");
		if (!nc_ip)
			return -1;	/* ncip is 0.0.0.0 */
		char *p = strchr (getenv ("ncip"), ':');
		if (p)
			nc_port = simple_strtoul (p + 1, NULL, 10);
	} else
		nc_ip = ~0;		/* ncip is not set */

	our_ip = getenv_IPaddr ("ipaddr");
	netmask = getenv_IPaddr ("netmask");

	if (nc_ip == ~0 ||				/* 255.255.255.255 */
	    ((netmask & our_ip) == (netmask & nc_ip) &&	/* on the same net */
	    (netmask | nc_ip) == ~0))			/* broadcast to our net */
		memset (nc_ether, 0xff, sizeof nc_ether);
	else
		memset (nc_ether, 0, sizeof nc_ether);	/* force arp request */

	return 0;
}

void nc_putc (char c)
{
	if (output_recursion)
		return;
	output_recursion = 1;

	nc_send_packet (&c, 1);

	output_recursion = 0;
}

void nc_puts (const char *s)
{
	if (output_recursion)
		return;
	output_recursion = 1;

	int len = strlen (s);

	if (len > 512)
		len = 512;

	nc_send_packet (s, len);

	output_recursion = 0;
}

int nc_getc (void)
{
	input_recursion = 1;

	net_timeout = 0;	/* no timeout */
	while (!input_size)
		NetLoop (NETCONS);

	input_recursion = 0;

	uchar c = input_buffer[input_offset];
	input_offset++;
	if (input_offset >= sizeof input_buffer)
		input_offset -= sizeof input_buffer;
	input_size--;

	return c;
}

int nc_tstc (void)
{
	struct eth_device *eth;

	if (input_recursion)
		return 0;

	if (input_size)
		return 1;

	eth = eth_get_dev ();
	if (eth && eth->state == ETH_STATE_ACTIVE)
		return 0;	/* inside net loop */

	input_recursion = 1;

	net_timeout = 1;
	NetLoop (NETCONS);	/* kind of poll */

	input_recursion = 0;

	return input_size != 0;
}

int drv_nc_init (void)
{
	device_t dev;
	int rc;

	memset (&dev, 0, sizeof (dev));

	strcpy (dev.name, "nc");
	dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT | DEV_FLAGS_SYSTEM;
	dev.start = nc_start;
	dev.putc = nc_putc;
	dev.puts = nc_puts;
	dev.getc = nc_getc;
	dev.tstc = nc_tstc;

	rc = device_register (&dev);

	return (rc == 0) ? 1 : rc;
}

#endif	/* CONFIG_NETCONSOLE */
Commit	Line	Data
68ceb29e WD	1	/*
	2	* (C) Copyright 2004
	3	* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
	4	*
	5	* See file CREDITS for list of people who contributed to this
	6	* project.
	7	*
	8	* This program is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU General Public License as
	10	* published by the Free Software Foundation; either version 2 of
	11	* the License, or (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
	21	* MA 02111-1307 USA
	22	*/
	23
	24	#include <common.h>
	25
	26	#ifdef CONFIG_NETCONSOLE
	27
	28	#include <command.h>
	29	#include <devices.h>
	30	#include <net.h>
	31
	32	#ifndef CONFIG_NET_MULTI
	33	#error define CONFIG_NET_MULTI to use netconsole
	34	#endif
	35
eedcd078 WD	36	static char input_buffer[512];
	37	static int input_size = 0; /* char count in input buffer */
	38	static int input_offset = 0; /* offset to valid chars in input buffer */
68ceb29e WD	39	static int input_recursion = 0;
	40	static int output_recursion = 0;
	41	static int net_timeout;
eedcd078 WD	42	static uchar nc_ether[6]; /* server enet address */
	43	static IPaddr_t nc_ip; /* server ip */
	44	static short nc_port; /* source/target port */
	45	static const char output_packet; / used by first send udp */
	46	static int output_packet_len = 0;
68ceb29e WD	47
	48	static void nc_wait_arp_handler (uchar * pkt, unsigned dest, unsigned src,
	49	unsigned len)
	50	{
	51	NetState = NETLOOP_SUCCESS; /* got arp reply - quit net loop */
	52	}
	53
	54	static void nc_handler (uchar * pkt, unsigned dest, unsigned src,
	55	unsigned len)
	56	{
eedcd078	57	if (input_size)
68ceb29e WD	58	NetState = NETLOOP_SUCCESS; /* got input - quit net loop */
	59	}
	60
	61	static void nc_timeout (void)
	62	{
	63	NetState = NETLOOP_SUCCESS;
	64	}
	65
	66	void NcStart (void)
	67	{
eedcd078	68	if (!output_packet_len \|\| memcmp (nc_ether, NetEtherNullAddr, 6)) {
68ceb29e WD	69	/* going to check for input packet */
	70	NetSetHandler (nc_handler);
	71	NetSetTimeout (net_timeout, nc_timeout);
	72	} else {
	73	/* send arp request */
eedcd078	74	uchar *pkt;
68ceb29e	75	NetSetHandler (nc_wait_arp_handler);
eedcd078 WD	76	pkt = (uchar *) NetTxPacket + NetEthHdrSize () + IP_HDR_SIZE;
	77	memcpy (pkt, output_packet, output_packet_len);
	78	NetSendUDPPacket (nc_ether, nc_ip, nc_port, nc_port, output_packet_len);
68ceb29e WD	79	}
	80	}
	81
	82	int nc_input_packet (uchar * pkt, unsigned dest, unsigned src, unsigned len)
	83	{
eedcd078 WD	84	int end, chunk;
	85
	86	if (dest != nc_port \|\| !len)
68ceb29e WD	87	return 0; /* not for us */
68ceb29e WD	88
eedcd078 WD	89	if (input_size == sizeof input_buffer)
	90	return 1; /* no space */
	91	if (len > sizeof input_buffer - input_size)
	92	len = sizeof input_buffer - input_size;
	93
	94	end = input_offset + input_size;
	95	if (end > sizeof input_buffer)
	96	end -= sizeof input_buffer;
	97
	98	chunk = len;
	99	if (end + len > sizeof input_buffer) {
	100	chunk = sizeof input_buffer - end;
	101	memcpy(input_buffer, pkt + chunk, len - chunk);
	102	}
	103	memcpy (input_buffer + end, pkt, chunk);
	104
	105	input_size += len;
	106
68ceb29e WD	107	return 1;
	108	}
	109
	110	static void nc_send_packet (const char *buf, int len)
	111	{
	112	DECLARE_GLOBAL_DATA_PTR;
	113
	114	struct eth_device *eth;
	115	int inited = 0;
	116	uchar *pkt;
eedcd078 WD	117	uchar *ether;
eedcd078 WD	118	IPaddr_t ip;
68ceb29e	119
eedcd078	120	if ((eth = eth_get_dev ()) == NULL) {
68ceb29e	121	return;
eedcd078	122	}
68ceb29e	123
eedcd078 WD	124	if (!memcmp (nc_ether, NetEtherNullAddr, 6)) {
	125	if (eth->state == ETH_STATE_ACTIVE)
	126	return; /* inside net loop */
	127	output_packet = buf;
	128	output_packet_len = len;
	129	NetLoop (NETCONS); /* wait for arp reply and send packet */
	130	output_packet_len = 0;
68ceb29e WD	131	return;
	132	}
	133
	134	if (eth->state != ETH_STATE_ACTIVE) {
	135	if (eth_init (gd->bd) < 0)
	136	return;
	137	inited = 1;
	138	}
	139	pkt = (uchar *) NetTxPacket + NetEthHdrSize () + IP_HDR_SIZE;
	140	memcpy (pkt, buf, len);
eedcd078 WD	141	ether = nc_ether;
	142	ip = nc_ip;
	143	NetSendUDPPacket (ether, ip, nc_port, nc_port, len);
68ceb29e WD	144
	145	if (inited)
	146	eth_halt ();
	147	}
	148
	149	int nc_start (void)
	150	{
eedcd078 WD	151	int netmask, our_ip;
	152
	153	nc_port = 6666; /* default port */
	154
	155	if (getenv ("ncip")) {
	156	nc_ip = getenv_IPaddr ("ncip");
	157	if (!nc_ip)
	158	return -1; /* ncip is 0.0.0.0 */
	159	char *p = strchr (getenv ("ncip"), ':');
	160	if (p)
	161	nc_port = simple_strtoul (p + 1, NULL, 10);
	162	} else
	163	nc_ip = ~0; /* ncip is not set */
	164
	165	our_ip = getenv_IPaddr ("ipaddr");
	166	netmask = getenv_IPaddr ("netmask");
	167
	168	if (nc_ip == ~0 \|\| /* 255.255.255.255 */
	169	((netmask & our_ip) == (netmask & nc_ip) && /* on the same net */
	170	(netmask \| nc_ip) == ~0)) /* broadcast to our net */
	171	memset (nc_ether, 0xff, sizeof nc_ether);
	172	else
	173	memset (nc_ether, 0, sizeof nc_ether); /* force arp request */
	174
	175	return 0;
68ceb29e WD	176	}
	177
	178	void nc_putc (char c)
	179	{
	180	if (output_recursion)
	181	return;
	182	output_recursion = 1;
	183
	184	nc_send_packet (&c, 1);
	185
	186	output_recursion = 0;
	187	}
	188
	189	void nc_puts (const char *s)
	190	{
	191	if (output_recursion)
	192	return;
	193	output_recursion = 1;
	194
	195	int len = strlen (s);
	196
	197	if (len > 512)
	198	len = 512;
	199
	200	nc_send_packet (s, len);
	201
	202	output_recursion = 0;
	203	}
	204
	205	int nc_getc (void)
	206	{
	207	input_recursion = 1;
	208
	209	net_timeout = 0; /* no timeout */
eedcd078	210	while (!input_size)
68ceb29e WD	211	NetLoop (NETCONS);
	212
	213	input_recursion = 0;
	214
eedcd078 WD	215	uchar c = input_buffer[input_offset];
	216	input_offset++;
	217	if (input_offset >= sizeof input_buffer)
	218	input_offset -= sizeof input_buffer;
	219	input_size--;
68ceb29e	220
eedcd078	221	return c;
68ceb29e WD	222	}
	223
	224	int nc_tstc (void)
	225	{
	226	struct eth_device *eth;
	227
	228	if (input_recursion)
	229	return 0;
	230
eedcd078	231	if (input_size)
68ceb29e WD	232	return 1;
	233
	234	eth = eth_get_dev ();
	235	if (eth && eth->state == ETH_STATE_ACTIVE)
	236	return 0; /* inside net loop */
	237
	238	input_recursion = 1;
	239
	240	net_timeout = 1;
eedcd078	241	NetLoop (NETCONS); /* kind of poll */
68ceb29e WD	242
	243	input_recursion = 0;
	244
eedcd078	245	return input_size != 0;
68ceb29e WD	246	}
	247
	248	int drv_nc_init (void)
	249	{
	250	device_t dev;
	251	int rc;
	252
	253	memset (&dev, 0, sizeof (dev));
	254
	255	strcpy (dev.name, "nc");
	256	dev.flags = DEV_FLAGS_OUTPUT \| DEV_FLAGS_INPUT \| DEV_FLAGS_SYSTEM;
	257	dev.start = nc_start;
	258	dev.putc = nc_putc;
	259	dev.puts = nc_puts;
	260	dev.getc = nc_getc;
	261	dev.tstc = nc_tstc;
	262
	263	rc = device_register (&dev);
	264
	265	return (rc == 0) ? 1 : rc;
	266	}
	267
	268	#endif /* CONFIG_NETCONSOLE */