xref: /openbmc/u-boot/include/net.h (revision c1393bb3)
1 /*
2  *	LiMon Monitor (LiMon) - Network.
3  *
4  *	Copyright 1994 - 2000 Neil Russell.
5  *	(See License)
6  *
7  *
8  * History
9  *	9/16/00	  bor  adapted to TQM823L/STK8xxL board, RARP/TFTP boot added
10  */
11 
12 #ifndef __NET_H__
13 #define __NET_H__
14 
15 #if defined(CONFIG_8xx)
16 #include <commproc.h>
17 #endif	/* CONFIG_8xx */
18 
19 #include <asm/cache.h>
20 #include <asm/byteorder.h>	/* for nton* / ntoh* stuff */
21 
22 #define DEBUG_LL_STATE 0	/* Link local state machine changes */
23 #define DEBUG_DEV_PKT 0		/* Packets or info directed to the device */
24 #define DEBUG_NET_PKT 0		/* Packets on info on the network at large */
25 #define DEBUG_INT_STATE 0	/* Internal network state changes */
26 
27 /*
28  *	The number of receive packet buffers, and the required packet buffer
29  *	alignment in memory.
30  *
31  */
32 
33 #ifdef CONFIG_SYS_RX_ETH_BUFFER
34 # define PKTBUFSRX	CONFIG_SYS_RX_ETH_BUFFER
35 #else
36 # define PKTBUFSRX	4
37 #endif
38 
39 #define PKTALIGN	ARCH_DMA_MINALIGN
40 
41 /* IPv4 addresses are always 32 bits in size */
42 typedef u32		IPaddr_t;
43 
44 
45 /**
46  * An incoming packet handler.
47  * @param pkt    pointer to the application packet
48  * @param dport  destination UDP port
49  * @param sip    source IP address
50  * @param sport  source UDP port
51  * @param len    packet length
52  */
53 typedef void rxhand_f(uchar *pkt, unsigned dport,
54 		      IPaddr_t sip, unsigned sport,
55 		      unsigned len);
56 
57 /**
58  * An incoming ICMP packet handler.
59  * @param type	ICMP type
60  * @param code	ICMP code
61  * @param dport	destination UDP port
62  * @param sip	source IP address
63  * @param sport	source UDP port
64  * @param pkt	pointer to the ICMP packet data
65  * @param len	packet length
66  */
67 typedef void rxhand_icmp_f(unsigned type, unsigned code, unsigned dport,
68 		IPaddr_t sip, unsigned sport, uchar *pkt, unsigned len);
69 
70 /*
71  *	A timeout handler.  Called after time interval has expired.
72  */
73 typedef void	thand_f(void);
74 
75 enum eth_state_t {
76 	ETH_STATE_INIT,
77 	ETH_STATE_PASSIVE,
78 	ETH_STATE_ACTIVE
79 };
80 
81 struct eth_device {
82 	char name[16];
83 	unsigned char enetaddr[6];
84 	int iobase;
85 	int state;
86 
87 	int  (*init) (struct eth_device *, bd_t *);
88 	int  (*send) (struct eth_device *, void *packet, int length);
89 	int  (*recv) (struct eth_device *);
90 	void (*halt) (struct eth_device *);
91 #ifdef CONFIG_MCAST_TFTP
92 	int (*mcast) (struct eth_device *, u32 ip, u8 set);
93 #endif
94 	int  (*write_hwaddr) (struct eth_device *);
95 	struct eth_device *next;
96 	int index;
97 	void *priv;
98 };
99 
100 extern int eth_initialize(bd_t *bis);	/* Initialize network subsystem */
101 extern int eth_register(struct eth_device* dev);/* Register network device */
102 extern int eth_unregister(struct eth_device *dev);/* Remove network device */
103 extern void eth_try_another(int first_restart);	/* Change the device */
104 extern void eth_set_current(void);		/* set nterface to ethcur var */
105 extern struct eth_device *eth_get_dev(void);	/* get the current device MAC */
106 extern struct eth_device *eth_get_dev_by_name(const char *devname);
107 extern struct eth_device *eth_get_dev_by_index(int index); /* get dev @ index */
108 extern int eth_get_dev_index(void);		/* get the device index */
109 extern void eth_parse_enetaddr(const char *addr, uchar *enetaddr);
110 extern int eth_getenv_enetaddr(char *name, uchar *enetaddr);
111 extern int eth_setenv_enetaddr(char *name, const uchar *enetaddr);
112 
113 /*
114  * Get the hardware address for an ethernet interface .
115  * Args:
116  *	base_name - base name for device (normally "eth")
117  *	index - device index number (0 for first)
118  *	enetaddr - returns 6 byte hardware address
119  * Returns:
120  *	Return true if the address is valid.
121  */
122 extern int eth_getenv_enetaddr_by_index(const char *base_name, int index,
123 					uchar *enetaddr);
124 
125 #ifdef CONFIG_RANDOM_MACADDR
126 /*
127  * The u-boot policy does not allow hardcoded ethernet addresses. Under the
128  * following circumstances a random generated address is allowed:
129  *  - in emergency cases, where you need a working network connection to set
130  *    the ethernet address.
131  *    Eg. you want a rescue boot and don't have a serial port to access the
132  *    CLI to set environment variables.
133  *
134  * In these cases, we generate a random locally administered ethernet address.
135  *
136  * Args:
137  *  enetaddr - returns 6 byte hardware address
138  */
139 extern void eth_random_enetaddr(uchar *enetaddr);
140 #endif
141 
142 extern int usb_eth_initialize(bd_t *bi);
143 extern int eth_init(bd_t *bis);			/* Initialize the device */
144 extern int eth_send(void *packet, int length);	   /* Send a packet */
145 
146 #ifdef CONFIG_API
147 extern int eth_receive(void *packet, int length); /* Receive a packet*/
148 extern void (*push_packet)(void *packet, int length);
149 #endif
150 extern int eth_rx(void);			/* Check for received packets */
151 extern void eth_halt(void);			/* stop SCC */
152 extern char *eth_get_name(void);		/* get name of current device */
153 
154 /*
155  * Set the hardware address for an ethernet interface based on 'eth%daddr'
156  * environment variable (or just 'ethaddr' if eth_number is 0).
157  * Args:
158  *	base_name - base name for device (normally "eth")
159  *	eth_number - value of %d (0 for first device of this type)
160  * Returns:
161  *	0 is success, non-zero is error status from driver.
162  */
163 int eth_write_hwaddr(struct eth_device *dev, const char *base_name,
164 		     int eth_number);
165 
166 #ifdef CONFIG_MCAST_TFTP
167 int eth_mcast_join(IPaddr_t mcast_addr, u8 join);
168 u32 ether_crc(size_t len, unsigned char const *p);
169 #endif
170 
171 
172 /**********************************************************************/
173 /*
174  *	Protocol headers.
175  */
176 
177 /*
178  *	Ethernet header
179  */
180 
181 struct ethernet_hdr {
182 	uchar		et_dest[6];	/* Destination node		*/
183 	uchar		et_src[6];	/* Source node			*/
184 	ushort		et_protlen;	/* Protocol or length		*/
185 };
186 
187 /* Ethernet header size */
188 #define ETHER_HDR_SIZE	(sizeof(struct ethernet_hdr))
189 
190 struct e802_hdr {
191 	uchar		et_dest[6];	/* Destination node		*/
192 	uchar		et_src[6];	/* Source node			*/
193 	ushort		et_protlen;	/* Protocol or length		*/
194 	uchar		et_dsap;	/* 802 DSAP			*/
195 	uchar		et_ssap;	/* 802 SSAP			*/
196 	uchar		et_ctl;		/* 802 control			*/
197 	uchar		et_snap1;	/* SNAP				*/
198 	uchar		et_snap2;
199 	uchar		et_snap3;
200 	ushort		et_prot;	/* 802 protocol			*/
201 };
202 
203 /* 802 + SNAP + ethernet header size */
204 #define E802_HDR_SIZE	(sizeof(struct e802_hdr))
205 
206 /*
207  *	Virtual LAN Ethernet header
208  */
209 struct vlan_ethernet_hdr {
210 	uchar		vet_dest[6];	/* Destination node		*/
211 	uchar		vet_src[6];	/* Source node			*/
212 	ushort		vet_vlan_type;	/* PROT_VLAN			*/
213 	ushort		vet_tag;	/* TAG of VLAN			*/
214 	ushort		vet_type;	/* protocol type		*/
215 };
216 
217 /* VLAN Ethernet header size */
218 #define VLAN_ETHER_HDR_SIZE	(sizeof(struct vlan_ethernet_hdr))
219 
220 #define PROT_IP		0x0800		/* IP protocol			*/
221 #define PROT_ARP	0x0806		/* IP ARP protocol		*/
222 #define PROT_RARP	0x8035		/* IP ARP protocol		*/
223 #define PROT_VLAN	0x8100		/* IEEE 802.1q protocol		*/
224 
225 #define IPPROTO_ICMP	 1	/* Internet Control Message Protocol	*/
226 #define IPPROTO_UDP	17	/* User Datagram Protocol		*/
227 
228 /*
229  *	Internet Protocol (IP) header.
230  */
231 struct ip_hdr {
232 	uchar		ip_hl_v;	/* header length and version	*/
233 	uchar		ip_tos;		/* type of service		*/
234 	ushort		ip_len;		/* total length			*/
235 	ushort		ip_id;		/* identification		*/
236 	ushort		ip_off;		/* fragment offset field	*/
237 	uchar		ip_ttl;		/* time to live			*/
238 	uchar		ip_p;		/* protocol			*/
239 	ushort		ip_sum;		/* checksum			*/
240 	IPaddr_t	ip_src;		/* Source IP address		*/
241 	IPaddr_t	ip_dst;		/* Destination IP address	*/
242 };
243 
244 #define IP_OFFS		0x1fff /* ip offset *= 8 */
245 #define IP_FLAGS	0xe000 /* first 3 bits */
246 #define IP_FLAGS_RES	0x8000 /* reserved */
247 #define IP_FLAGS_DFRAG	0x4000 /* don't fragments */
248 #define IP_FLAGS_MFRAG	0x2000 /* more fragments */
249 
250 #define IP_HDR_SIZE		(sizeof(struct ip_hdr))
251 
252 /*
253  *	Internet Protocol (IP) + UDP header.
254  */
255 struct ip_udp_hdr {
256 	uchar		ip_hl_v;	/* header length and version	*/
257 	uchar		ip_tos;		/* type of service		*/
258 	ushort		ip_len;		/* total length			*/
259 	ushort		ip_id;		/* identification		*/
260 	ushort		ip_off;		/* fragment offset field	*/
261 	uchar		ip_ttl;		/* time to live			*/
262 	uchar		ip_p;		/* protocol			*/
263 	ushort		ip_sum;		/* checksum			*/
264 	IPaddr_t	ip_src;		/* Source IP address		*/
265 	IPaddr_t	ip_dst;		/* Destination IP address	*/
266 	ushort		udp_src;	/* UDP source port		*/
267 	ushort		udp_dst;	/* UDP destination port		*/
268 	ushort		udp_len;	/* Length of UDP packet		*/
269 	ushort		udp_xsum;	/* Checksum			*/
270 };
271 
272 #define IP_UDP_HDR_SIZE		(sizeof(struct ip_udp_hdr))
273 #define UDP_HDR_SIZE		(IP_UDP_HDR_SIZE - IP_HDR_SIZE)
274 
275 /*
276  *	Address Resolution Protocol (ARP) header.
277  */
278 struct arp_hdr {
279 	ushort		ar_hrd;		/* Format of hardware address	*/
280 #   define ARP_ETHER	    1		/* Ethernet  hardware address	*/
281 	ushort		ar_pro;		/* Format of protocol address	*/
282 	uchar		ar_hln;		/* Length of hardware address	*/
283 #   define ARP_HLEN	6
284 	uchar		ar_pln;		/* Length of protocol address	*/
285 #   define ARP_PLEN	4
286 	ushort		ar_op;		/* Operation			*/
287 #   define ARPOP_REQUEST    1		/* Request  to resolve  address	*/
288 #   define ARPOP_REPLY	    2		/* Response to previous request	*/
289 
290 #   define RARPOP_REQUEST   3		/* Request  to resolve  address	*/
291 #   define RARPOP_REPLY	    4		/* Response to previous request */
292 
293 	/*
294 	 * The remaining fields are variable in size, according to
295 	 * the sizes above, and are defined as appropriate for
296 	 * specific hardware/protocol combinations.
297 	 */
298 	uchar		ar_data[0];
299 #define ar_sha		ar_data[0]
300 #define ar_spa		ar_data[ARP_HLEN]
301 #define ar_tha		ar_data[ARP_HLEN + ARP_PLEN]
302 #define ar_tpa		ar_data[ARP_HLEN + ARP_PLEN + ARP_HLEN]
303 #if 0
304 	uchar		ar_sha[];	/* Sender hardware address	*/
305 	uchar		ar_spa[];	/* Sender protocol address	*/
306 	uchar		ar_tha[];	/* Target hardware address	*/
307 	uchar		ar_tpa[];	/* Target protocol address	*/
308 #endif /* 0 */
309 };
310 
311 #define ARP_HDR_SIZE	(8+20)		/* Size assuming ethernet	*/
312 
313 /*
314  * ICMP stuff (just enough to handle (host) redirect messages)
315  */
316 #define ICMP_ECHO_REPLY		0	/* Echo reply			*/
317 #define ICMP_NOT_REACH		3	/* Detination unreachable	*/
318 #define ICMP_REDIRECT		5	/* Redirect (change route)	*/
319 #define ICMP_ECHO_REQUEST	8	/* Echo request			*/
320 
321 /* Codes for REDIRECT. */
322 #define ICMP_REDIR_NET		0	/* Redirect Net			*/
323 #define ICMP_REDIR_HOST		1	/* Redirect Host		*/
324 
325 /* Codes for NOT_REACH */
326 #define ICMP_NOT_REACH_PORT	3	/* Port unreachable		*/
327 
328 struct icmp_hdr {
329 	uchar		type;
330 	uchar		code;
331 	ushort		checksum;
332 	union {
333 		struct {
334 			ushort	id;
335 			ushort	sequence;
336 		} echo;
337 		ulong	gateway;
338 		struct {
339 			ushort	__unused;
340 			ushort	mtu;
341 		} frag;
342 		uchar data[0];
343 	} un;
344 };
345 
346 #define ICMP_HDR_SIZE		(sizeof(struct icmp_hdr))
347 #define IP_ICMP_HDR_SIZE	(IP_HDR_SIZE + ICMP_HDR_SIZE)
348 
349 /*
350  * Maximum packet size; used to allocate packet storage.
351  * TFTP packets can be 524 bytes + IP header + ethernet header.
352  * Lets be conservative, and go for 38 * 16.  (Must also be
353  * a multiple of 32 bytes).
354  */
355 /*
356  * AS.HARNOIS : Better to set PKTSIZE to maximum size because
357  * traffic type is not always controlled
358  * maximum packet size =  1518
359  * maximum packet size and multiple of 32 bytes =  1536
360  */
361 #define PKTSIZE			1518
362 #define PKTSIZE_ALIGN		1536
363 /*#define PKTSIZE		608*/
364 
365 /*
366  * Maximum receive ring size; that is, the number of packets
367  * we can buffer before overflow happens. Basically, this just
368  * needs to be enough to prevent a packet being discarded while
369  * we are processing the previous one.
370  */
371 #define RINGSZ		4
372 #define RINGSZ_LOG2	2
373 
374 /**********************************************************************/
375 /*
376  *	Globals.
377  *
378  * Note:
379  *
380  * All variables of type IPaddr_t are stored in NETWORK byte order
381  * (big endian).
382  */
383 
384 /* net.c */
385 /** BOOTP EXTENTIONS **/
386 extern IPaddr_t NetOurGatewayIP;	/* Our gateway IP address */
387 extern IPaddr_t NetOurSubnetMask;	/* Our subnet mask (0 = unknown) */
388 extern IPaddr_t NetOurDNSIP;	/* Our Domain Name Server (0 = unknown) */
389 #if defined(CONFIG_BOOTP_DNS2)
390 extern IPaddr_t NetOurDNS2IP;	/* Our 2nd Domain Name Server (0 = unknown) */
391 #endif
392 extern char	NetOurNISDomain[32];	/* Our NIS domain */
393 extern char	NetOurHostName[32];	/* Our hostname */
394 extern char	NetOurRootPath[64];	/* Our root path */
395 extern ushort	NetBootFileSize;	/* Our boot file size in blocks */
396 /** END OF BOOTP EXTENTIONS **/
397 extern ulong		NetBootFileXferSize;	/* size of bootfile in bytes */
398 extern uchar		NetOurEther[6];		/* Our ethernet address */
399 extern uchar		NetServerEther[6];	/* Boot server enet address */
400 extern IPaddr_t		NetOurIP;	/* Our    IP addr (0 = unknown) */
401 extern IPaddr_t		NetServerIP;	/* Server IP addr (0 = unknown) */
402 extern uchar		*NetTxPacket;		/* THE transmit packet */
403 extern uchar		*NetRxPackets[PKTBUFSRX]; /* Receive packets */
404 extern uchar		*NetRxPacket;		/* Current receive packet */
405 extern int		NetRxPacketLen;		/* Current rx packet length */
406 extern unsigned		NetIPID;		/* IP ID (counting) */
407 extern uchar		NetBcastAddr[6];	/* Ethernet boardcast address */
408 extern uchar		NetEtherNullAddr[6];
409 
410 #define VLAN_NONE	4095			/* untagged */
411 #define VLAN_IDMASK	0x0fff			/* mask of valid vlan id */
412 extern ushort		NetOurVLAN;		/* Our VLAN */
413 extern ushort		NetOurNativeVLAN;	/* Our Native VLAN */
414 
415 extern int		NetRestartWrap;		/* Tried all network devices */
416 
417 enum proto_t {
418 	BOOTP, RARP, ARP, TFTPGET, DHCP, PING, DNS, NFS, CDP, NETCONS, SNTP,
419 	TFTPSRV, TFTPPUT, LINKLOCAL
420 };
421 
422 /* from net/net.c */
423 extern char	BootFile[128];			/* Boot File name */
424 
425 #if defined(CONFIG_CMD_DNS)
426 extern char *NetDNSResolve;		/* The host to resolve  */
427 extern char *NetDNSenvvar;		/* the env var to put the ip into */
428 #endif
429 
430 #if defined(CONFIG_CMD_PING)
431 extern IPaddr_t	NetPingIP;			/* the ip address to ping */
432 #endif
433 
434 #if defined(CONFIG_CMD_CDP)
435 /* when CDP completes these hold the return values */
436 extern ushort CDPNativeVLAN;		/* CDP returned native VLAN */
437 extern ushort CDPApplianceVLAN;		/* CDP returned appliance VLAN */
438 
439 /*
440  * Check for a CDP packet by examining the received MAC address field
441  */
442 static inline int is_cdp_packet(const uchar *et_addr)
443 {
444 	extern const uchar NetCDPAddr[6];
445 
446 	return memcmp(et_addr, NetCDPAddr, 6) == 0;
447 }
448 #endif
449 
450 #if defined(CONFIG_CMD_SNTP)
451 extern IPaddr_t	NetNtpServerIP;			/* the ip address to NTP */
452 extern int NetTimeOffset;			/* offset time from UTC */
453 #endif
454 
455 #if defined(CONFIG_MCAST_TFTP)
456 extern IPaddr_t Mcast_addr;
457 #endif
458 
459 /* Initialize the network adapter */
460 extern void net_init(void);
461 extern int NetLoop(enum proto_t);
462 
463 /* Shutdown adapters and cleanup */
464 extern void	NetStop(void);
465 
466 /* Load failed.	 Start again. */
467 extern void	NetStartAgain(void);
468 
469 /* Get size of the ethernet header when we send */
470 extern int	NetEthHdrSize(void);
471 
472 /* Set ethernet header; returns the size of the header */
473 extern int NetSetEther(uchar *, uchar *, uint);
474 extern int net_update_ether(struct ethernet_hdr *et, uchar *addr, uint prot);
475 
476 /* Set IP header */
477 extern void net_set_ip_header(uchar *pkt, IPaddr_t dest, IPaddr_t source);
478 extern void net_set_udp_header(uchar *pkt, IPaddr_t dest, int dport,
479 				int sport, int len);
480 
481 /* Checksum */
482 extern int	NetCksumOk(uchar *, int);	/* Return true if cksum OK */
483 extern uint	NetCksum(uchar *, int);		/* Calculate the checksum */
484 
485 /* Callbacks */
486 extern rxhand_f *net_get_udp_handler(void);	/* Get UDP RX packet handler */
487 extern void net_set_udp_handler(rxhand_f *);	/* Set UDP RX packet handler */
488 extern rxhand_f *net_get_arp_handler(void);	/* Get ARP RX packet handler */
489 extern void net_set_arp_handler(rxhand_f *);	/* Set ARP RX packet handler */
490 extern void net_set_icmp_handler(rxhand_icmp_f *f); /* Set ICMP RX handler */
491 extern void	NetSetTimeout(ulong, thand_f *);/* Set timeout handler */
492 
493 /* Network loop state */
494 enum net_loop_state {
495 	NETLOOP_CONTINUE,
496 	NETLOOP_RESTART,
497 	NETLOOP_SUCCESS,
498 	NETLOOP_FAIL
499 };
500 static inline void net_set_state(enum net_loop_state state)
501 {
502 	extern enum net_loop_state net_state;
503 
504 	debug_cond(DEBUG_INT_STATE, "--- NetState set to %d\n", state);
505 	net_state = state;
506 }
507 
508 /* Transmit a packet */
509 static inline void NetSendPacket(uchar *pkt, int len)
510 {
511 	(void) eth_send(pkt, len);
512 }
513 
514 /*
515  * Transmit "NetTxPacket" as UDP packet, performing ARP request if needed
516  *  (ether will be populated)
517  *
518  * @param ether Raw packet buffer
519  * @param dest IP address to send the datagram to
520  * @param dport Destination UDP port
521  * @param sport Source UDP port
522  * @param payload_len Length of data after the UDP header
523  */
524 extern int NetSendUDPPacket(uchar *ether, IPaddr_t dest, int dport,
525 			int sport, int payload_len);
526 
527 /* Processes a received packet */
528 extern void NetReceive(uchar *, int);
529 
530 #ifdef CONFIG_NETCONSOLE
531 void NcStart(void);
532 int nc_input_packet(uchar *pkt, unsigned dest, unsigned src, unsigned len);
533 #endif
534 
535 /*
536  * Check if autoload is enabled. If so, use either NFS or TFTP to download
537  * the boot file.
538  */
539 void net_auto_load(void);
540 
541 /*
542  * The following functions are a bit ugly, but necessary to deal with
543  * alignment restrictions on ARM.
544  *
545  * We're using inline functions, which had the smallest memory
546  * footprint in our tests.
547  */
548 /* return IP *in network byteorder* */
549 static inline IPaddr_t NetReadIP(void *from)
550 {
551 	IPaddr_t ip;
552 
553 	memcpy((void *)&ip, (void *)from, sizeof(ip));
554 	return ip;
555 }
556 
557 /* return ulong *in network byteorder* */
558 static inline ulong NetReadLong(ulong *from)
559 {
560 	ulong l;
561 
562 	memcpy((void *)&l, (void *)from, sizeof(l));
563 	return l;
564 }
565 
566 /* write IP *in network byteorder* */
567 static inline void NetWriteIP(void *to, IPaddr_t ip)
568 {
569 	memcpy(to, (void *)&ip, sizeof(ip));
570 }
571 
572 /* copy IP */
573 static inline void NetCopyIP(void *to, void *from)
574 {
575 	memcpy((void *)to, from, sizeof(IPaddr_t));
576 }
577 
578 /* copy ulong */
579 static inline void NetCopyLong(ulong *to, ulong *from)
580 {
581 	memcpy((void *)to, (void *)from, sizeof(ulong));
582 }
583 
584 /**
585  * is_zero_ether_addr - Determine if give Ethernet address is all zeros.
586  * @addr: Pointer to a six-byte array containing the Ethernet address
587  *
588  * Return true if the address is all zeroes.
589  */
590 static inline int is_zero_ether_addr(const u8 *addr)
591 {
592 	return !(addr[0] | addr[1] | addr[2] | addr[3] | addr[4] | addr[5]);
593 }
594 
595 /**
596  * is_multicast_ether_addr - Determine if the Ethernet address is a multicast.
597  * @addr: Pointer to a six-byte array containing the Ethernet address
598  *
599  * Return true if the address is a multicast address.
600  * By definition the broadcast address is also a multicast address.
601  */
602 static inline int is_multicast_ether_addr(const u8 *addr)
603 {
604 	return 0x01 & addr[0];
605 }
606 
607 /*
608  * is_broadcast_ether_addr - Determine if the Ethernet address is broadcast
609  * @addr: Pointer to a six-byte array containing the Ethernet address
610  *
611  * Return true if the address is the broadcast address.
612  */
613 static inline int is_broadcast_ether_addr(const u8 *addr)
614 {
615 	return (addr[0] & addr[1] & addr[2] & addr[3] & addr[4] & addr[5]) ==
616 		0xff;
617 }
618 
619 /*
620  * is_valid_ether_addr - Determine if the given Ethernet address is valid
621  * @addr: Pointer to a six-byte array containing the Ethernet address
622  *
623  * Check that the Ethernet address (MAC) is not 00:00:00:00:00:00, is not
624  * a multicast address, and is not FF:FF:FF:FF:FF:FF.
625  *
626  * Return true if the address is valid.
627  */
628 static inline int is_valid_ether_addr(const u8 *addr)
629 {
630 	/* FF:FF:FF:FF:FF:FF is a multicast address so we don't need to
631 	 * explicitly check for it here. */
632 	return !is_multicast_ether_addr(addr) && !is_zero_ether_addr(addr);
633 }
634 
635 /* Convert an IP address to a string */
636 extern void ip_to_string(IPaddr_t x, char *s);
637 
638 /* Convert a string to ip address */
639 extern IPaddr_t string_to_ip(const char *s);
640 
641 /* Convert a VLAN id to a string */
642 extern void VLAN_to_string(ushort x, char *s);
643 
644 /* Convert a string to a vlan id */
645 extern ushort string_to_VLAN(const char *s);
646 
647 /* read a VLAN id from an environment variable */
648 extern ushort getenv_VLAN(char *);
649 
650 /* copy a filename (allow for "..." notation, limit length) */
651 extern void copy_filename(char *dst, const char *src, int size);
652 
653 /* get a random source port */
654 extern unsigned int random_port(void);
655 
656 /**********************************************************************/
657 
658 #endif /* __NET_H__ */
659