[people/ms/u-boot.git] / net / cdp.c

/*
 *	Copied from Linux Monitor (LiMon) - Networking.
 *
 *	Copyright 1994 - 2000 Neil Russell.
 *	(See License)
 *	Copyright 2000 Roland Borde
 *	Copyright 2000 Paolo Scaffardi
 *	Copyright 2000-2002 Wolfgang Denk, wd@denx.de
 *	SPDX-License-Identifier:	GPL-2.0
 */

#include <common.h>
#include <net.h>
#if defined(CONFIG_CDP_VERSION)
#include <timestamp.h>
#endif

#include "cdp.h"

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

#define CDP_DEVICE_ID_TLV		0x0001
#define CDP_ADDRESS_TLV			0x0002
#define CDP_PORT_ID_TLV			0x0003
#define CDP_CAPABILITIES_TLV		0x0004
#define CDP_VERSION_TLV			0x0005
#define CDP_PLATFORM_TLV		0x0006
#define CDP_NATIVE_VLAN_TLV		0x000a
#define CDP_APPLIANCE_VLAN_TLV		0x000e
#define CDP_TRIGGER_TLV			0x000f
#define CDP_POWER_CONSUMPTION_TLV	0x0010
#define CDP_SYSNAME_TLV			0x0014
#define CDP_SYSOBJECT_TLV		0x0015
#define CDP_MANAGEMENT_ADDRESS_TLV	0x0016

#define CDP_TIMEOUT			250UL	/* one packet every 250ms */

static int CDPSeq;
static int CDPOK;

ushort CDPNativeVLAN;
ushort CDPApplianceVLAN;

static const uchar CDP_SNAP_hdr[8] = {
	0xAA, 0xAA, 0x03, 0x00, 0x00, 0x0C, 0x20, 0x00 };

static ushort
CDP_compute_csum(const uchar *buff, ushort len)
{
	ushort csum;
	int     odd;
	ulong   result = 0;
	ushort  leftover;
	ushort *p;

	if (len > 0) {
		odd = 1 & (ulong)buff;
		if (odd) {
			result = *buff << 8;
			len--;
			buff++;
		}
		while (len > 1) {
			p = (ushort *)buff;
			result += *p++;
			buff = (uchar *)p;
			if (result & 0x80000000)
				result = (result & 0xFFFF) + (result >> 16);
			len -= 2;
		}
		if (len) {
			leftover = (signed short)(*(const signed char *)buff);
			/*
			 * CISCO SUCKS big time! (and blows too):
			 * CDP uses the IP checksum algorithm with a twist;
			 * for the last byte it *sign* extends and sums.
			 */
			result = (result & 0xffff0000) |
				 ((result + leftover) & 0x0000ffff);
		}
		while (result >> 16)
			result = (result & 0xFFFF) + (result >> 16);

		if (odd)
			result = ((result >> 8) & 0xff) |
				 ((result & 0xff) << 8);
	}

	/* add up 16-bit and 17-bit words for 17+c bits */
	result = (result & 0xffff) + (result >> 16);
	/* add up 16-bit and 2-bit for 16+c bit */
	result = (result & 0xffff) + (result >> 16);
	/* add up carry.. */
	result = (result & 0xffff) + (result >> 16);

	/* negate */
	csum = ~(ushort)result;

	/* run time endian detection */
	if (csum != htons(csum))	/* little endian */
		csum = htons(csum);

	return csum;
}

static int
CDPSendTrigger(void)
{
	uchar *pkt;
	ushort *s;
	ushort *cp;
	struct ethernet_hdr *et;
	int len;
	ushort chksum;
#if	defined(CONFIG_CDP_DEVICE_ID) || defined(CONFIG_CDP_PORT_ID)   || \
	defined(CONFIG_CDP_VERSION)   || defined(CONFIG_CDP_PLATFORM)
	char buf[32];
#endif

	pkt = NetTxPacket;
	et = (struct ethernet_hdr *)pkt;

	/* NOTE: trigger sent not on any VLAN */

	/* form ethernet header */
	memcpy(et->et_dest, NetCDPAddr, 6);
	memcpy(et->et_src, NetOurEther, 6);

	pkt += ETHER_HDR_SIZE;

	/* SNAP header */
	memcpy((uchar *)pkt, CDP_SNAP_hdr, sizeof(CDP_SNAP_hdr));
	pkt += sizeof(CDP_SNAP_hdr);

	/* CDP header */
	*pkt++ = 0x02;				/* CDP version 2 */
	*pkt++ = 180;				/* TTL */
	s = (ushort *)pkt;
	cp = s;
	/* checksum (0 for later calculation) */
	*s++ = htons(0);

	/* CDP fields */
#ifdef CONFIG_CDP_DEVICE_ID
	*s++ = htons(CDP_DEVICE_ID_TLV);
	*s++ = htons(CONFIG_CDP_DEVICE_ID);
	sprintf(buf, CONFIG_CDP_DEVICE_ID_PREFIX "%pm", NetOurEther);
	memcpy((uchar *)s, buf, 16);
	s += 16 / 2;
#endif

#ifdef CONFIG_CDP_PORT_ID
	*s++ = htons(CDP_PORT_ID_TLV);
	memset(buf, 0, sizeof(buf));
	sprintf(buf, CONFIG_CDP_PORT_ID, eth_get_dev_index());
	len = strlen(buf);
	if (len & 1)	/* make it even */
		len++;
	*s++ = htons(len + 4);
	memcpy((uchar *)s, buf, len);
	s += len / 2;
#endif

#ifdef CONFIG_CDP_CAPABILITIES
	*s++ = htons(CDP_CAPABILITIES_TLV);
	*s++ = htons(8);
	*(ulong *)s = htonl(CONFIG_CDP_CAPABILITIES);
	s += 2;
#endif

#ifdef CONFIG_CDP_VERSION
	*s++ = htons(CDP_VERSION_TLV);
	memset(buf, 0, sizeof(buf));
	strcpy(buf, CONFIG_CDP_VERSION);
	len = strlen(buf);
	if (len & 1)	/* make it even */
		len++;
	*s++ = htons(len + 4);
	memcpy((uchar *)s, buf, len);
	s += len / 2;
#endif

#ifdef CONFIG_CDP_PLATFORM
	*s++ = htons(CDP_PLATFORM_TLV);
	memset(buf, 0, sizeof(buf));
	strcpy(buf, CONFIG_CDP_PLATFORM);
	len = strlen(buf);
	if (len & 1)	/* make it even */
		len++;
	*s++ = htons(len + 4);
	memcpy((uchar *)s, buf, len);
	s += len / 2;
#endif

#ifdef CONFIG_CDP_TRIGGER
	*s++ = htons(CDP_TRIGGER_TLV);
	*s++ = htons(8);
	*(ulong *)s = htonl(CONFIG_CDP_TRIGGER);
	s += 2;
#endif

#ifdef CONFIG_CDP_POWER_CONSUMPTION
	*s++ = htons(CDP_POWER_CONSUMPTION_TLV);
	*s++ = htons(6);
	*s++ = htons(CONFIG_CDP_POWER_CONSUMPTION);
#endif

	/* length of ethernet packet */
	len = (uchar *)s - ((uchar *)NetTxPacket + ETHER_HDR_SIZE);
	et->et_protlen = htons(len);

	len = ETHER_HDR_SIZE + sizeof(CDP_SNAP_hdr);
	chksum = CDP_compute_csum((uchar *)NetTxPacket + len,
				  (uchar *)s - (NetTxPacket + len));
	if (chksum == 0)
		chksum = 0xFFFF;
	*cp = htons(chksum);

	NetSendPacket(NetTxPacket, (uchar *)s - NetTxPacket);
	return 0;
}

static void
CDPTimeout(void)
{
	CDPSeq++;

	if (CDPSeq < 3) {
		NetSetTimeout(CDP_TIMEOUT, CDPTimeout);
		CDPSendTrigger();
		return;
	}

	/* if not OK try again */
	if (!CDPOK)
		NetStartAgain();
	else
		net_set_state(NETLOOP_SUCCESS);
}

void cdp_receive(const uchar *pkt, unsigned len)
{
	const uchar *t;
	const ushort *ss;
	ushort type, tlen;
	ushort vlan, nvlan;

	/* minimum size? */
	if (len < sizeof(CDP_SNAP_hdr) + 4)
		goto pkt_short;

	/* check for valid CDP SNAP header */
	if (memcmp(pkt, CDP_SNAP_hdr, sizeof(CDP_SNAP_hdr)) != 0)
		return;

	pkt += sizeof(CDP_SNAP_hdr);
	len -= sizeof(CDP_SNAP_hdr);

	/* Version of CDP protocol must be >= 2 and TTL != 0 */
	if (pkt[0] < 0x02 || pkt[1] == 0)
		return;

	/*
	 * if version is greater than 0x02 maybe we'll have a problem;
	 * output a warning
	 */
	if (pkt[0] != 0x02)
		printf("**WARNING: CDP packet received with a protocol version "
				"%d > 2\n", pkt[0] & 0xff);

	if (CDP_compute_csum(pkt, len) != 0)
		return;

	pkt += 4;
	len -= 4;

	vlan = htons(-1);
	nvlan = htons(-1);
	while (len > 0) {
		if (len < 4)
			goto pkt_short;

		ss = (const ushort *)pkt;
		type = ntohs(ss[0]);
		tlen = ntohs(ss[1]);
		if (tlen > len)
			goto pkt_short;

		pkt += tlen;
		len -= tlen;

		ss += 2;	/* point ss to the data of the TLV */
		tlen -= 4;

		switch (type) {
		case CDP_DEVICE_ID_TLV:
			break;
		case CDP_ADDRESS_TLV:
			break;
		case CDP_PORT_ID_TLV:
			break;
		case CDP_CAPABILITIES_TLV:
			break;
		case CDP_VERSION_TLV:
			break;
		case CDP_PLATFORM_TLV:
			break;
		case CDP_NATIVE_VLAN_TLV:
			nvlan = *ss;
			break;
		case CDP_APPLIANCE_VLAN_TLV:
			t = (const uchar *)ss;
			while (tlen > 0) {
				if (tlen < 3)
					goto pkt_short;

				ss = (const ushort *)(t + 1);

#ifdef CONFIG_CDP_APPLIANCE_VLAN_TYPE
				if (t[0] == CONFIG_CDP_APPLIANCE_VLAN_TYPE)
					vlan = *ss;
#else
				/* XXX will this work; dunno */
				vlan = ntohs(*ss);
#endif
				t += 3; tlen -= 3;
			}
			break;
		case CDP_TRIGGER_TLV:
			break;
		case CDP_POWER_CONSUMPTION_TLV:
			break;
		case CDP_SYSNAME_TLV:
			break;
		case CDP_SYSOBJECT_TLV:
			break;
		case CDP_MANAGEMENT_ADDRESS_TLV:
			break;
		}
	}

	CDPApplianceVLAN = vlan;
	CDPNativeVLAN = nvlan;

	CDPOK = 1;
	return;

 pkt_short:
	printf("** CDP packet is too short\n");
	return;
}

void
CDPStart(void)
{
	printf("Using %s device\n", eth_get_name());
	CDPSeq = 0;
	CDPOK = 0;

	CDPNativeVLAN = htons(-1);
	CDPApplianceVLAN = htons(-1);

	NetSetTimeout(CDP_TIMEOUT, CDPTimeout);

	CDPSendTrigger();
}
Commit	Line	Data
f575ae1f JH	1	/*
	2	* Copied from Linux Monitor (LiMon) - Networking.
	3	*
	4	* Copyright 1994 - 2000 Neil Russell.
	5	* (See License)
	6	* Copyright 2000 Roland Borde
	7	* Copyright 2000 Paolo Scaffardi
	8	* Copyright 2000-2002 Wolfgang Denk, wd@denx.de
2ea91039	9	* SPDX-License-Identifier: GPL-2.0
f575ae1f JH	10	*/
	11
	12	#include <common.h>
	13	#include <net.h>
	14	#if defined(CONFIG_CDP_VERSION)
	15	#include <timestamp.h>
	16	#endif
	17
	18	#include "cdp.h"
	19
	20	/* Ethernet bcast address */
	21	const uchar NetCDPAddr[6] = { 0x01, 0x00, 0x0c, 0xcc, 0xcc, 0xcc };
	22
	23	#define CDP_DEVICE_ID_TLV 0x0001
	24	#define CDP_ADDRESS_TLV 0x0002
	25	#define CDP_PORT_ID_TLV 0x0003
	26	#define CDP_CAPABILITIES_TLV 0x0004
	27	#define CDP_VERSION_TLV 0x0005
	28	#define CDP_PLATFORM_TLV 0x0006
	29	#define CDP_NATIVE_VLAN_TLV 0x000a
	30	#define CDP_APPLIANCE_VLAN_TLV 0x000e
	31	#define CDP_TRIGGER_TLV 0x000f
	32	#define CDP_POWER_CONSUMPTION_TLV 0x0010
	33	#define CDP_SYSNAME_TLV 0x0014
	34	#define CDP_SYSOBJECT_TLV 0x0015
	35	#define CDP_MANAGEMENT_ADDRESS_TLV 0x0016
	36
	37	#define CDP_TIMEOUT 250UL /* one packet every 250ms */
	38
	39	static int CDPSeq;
	40	static int CDPOK;
	41
	42	ushort CDPNativeVLAN;
	43	ushort CDPApplianceVLAN;
	44
	45	static const uchar CDP_SNAP_hdr[8] = {
	46	0xAA, 0xAA, 0x03, 0x00, 0x00, 0x0C, 0x20, 0x00 };
	47
	48	static ushort
	49	CDP_compute_csum(const uchar *buff, ushort len)
	50	{
	51	ushort csum;
	52	int odd;
	53	ulong result = 0;
	54	ushort leftover;
	55	ushort *p;
	56
	57	if (len > 0) {
	58	odd = 1 & (ulong)buff;
	59	if (odd) {
	60	result = *buff << 8;
	61	len--;
	62	buff++;
	63	}
	64	while (len > 1) {
	65	p = (ushort *)buff;
	66	result += *p++;
	67	buff = (uchar *)p;
	68	if (result & 0x80000000)
	69	result = (result & 0xFFFF) + (result >> 16);
	70	len -= 2;
	71	}
	72	if (len) {
	73	leftover = (signed short)((const signed char )buff);
74	/*
75	* CISCO SUCKS big time! (and blows too):
76	* CDP uses the IP checksum algorithm with a twist;
77	* for the last byte it sign extends and sums.
78	*/
79	result = (result & 0xffff0000) \|
80	((result + leftover) & 0x0000ffff);
81	}
82	while (result >> 16)
83	result = (result & 0xFFFF) + (result >> 16);
84
85	if (odd)
86	result = ((result >> 8) & 0xff) \|
87	((result & 0xff) << 8);
88	}
89
90	/* add up 16-bit and 17-bit words for 17+c bits */
91	result = (result & 0xffff) + (result >> 16);
92	/* add up 16-bit and 2-bit for 16+c bit */
93	result = (result & 0xffff) + (result >> 16);
94	/* add up carry.. */
95	result = (result & 0xffff) + (result >> 16);
96
97	/* negate */
98	csum = ~(ushort)result;
99
100	/* run time endian detection */
101	if (csum != htons(csum)) /* little endian */
102	csum = htons(csum);
103
104	return csum;
105	}
106
107	static int
108	CDPSendTrigger(void)
109	{
110	uchar *pkt;
111	ushort *s;
112	ushort *cp;
cb487f56	113	struct ethernet_hdr *et;
f575ae1f JH	114	int len;
	115	ushort chksum;
	116	#if defined(CONFIG_CDP_DEVICE_ID) \|\| defined(CONFIG_CDP_PORT_ID) \|\| \
	117	defined(CONFIG_CDP_VERSION) \|\| defined(CONFIG_CDP_PLATFORM)
	118	char buf[32];
	119	#endif
	120
	121	pkt = NetTxPacket;
cb487f56	122	et = (struct ethernet_hdr *)pkt;
f575ae1f JH	123
	124	/* NOTE: trigger sent not on any VLAN */
	125
	126	/* form ethernet header */
	127	memcpy(et->et_dest, NetCDPAddr, 6);
	128	memcpy(et->et_src, NetOurEther, 6);
	129
	130	pkt += ETHER_HDR_SIZE;
	131
	132	/* SNAP header */
	133	memcpy((uchar *)pkt, CDP_SNAP_hdr, sizeof(CDP_SNAP_hdr));
	134	pkt += sizeof(CDP_SNAP_hdr);
	135
	136	/* CDP header */
	137	pkt++ = 0x02; / CDP version 2 */
	138	pkt++ = 180; / TTL */
	139	s = (ushort *)pkt;
	140	cp = s;
	141	/* checksum (0 for later calculation) */
	142	*s++ = htons(0);
	143
	144	/* CDP fields */
	145	#ifdef CONFIG_CDP_DEVICE_ID
	146	*s++ = htons(CDP_DEVICE_ID_TLV);
	147	*s++ = htons(CONFIG_CDP_DEVICE_ID);
	148	sprintf(buf, CONFIG_CDP_DEVICE_ID_PREFIX "%pm", NetOurEther);
	149	memcpy((uchar *)s, buf, 16);
	150	s += 16 / 2;
	151	#endif
	152
	153	#ifdef CONFIG_CDP_PORT_ID
	154	*s++ = htons(CDP_PORT_ID_TLV);
	155	memset(buf, 0, sizeof(buf));
	156	sprintf(buf, CONFIG_CDP_PORT_ID, eth_get_dev_index());
	157	len = strlen(buf);
	158	if (len & 1) /* make it even */
	159	len++;
	160	*s++ = htons(len + 4);
	161	memcpy((uchar *)s, buf, len);
	162	s += len / 2;
	163	#endif
	164
	165	#ifdef CONFIG_CDP_CAPABILITIES
	166	*s++ = htons(CDP_CAPABILITIES_TLV);
	167	*s++ = htons(8);
	168	(ulong )s = htonl(CONFIG_CDP_CAPABILITIES);
	169	s += 2;
	170	#endif
	171
	172	#ifdef CONFIG_CDP_VERSION
	173	*s++ = htons(CDP_VERSION_TLV);
	174	memset(buf, 0, sizeof(buf));
	175	strcpy(buf, CONFIG_CDP_VERSION);
	176	len = strlen(buf);
	177	if (len & 1) /* make it even */
	178	len++;
	179	*s++ = htons(len + 4);
	180	memcpy((uchar *)s, buf, len);
	181	s += len / 2;
	182	#endif
	183
	184	#ifdef CONFIG_CDP_PLATFORM
	185	*s++ = htons(CDP_PLATFORM_TLV);
	186	memset(buf, 0, sizeof(buf));
187	strcpy(buf, CONFIG_CDP_PLATFORM);
188	len = strlen(buf);
189	if (len & 1) /* make it even */
190	len++;
191	*s++ = htons(len + 4);
192	memcpy((uchar *)s, buf, len);
193	s += len / 2;
194	#endif
195
196	#ifdef CONFIG_CDP_TRIGGER
197	*s++ = htons(CDP_TRIGGER_TLV);
198	*s++ = htons(8);
199	(ulong )s = htonl(CONFIG_CDP_TRIGGER);
200	s += 2;
201	#endif
202
203	#ifdef CONFIG_CDP_POWER_CONSUMPTION
204	*s++ = htons(CDP_POWER_CONSUMPTION_TLV);
205	*s++ = htons(6);
206	*s++ = htons(CONFIG_CDP_POWER_CONSUMPTION);
207	#endif
208
209	/* length of ethernet packet */
210	len = (uchar )s - ((uchar )NetTxPacket + ETHER_HDR_SIZE);
211	et->et_protlen = htons(len);
212
213	len = ETHER_HDR_SIZE + sizeof(CDP_SNAP_hdr);
214	chksum = CDP_compute_csum((uchar *)NetTxPacket + len,
215	(uchar *)s - (NetTxPacket + len));
216	if (chksum == 0)
217	chksum = 0xFFFF;
218	*cp = htons(chksum);
219
adf5d93e	220	NetSendPacket(NetTxPacket, (uchar *)s - NetTxPacket);
f575ae1f JH	221	return 0;
	222	}
	223
	224	static void
	225	CDPTimeout(void)
	226	{
	227	CDPSeq++;
	228
	229	if (CDPSeq < 3) {
	230	NetSetTimeout(CDP_TIMEOUT, CDPTimeout);
	231	CDPSendTrigger();
	232	return;
	233	}
	234
	235	/* if not OK try again */
	236	if (!CDPOK)
	237	NetStartAgain();
	238	else
22f6e99d	239	net_set_state(NETLOOP_SUCCESS);
f575ae1f JH	240	}
f575ae1f JH	241
0b4c5ff4	242	void cdp_receive(const uchar *pkt, unsigned len)
f575ae1f JH	243	{
	244	const uchar *t;
	245	const ushort *ss;
	246	ushort type, tlen;
	247	ushort vlan, nvlan;
	248
	249	/* minimum size? */
	250	if (len < sizeof(CDP_SNAP_hdr) + 4)
	251	goto pkt_short;
	252
	253	/* check for valid CDP SNAP header */
	254	if (memcmp(pkt, CDP_SNAP_hdr, sizeof(CDP_SNAP_hdr)) != 0)
	255	return;
	256
	257	pkt += sizeof(CDP_SNAP_hdr);
	258	len -= sizeof(CDP_SNAP_hdr);
	259
	260	/* Version of CDP protocol must be >= 2 and TTL != 0 */
	261	if (pkt[0] < 0x02 \|\| pkt[1] == 0)
	262	return;
	263
	264	/*
	265	* if version is greater than 0x02 maybe we'll have a problem;
	266	* output a warning
	267	*/
	268	if (pkt[0] != 0x02)
	269	printf("**WARNING: CDP packet received with a protocol version "
	270	"%d > 2\n", pkt[0] & 0xff);
	271
	272	if (CDP_compute_csum(pkt, len) != 0)
	273	return;
	274
	275	pkt += 4;
	276	len -= 4;
	277
	278	vlan = htons(-1);
	279	nvlan = htons(-1);
	280	while (len > 0) {
	281	if (len < 4)
	282	goto pkt_short;
	283
	284	ss = (const ushort *)pkt;
	285	type = ntohs(ss[0]);
	286	tlen = ntohs(ss[1]);
	287	if (tlen > len)
	288	goto pkt_short;
	289
	290	pkt += tlen;
	291	len -= tlen;
	292
	293	ss += 2; /* point ss to the data of the TLV */
	294	tlen -= 4;
	295
	296	switch (type) {
	297	case CDP_DEVICE_ID_TLV:
	298	break;
	299	case CDP_ADDRESS_TLV:
	300	break;
	301	case CDP_PORT_ID_TLV:
	302	break;
	303	case CDP_CAPABILITIES_TLV:
	304	break;
	305	case CDP_VERSION_TLV:
	306	break;
307	case CDP_PLATFORM_TLV:
308	break;
309	case CDP_NATIVE_VLAN_TLV:
310	nvlan = *ss;
311	break;
312	case CDP_APPLIANCE_VLAN_TLV:
313	t = (const uchar *)ss;
314	while (tlen > 0) {
315	if (tlen < 3)
316	goto pkt_short;
317
318	ss = (const ushort *)(t + 1);
319
320	#ifdef CONFIG_CDP_APPLIANCE_VLAN_TYPE
321	if (t[0] == CONFIG_CDP_APPLIANCE_VLAN_TYPE)
322	vlan = *ss;
323	#else
324	/* XXX will this work; dunno */
325	vlan = ntohs(*ss);
326	#endif
327	t += 3; tlen -= 3;
328	}
329	break;
330	case CDP_TRIGGER_TLV:
331	break;
332	case CDP_POWER_CONSUMPTION_TLV:
333	break;
334	case CDP_SYSNAME_TLV:
335	break;
336	case CDP_SYSOBJECT_TLV:
337	break;
338	case CDP_MANAGEMENT_ADDRESS_TLV:
339	break;
340	}
341	}
342
343	CDPApplianceVLAN = vlan;
344	CDPNativeVLAN = nvlan;
345
346	CDPOK = 1;
347	return;
348
349	pkt_short:
350	printf("** CDP packet is too short\n");
351	return;
352	}
353
354	void
355	CDPStart(void)
356	{
357	printf("Using %s device\n", eth_get_name());
358	CDPSeq = 0;
359	CDPOK = 0;
360
361	CDPNativeVLAN = htons(-1);
362	CDPApplianceVLAN = htons(-1);
363
364	NetSetTimeout(CDP_TIMEOUT, CDPTimeout);
f575ae1f JH	365
	366	CDPSendTrigger();
	367	}