net.h 24.9 KB
Newer Older
wdenk's avatar
wdenk committed
1 2 3 4 5
/*
 *	LiMon Monitor (LiMon) - Network.
 *
 *	Copyright 1994 - 2000 Neil Russell.
 *	(See License)
6
 *	SPDX-License-Identifier:	GPL-2.0
wdenk's avatar
wdenk committed
7 8 9 10 11 12 13 14
 *
 * History
 *	9/16/00	  bor  adapted to TQM823L/STK8xxL board, RARP/TFTP boot added
 */

#ifndef __NET_H__
#define __NET_H__

15
#if defined(CONFIG_8xx)
wdenk's avatar
wdenk committed
16
#include <commproc.h>
17
#endif	/* CONFIG_8xx */
wdenk's avatar
wdenk committed
18

19
#include <asm/cache.h>
wdenk's avatar
wdenk committed
20 21
#include <asm/byteorder.h>	/* for nton* / ntoh* stuff */

22 23 24 25
#define DEBUG_LL_STATE 0	/* Link local state machine changes */
#define DEBUG_DEV_PKT 0		/* Packets or info directed to the device */
#define DEBUG_NET_PKT 0		/* Packets on info on the network at large */
#define DEBUG_INT_STATE 0	/* Internal network state changes */
wdenk's avatar
wdenk committed
26 27 28 29 30 31 32

/*
 *	The number of receive packet buffers, and the required packet buffer
 *	alignment in memory.
 *
 */

33 34
#ifdef CONFIG_SYS_RX_ETH_BUFFER
# define PKTBUFSRX	CONFIG_SYS_RX_ETH_BUFFER
wdenk's avatar
wdenk committed
35
#else
stroese's avatar
stroese committed
36
# define PKTBUFSRX	4
wdenk's avatar
wdenk committed
37 38
#endif

39
#define PKTALIGN	ARCH_DMA_MINALIGN
wdenk's avatar
wdenk committed
40

41
/* IPv4 addresses are always 32 bits in size */
42 43 44
struct in_addr {
	__be32 s_addr;
};
wdenk's avatar
wdenk committed
45

46 47 48 49 50 51 52
/**
 * An incoming packet handler.
 * @param pkt    pointer to the application packet
 * @param dport  destination UDP port
 * @param sip    source IP address
 * @param sport  source UDP port
 * @param len    packet length
wdenk's avatar
wdenk committed
53
 */
54
typedef void rxhand_f(uchar *pkt, unsigned dport,
55
		      struct in_addr sip, unsigned sport,
56
		      unsigned len);
wdenk's avatar
wdenk committed
57

58 59 60 61 62 63 64 65 66 67 68
/**
 * An incoming ICMP packet handler.
 * @param type	ICMP type
 * @param code	ICMP code
 * @param dport	destination UDP port
 * @param sip	source IP address
 * @param sport	source UDP port
 * @param pkt	pointer to the ICMP packet data
 * @param len	packet length
 */
typedef void rxhand_icmp_f(unsigned type, unsigned code, unsigned dport,
69
		struct in_addr sip, unsigned sport, uchar *pkt, unsigned len);
70

wdenk's avatar
wdenk committed
71 72 73 74 75 76 77 78 79 80 81
/*
 *	A timeout handler.  Called after time interval has expired.
 */
typedef void	thand_f(void);

enum eth_state_t {
	ETH_STATE_INIT,
	ETH_STATE_PASSIVE,
	ETH_STATE_ACTIVE
};

82 83 84 85 86 87
#ifdef CONFIG_DM_ETH
/**
 * struct eth_pdata - Platform data for Ethernet MAC controllers
 *
 * @iobase: The base address of the hardware registers
 * @enetaddr: The Ethernet MAC address that is loaded from EEPROM or env
88
 * @phy_interface: PHY interface to use - see PHY_INTERFACE_MODE_...
89
 * @max_speed: Maximum speed of Ethernet connection supported by MAC
90 91 92 93
 */
struct eth_pdata {
	phys_addr_t iobase;
	unsigned char enetaddr[6];
94
	int phy_interface;
95
	int max_speed;
96 97
};

98 99 100 101 102 103 104 105
enum eth_recv_flags {
	/*
	 * Check hardware device for new packets (otherwise only return those
	 * which are already in the memory buffer ready to process)
	 */
	ETH_RECV_CHECK_DEVICE		= 1 << 0,
};

106 107 108 109 110
/**
 * struct eth_ops - functions of Ethernet MAC controllers
 *
 * start: Prepare the hardware to send and receive packets
 * send: Send the bytes passed in "packet" as a packet on the wire
111 112
 * recv: Check if the hardware received a packet. If so, set the pointer to the
 *	 packet buffer in the packetp parameter. If not, return an error or 0 to
113 114 115 116 117 118
 *	 indicate that the hardware receive FIFO is empty. If 0 is returned, the
 *	 network stack will not process the empty packet, but free_pkt() will be
 *	 called if supplied
 * free_pkt: Give the driver an opportunity to manage its packet buffer memory
 *	     when the network stack is finished processing it. This will only be
 *	     called when no error was returned from recv - optional
119 120 121 122 123
 * stop: Stop the hardware from looking for packets - may be called even if
 *	 state == PASSIVE
 * mcast: Join or leave a multicast group (for TFTP) - optional
 * write_hwaddr: Write a MAC address to the hardware (used to pass it to Linux
 *		 on some platforms like ARM). This function expects the
124 125 126
 *		 eth_pdata::enetaddr field to be populated. The method can
 *		 return -ENOSYS to indicate that this is not implemented for
		 this hardware - optional.
127 128 129 130 131 132 133 134
 * read_rom_hwaddr: Some devices have a backup of the MAC address stored in a
 *		    ROM on the board. This is how the driver should expose it
 *		    to the network stack. This function should fill in the
 *		    eth_pdata::enetaddr field - optional
 */
struct eth_ops {
	int (*start)(struct udevice *dev);
	int (*send)(struct udevice *dev, void *packet, int length);
135
	int (*recv)(struct udevice *dev, int flags, uchar **packetp);
136
	int (*free_pkt)(struct udevice *dev, uchar *packet, int length);
137 138 139 140 141 142 143 144 145 146 147
	void (*stop)(struct udevice *dev);
#ifdef CONFIG_MCAST_TFTP
	int (*mcast)(struct udevice *dev, const u8 *enetaddr, int join);
#endif
	int (*write_hwaddr)(struct udevice *dev);
	int (*read_rom_hwaddr)(struct udevice *dev);
};

#define eth_get_ops(dev) ((struct eth_ops *)(dev)->driver->ops)

struct udevice *eth_get_dev(void); /* get the current device */
148 149 150 151 152
/*
 * The devname can be either an exact name given by the driver or device tree
 * or it can be an alias of the form "eth%d"
 */
struct udevice *eth_get_dev_by_name(const char *devname);
153
unsigned char *eth_get_ethaddr(void); /* get the current device MAC */
154

155
/* Used only when NetConsole is enabled */
156
int eth_is_active(struct udevice *dev); /* Test device for active state */
157 158 159 160 161
int eth_init_state_only(void); /* Set active state */
void eth_halt_state_only(void); /* Set passive state */
#endif

#ifndef CONFIG_DM_ETH
wdenk's avatar
wdenk committed
162
struct eth_device {
163
	char name[16];
wdenk's avatar
wdenk committed
164
	unsigned char enetaddr[6];
165
	phys_addr_t iobase;
wdenk's avatar
wdenk committed
166 167
	int state;

168 169 170 171
	int (*init)(struct eth_device *, bd_t *);
	int (*send)(struct eth_device *, void *packet, int length);
	int (*recv)(struct eth_device *);
	void (*halt)(struct eth_device *);
David Updegraff's avatar
David Updegraff committed
172
#ifdef CONFIG_MCAST_TFTP
173
	int (*mcast)(struct eth_device *, const u8 *enetaddr, u8 set);
David Updegraff's avatar
David Updegraff committed
174
#endif
175
	int (*write_hwaddr)(struct eth_device *);
wdenk's avatar
wdenk committed
176
	struct eth_device *next;
177
	int index;
wdenk's avatar
wdenk committed
178 179 180
	void *priv;
};

181 182
int eth_register(struct eth_device *dev);/* Register network device */
int eth_unregister(struct eth_device *dev);/* Remove network device */
Kim Phillips's avatar
Kim Phillips committed
183 184 185

extern struct eth_device *eth_current;

186
static __always_inline struct eth_device *eth_get_dev(void)
187 188 189
{
	return eth_current;
}
190 191
struct eth_device *eth_get_dev_by_name(const char *devname);
struct eth_device *eth_get_dev_by_index(int index); /* get dev @ index */
192

193
/* get the current device MAC */
194 195 196 197 198 199 200
static inline unsigned char *eth_get_ethaddr(void)
{
	if (eth_current)
		return eth_current->enetaddr;
	return NULL;
}

201 202
/* Used only when NetConsole is enabled */
int eth_is_active(struct eth_device *dev); /* Test device for active state */
203
/* Set active state */
204
static __always_inline int eth_init_state_only(void)
205 206 207 208 209 210
{
	eth_get_dev()->state = ETH_STATE_ACTIVE;

	return 0;
}
/* Set passive state */
211
static __always_inline void eth_halt_state_only(void)
212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228
{
	eth_get_dev()->state = ETH_STATE_PASSIVE;
}

/*
 * Set the hardware address for an ethernet interface based on 'eth%daddr'
 * environment variable (or just 'ethaddr' if eth_number is 0).
 * Args:
 *	base_name - base name for device (normally "eth")
 *	eth_number - value of %d (0 for first device of this type)
 * Returns:
 *	0 is success, non-zero is error status from driver.
 */
int eth_write_hwaddr(struct eth_device *dev, const char *base_name,
		     int eth_number);

int usb_eth_initialize(bd_t *bi);
229
#endif
230

231
int eth_initialize(void);		/* Initialize network subsystem */
232 233 234
void eth_try_another(int first_restart);	/* Change the device */
void eth_set_current(void);		/* set nterface to ethcur var */

235 236
int eth_get_dev_index(void);		/* get the device index */
void eth_parse_enetaddr(const char *addr, uchar *enetaddr);
237 238
int eth_getenv_enetaddr(const char *name, uchar *enetaddr);
int eth_setenv_enetaddr(const char *name, const uchar *enetaddr);
239

240
/**
241
 * eth_setenv_enetaddr_by_index() - set the MAC address environment variable
242 243 244 245 246 247 248 249 250 251 252 253 254 255 256
 *
 * This sets up an environment variable with the given MAC address (@enetaddr).
 * The environment variable to be set is defined by <@base_name><@index>addr.
 * If @index is 0 it is omitted. For common Ethernet this means ethaddr,
 * eth1addr, etc.
 *
 * @base_name:  Base name for variable, typically "eth"
 * @index:      Index of interface being updated (>=0)
 * @enetaddr:   Pointer to MAC address to put into the variable
 * @return 0 if OK, other value on error
 */
int eth_setenv_enetaddr_by_index(const char *base_name, int index,
				 uchar *enetaddr);


257 258 259 260 261 262 263 264 265
/*
 * Get the hardware address for an ethernet interface .
 * Args:
 *	base_name - base name for device (normally "eth")
 *	index - device index number (0 for first)
 *	enetaddr - returns 6 byte hardware address
 * Returns:
 *	Return true if the address is valid.
 */
266 267
int eth_getenv_enetaddr_by_index(const char *base_name, int index,
				 uchar *enetaddr);
268

269
int eth_init(void);			/* Initialize the device */
270
int eth_send(void *packet, int length);	   /* Send a packet */
271

272
#if defined(CONFIG_API) || defined(CONFIG_EFI_LOADER)
273
int eth_receive(void *packet, int length); /* Receive a packet*/
274
extern void (*push_packet)(void *packet, int length);
275
#endif
276 277
int eth_rx(void);			/* Check for received packets */
void eth_halt(void);			/* stop SCC */
278
const char *eth_get_name(void);		/* get name of current device */
279

David Updegraff's avatar
David Updegraff committed
280
#ifdef CONFIG_MCAST_TFTP
281
int eth_mcast_join(struct in_addr mcast_addr, int join);
282
u32 ether_crc(size_t len, unsigned char const *p);
David Updegraff's avatar
David Updegraff committed
283 284
#endif

wdenk's avatar
wdenk committed
285 286 287 288 289 290 291 292 293

/**********************************************************************/
/*
 *	Protocol headers.
 */

/*
 *	Ethernet header
 */
294 295

struct ethernet_hdr {
296 297 298
	u8		et_dest[6];	/* Destination node		*/
	u8		et_src[6];	/* Source node			*/
	u16		et_protlen;	/* Protocol or length		*/
299 300 301 302 303
};

/* Ethernet header size */
#define ETHER_HDR_SIZE	(sizeof(struct ethernet_hdr))

304 305
#define ETH_FCS_LEN	4		/* Octets in the FCS		*/

306
struct e802_hdr {
307 308 309 310 311 312 313 314 315 316
	u8		et_dest[6];	/* Destination node		*/
	u8		et_src[6];	/* Source node			*/
	u16		et_protlen;	/* Protocol or length		*/
	u8		et_dsap;	/* 802 DSAP			*/
	u8		et_ssap;	/* 802 SSAP			*/
	u8		et_ctl;		/* 802 control			*/
	u8		et_snap1;	/* SNAP				*/
	u8		et_snap2;
	u8		et_snap3;
	u16		et_prot;	/* 802 protocol			*/
317
};
wdenk's avatar
wdenk committed
318

319
/* 802 + SNAP + ethernet header size */
320
#define E802_HDR_SIZE	(sizeof(struct e802_hdr))
321 322

/*
323
 *	Virtual LAN Ethernet header
324
 */
325
struct vlan_ethernet_hdr {
326 327 328 329 330
	u8		vet_dest[6];	/* Destination node		*/
	u8		vet_src[6];	/* Source node			*/
	u16		vet_vlan_type;	/* PROT_VLAN			*/
	u16		vet_tag;	/* TAG of VLAN			*/
	u16		vet_type;	/* protocol type		*/
331
};
332

333 334
/* VLAN Ethernet header size */
#define VLAN_ETHER_HDR_SIZE	(sizeof(struct vlan_ethernet_hdr))
335

wdenk's avatar
wdenk committed
336 337 338
#define PROT_IP		0x0800		/* IP protocol			*/
#define PROT_ARP	0x0806		/* IP ARP protocol		*/
#define PROT_RARP	0x8035		/* IP ARP protocol		*/
339
#define PROT_VLAN	0x8100		/* IEEE 802.1q protocol		*/
340 341
#define PROT_IPV6	0x86dd		/* IPv6 over bluebook		*/
#define PROT_PPP_SES	0x8864		/* PPPoE session messages	*/
wdenk's avatar
wdenk committed
342 343 344 345 346

#define IPPROTO_ICMP	 1	/* Internet Control Message Protocol	*/
#define IPPROTO_UDP	17	/* User Datagram Protocol		*/

/*
347
 *	Internet Protocol (IP) header.
wdenk's avatar
wdenk committed
348
 */
349
struct ip_hdr {
350 351 352 353 354 355 356 357
	u8		ip_hl_v;	/* header length and version	*/
	u8		ip_tos;		/* type of service		*/
	u16		ip_len;		/* total length			*/
	u16		ip_id;		/* identification		*/
	u16		ip_off;		/* fragment offset field	*/
	u8		ip_ttl;		/* time to live			*/
	u8		ip_p;		/* protocol			*/
	u16		ip_sum;		/* checksum			*/
358 359
	struct in_addr	ip_src;		/* Source IP address		*/
	struct in_addr	ip_dst;		/* Destination IP address	*/
360
};
wdenk's avatar
wdenk committed
361

362 363 364 365 366 367
#define IP_OFFS		0x1fff /* ip offset *= 8 */
#define IP_FLAGS	0xe000 /* first 3 bits */
#define IP_FLAGS_RES	0x8000 /* reserved */
#define IP_FLAGS_DFRAG	0x4000 /* don't fragments */
#define IP_FLAGS_MFRAG	0x2000 /* more fragments */

368 369 370 371 372 373
#define IP_HDR_SIZE		(sizeof(struct ip_hdr))

/*
 *	Internet Protocol (IP) + UDP header.
 */
struct ip_udp_hdr {
374 375 376 377 378 379 380 381
	u8		ip_hl_v;	/* header length and version	*/
	u8		ip_tos;		/* type of service		*/
	u16		ip_len;		/* total length			*/
	u16		ip_id;		/* identification		*/
	u16		ip_off;		/* fragment offset field	*/
	u8		ip_ttl;		/* time to live			*/
	u8		ip_p;		/* protocol			*/
	u16		ip_sum;		/* checksum			*/
382 383
	struct in_addr	ip_src;		/* Source IP address		*/
	struct in_addr	ip_dst;		/* Destination IP address	*/
384 385 386 387
	u16		udp_src;	/* UDP source port		*/
	u16		udp_dst;	/* UDP destination port		*/
	u16		udp_len;	/* Length of UDP packet		*/
	u16		udp_xsum;	/* Checksum			*/
388
};
wdenk's avatar
wdenk committed
389

390
#define IP_UDP_HDR_SIZE		(sizeof(struct ip_udp_hdr))
391
#define UDP_HDR_SIZE		(IP_UDP_HDR_SIZE - IP_HDR_SIZE)
wdenk's avatar
wdenk committed
392 393 394 395

/*
 *	Address Resolution Protocol (ARP) header.
 */
396
struct arp_hdr {
397
	u16		ar_hrd;		/* Format of hardware address	*/
wdenk's avatar
wdenk committed
398
#   define ARP_ETHER	    1		/* Ethernet  hardware address	*/
399 400
	u16		ar_pro;		/* Format of protocol address	*/
	u8		ar_hln;		/* Length of hardware address	*/
401
#   define ARP_HLEN	6
402
	u8		ar_pln;		/* Length of protocol address	*/
403
#   define ARP_PLEN	4
404
	u16		ar_op;		/* Operation			*/
wdenk's avatar
wdenk committed
405 406 407 408 409 410 411
#   define ARPOP_REQUEST    1		/* Request  to resolve  address	*/
#   define ARPOP_REPLY	    2		/* Response to previous request	*/

#   define RARPOP_REQUEST   3		/* Request  to resolve  address	*/
#   define RARPOP_REPLY	    4		/* Response to previous request */

	/*
wdenk's avatar
wdenk committed
412 413 414
	 * The remaining fields are variable in size, according to
	 * the sizes above, and are defined as appropriate for
	 * specific hardware/protocol combinations.
wdenk's avatar
wdenk committed
415
	 */
416
	u8		ar_data[0];
417 418 419 420
#define ar_sha		ar_data[0]
#define ar_spa		ar_data[ARP_HLEN]
#define ar_tha		ar_data[ARP_HLEN + ARP_PLEN]
#define ar_tpa		ar_data[ARP_HLEN + ARP_PLEN + ARP_HLEN]
wdenk's avatar
wdenk committed
421
#if 0
422 423 424 425
	u8		ar_sha[];	/* Sender hardware address	*/
	u8		ar_spa[];	/* Sender protocol address	*/
	u8		ar_tha[];	/* Target hardware address	*/
	u8		ar_tpa[];	/* Target protocol address	*/
wdenk's avatar
wdenk committed
426
#endif /* 0 */
427
};
wdenk's avatar
wdenk committed
428 429 430 431 432 433

#define ARP_HDR_SIZE	(8+20)		/* Size assuming ethernet	*/

/*
 * ICMP stuff (just enough to handle (host) redirect messages)
 */
Wolfgang Denk's avatar
Wolfgang Denk committed
434
#define ICMP_ECHO_REPLY		0	/* Echo reply			*/
435
#define ICMP_NOT_REACH		3	/* Detination unreachable	*/
wdenk's avatar
wdenk committed
436
#define ICMP_REDIRECT		5	/* Redirect (change route)	*/
wdenk's avatar
wdenk committed
437
#define ICMP_ECHO_REQUEST	8	/* Echo request			*/
wdenk's avatar
wdenk committed
438 439 440 441 442

/* Codes for REDIRECT. */
#define ICMP_REDIR_NET		0	/* Redirect Net			*/
#define ICMP_REDIR_HOST		1	/* Redirect Host		*/

443 444 445
/* Codes for NOT_REACH */
#define ICMP_NOT_REACH_PORT	3	/* Port unreachable		*/

446
struct icmp_hdr {
447 448 449
	u8		type;
	u8		code;
	u16		checksum;
wdenk's avatar
wdenk committed
450 451
	union {
		struct {
452 453
			u16	id;
			u16	sequence;
wdenk's avatar
wdenk committed
454
		} echo;
455
		u32	gateway;
wdenk's avatar
wdenk committed
456
		struct {
457 458
			u16	unused;
			u16	mtu;
wdenk's avatar
wdenk committed
459
		} frag;
460
		u8 data[0];
wdenk's avatar
wdenk committed
461
	} un;
462
};
wdenk's avatar
wdenk committed
463

464 465
#define ICMP_HDR_SIZE		(sizeof(struct icmp_hdr))
#define IP_ICMP_HDR_SIZE	(IP_HDR_SIZE + ICMP_HDR_SIZE)
wdenk's avatar
wdenk committed
466 467

/*
468 469 470 471
 * Maximum packet size; used to allocate packet storage. Use
 * the maxium Ethernet frame size as specified by the Ethernet
 * standard including the 802.1Q tag (VLAN tagging).
 * maximum packet size =  1522
wdenk's avatar
wdenk committed
472 473
 * maximum packet size and multiple of 32 bytes =  1536
 */
474
#define PKTSIZE			1522
wdenk's avatar
wdenk committed
475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491
#define PKTSIZE_ALIGN		1536

/*
 * Maximum receive ring size; that is, the number of packets
 * we can buffer before overflow happens. Basically, this just
 * needs to be enough to prevent a packet being discarded while
 * we are processing the previous one.
 */
#define RINGSZ		4
#define RINGSZ_LOG2	2

/**********************************************************************/
/*
 *	Globals.
 *
 * Note:
 *
492
 * All variables of type struct in_addr are stored in NETWORK byte order
wdenk's avatar
wdenk committed
493 494 495 496 497
 * (big endian).
 */

/* net.c */
/** BOOTP EXTENTIONS **/
498 499 500 501
extern struct in_addr net_gateway;	/* Our gateway IP address */
extern struct in_addr net_netmask;	/* Our subnet mask (0 = unknown) */
/* Our Domain Name Server (0 = unknown) */
extern struct in_addr net_dns_server;
502
#if defined(CONFIG_BOOTP_DNS2)
503 504
/* Our 2nd Domain Name Server (0 = unknown) */
extern struct in_addr net_dns_server2;
505
#endif
506 507 508
extern char	net_nis_domain[32];	/* Our IS domain */
extern char	net_hostname[32];	/* Our hostname */
extern char	net_root_path[64];	/* Our root path */
wdenk's avatar
wdenk committed
509
/** END OF BOOTP EXTENTIONS **/
510 511
extern u8		net_ethaddr[6];		/* Our ethernet address */
extern u8		net_server_ethaddr[6];	/* Boot server enet address */
512 513
extern struct in_addr	net_ip;		/* Our    IP addr (0 = unknown) */
extern struct in_addr	net_server_ip;	/* Server IP addr (0 = unknown) */
514
extern uchar		*net_tx_packet;		/* THE transmit packet */
515
extern uchar		*net_rx_packets[PKTBUFSRX]; /* Receive packets */
516 517
extern uchar		*net_rx_packet;		/* Current receive packet */
extern int		net_rx_packet_len;	/* Current rx packet length */
518 519
extern const u8		net_bcast_ethaddr[6];	/* Ethernet broadcast address */
extern const u8		net_null_ethaddr[6];
wdenk's avatar
wdenk committed
520

521 522
#define VLAN_NONE	4095			/* untagged */
#define VLAN_IDMASK	0x0fff			/* mask of valid vlan id */
523 524
extern ushort		net_our_vlan;		/* Our VLAN */
extern ushort		net_native_vlan;	/* Our Native VLAN */
525

526
extern int		net_restart_wrap;	/* Tried all network devices */
wdenk's avatar
wdenk committed
527

528 529
enum proto_t {
	BOOTP, RARP, ARP, TFTPGET, DHCP, PING, DNS, NFS, CDP, NETCONS, SNTP,
530
	TFTPSRV, TFTPPUT, LINKLOCAL
531
};
wdenk's avatar
wdenk committed
532

533
extern char	net_boot_file_name[1024];/* Boot File name */
534 535 536 537
/* The actual transferred size of the bootfile (in bytes) */
extern u32	net_boot_file_size;
/* Boot file size in blocks as reported by the DHCP server */
extern u32	net_boot_file_expected_size_in_blocks;
wdenk's avatar
wdenk committed
538

Robin Getz's avatar
Robin Getz committed
539
#if defined(CONFIG_CMD_DNS)
540 541
extern char *net_dns_resolve;		/* The host to resolve  */
extern char *net_dns_env_var;		/* the env var to put the ip into */
Robin Getz's avatar
Robin Getz committed
542 543
#endif

544
#if defined(CONFIG_CMD_PING)
545
extern struct in_addr net_ping_ip;	/* the ip address to ping */
wdenk's avatar
wdenk committed
546 547
#endif

548
#if defined(CONFIG_CMD_CDP)
549
/* when CDP completes these hold the return values */
550 551
extern ushort cdp_native_vlan;		/* CDP returned native VLAN */
extern ushort cdp_appliance_vlan;	/* CDP returned appliance VLAN */
552 553 554 555

/*
 * Check for a CDP packet by examining the received MAC address field
 */
556
static inline int is_cdp_packet(const uchar *ethaddr)
557
{
558
	extern const u8 net_cdp_ethaddr[6];
559

560
	return memcmp(ethaddr, net_cdp_ethaddr, 6) == 0;
561
}
562 563
#endif

564
#if defined(CONFIG_CMD_SNTP)
565
extern struct in_addr	net_ntp_server;		/* the ip address to NTP */
566
extern int net_ntp_time_offset;			/* offset time from UTC */
567 568
#endif

569
#if defined(CONFIG_MCAST_TFTP)
570
extern struct in_addr net_mcast_addr;
571 572
#endif

wdenk's avatar
wdenk committed
573
/* Initialize the network adapter */
574
void net_init(void);
575
int net_loop(enum proto_t);
wdenk's avatar
wdenk committed
576 577

/* Load failed.	 Start again. */
578
int net_start_again(void);
wdenk's avatar
wdenk committed
579

580
/* Get size of the ethernet header when we send */
581
int net_eth_hdr_size(void);
582 583

/* Set ethernet header; returns the size of the header */
584
int net_set_ether(uchar *xet, const uchar *dest_ethaddr, uint prot);
585
int net_update_ether(struct ethernet_hdr *et, uchar *addr, uint prot);
wdenk's avatar
wdenk committed
586 587

/* Set IP header */
588 589
void net_set_ip_header(uchar *pkt, struct in_addr dest, struct in_addr source);
void net_set_udp_header(uchar *pkt, struct in_addr dest, int dport,
590
				int sport, int len);
wdenk's avatar
wdenk committed
591

592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621
/**
 * compute_ip_checksum() - Compute IP checksum
 *
 * @addr:	Address to check (must be 16-bit aligned)
 * @nbytes:	Number of bytes to check (normally a multiple of 2)
 * @return 16-bit IP checksum
 */
unsigned compute_ip_checksum(const void *addr, unsigned nbytes);

/**
 * add_ip_checksums() - add two IP checksums
 *
 * @offset:	Offset of first sum (if odd we do a byte-swap)
 * @sum:	First checksum
 * @new_sum:	New checksum to add
 * @return updated 16-bit IP checksum
 */
unsigned add_ip_checksums(unsigned offset, unsigned sum, unsigned new_sum);

/**
 * ip_checksum_ok() - check if a checksum is correct
 *
 * This works by making sure the checksum sums to 0
 *
 * @addr:	Address to check (must be 16-bit aligned)
 * @nbytes:	Number of bytes to check (normally a multiple of 2)
 * @return true if the checksum matches, false if not
 */
int ip_checksum_ok(const void *addr, unsigned nbytes);

Joe Hershberger's avatar
Joe Hershberger committed
622
/* Callbacks */
623 624 625 626 627
rxhand_f *net_get_udp_handler(void);	/* Get UDP RX packet handler */
void net_set_udp_handler(rxhand_f *);	/* Set UDP RX packet handler */
rxhand_f *net_get_arp_handler(void);	/* Get ARP RX packet handler */
void net_set_arp_handler(rxhand_f *);	/* Set ARP RX packet handler */
void net_set_icmp_handler(rxhand_icmp_f *f); /* Set ICMP RX handler */
628
void net_set_timeout_handler(ulong, thand_f *);/* Set timeout handler */
wdenk's avatar
wdenk committed
629

630 631 632 633 634 635 636
/* Network loop state */
enum net_loop_state {
	NETLOOP_CONTINUE,
	NETLOOP_RESTART,
	NETLOOP_SUCCESS,
	NETLOOP_FAIL
};
Kim Phillips's avatar
Kim Phillips committed
637 638
extern enum net_loop_state net_state;

639 640
static inline void net_set_state(enum net_loop_state state)
{
641
	debug_cond(DEBUG_INT_STATE, "--- NetState set to %d\n", state);
642 643 644
	net_state = state;
}

645
/* Transmit a packet */
646
static inline void net_send_packet(uchar *pkt, int len)
647
{
648
	/* Currently no way to return errors from eth_send() */
649 650
	(void) eth_send(pkt, len);
}
wdenk's avatar
wdenk committed
651

652
/*
653
 * Transmit "net_tx_packet" as UDP packet, performing ARP request if needed
654
 *  (ether will be populated)
655 656 657 658 659 660 661
 *
 * @param ether Raw packet buffer
 * @param dest IP address to send the datagram to
 * @param dport Destination UDP port
 * @param sport Source UDP port
 * @param payload_len Length of data after the UDP header
 */
662
int net_send_udp_packet(uchar *ether, struct in_addr dest, int dport,
663
			int sport, int payload_len);
wdenk's avatar
wdenk committed
664

wdenk's avatar
wdenk committed
665
/* Processes a received packet */
666
void net_process_received_packet(uchar *in_packet, int len);
wdenk's avatar
wdenk committed
667

668
#ifdef CONFIG_NETCONSOLE
669
void nc_start(void);
670
int nc_input_packet(uchar *pkt, struct in_addr src_ip, unsigned dest_port,
671
	unsigned src_port, unsigned len);
672 673
#endif

674
static __always_inline int eth_is_on_demand_init(void)
675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693
{
#ifdef CONFIG_NETCONSOLE
	extern enum proto_t net_loop_last_protocol;

	return net_loop_last_protocol != NETCONS;
#else
	return 1;
#endif
}

static inline void eth_set_last_protocol(int protocol)
{
#ifdef CONFIG_NETCONSOLE
	extern enum proto_t net_loop_last_protocol;

	net_loop_last_protocol = protocol;
#endif
}

694 695 696 697 698 699
/*
 * Check if autoload is enabled. If so, use either NFS or TFTP to download
 * the boot file.
 */
void net_auto_load(void);

wdenk's avatar
wdenk committed
700 701 702 703 704 705 706 707
/*
 * The following functions are a bit ugly, but necessary to deal with
 * alignment restrictions on ARM.
 *
 * We're using inline functions, which had the smallest memory
 * footprint in our tests.
 */
/* return IP *in network byteorder* */
708
static inline struct in_addr net_read_ip(void *from)
wdenk's avatar
wdenk committed
709
{
710
	struct in_addr ip;
711 712

	memcpy((void *)&ip, (void *)from, sizeof(ip));
wdenk's avatar
wdenk committed
713 714 715 716
	return ip;
}

/* return ulong *in network byteorder* */
717
static inline u32 net_read_u32(u32 *from)
wdenk's avatar
wdenk committed
718
{
719
	u32 l;
720 721

	memcpy((void *)&l, (void *)from, sizeof(l));
wdenk's avatar
wdenk committed
722 723 724 725
	return l;
}

/* write IP *in network byteorder* */
726
static inline void net_write_ip(void *to, struct in_addr ip)
wdenk's avatar
wdenk committed
727
{
728
	memcpy(to, (void *)&ip, sizeof(ip));
wdenk's avatar
wdenk committed
729 730 731
}

/* copy IP */
732
static inline void net_copy_ip(void *to, void *from)
wdenk's avatar
wdenk committed
733
{
734
	memcpy((void *)to, from, sizeof(struct in_addr));
wdenk's avatar
wdenk committed
735 736 737
}

/* copy ulong */
738
static inline void net_copy_u32(u32 *to, u32 *from)
wdenk's avatar
wdenk committed
739
{
740
	memcpy((void *)to, (void *)from, sizeof(u32));
wdenk's avatar
wdenk committed
741 742
}

743
/**
744
 * is_zero_ethaddr - Determine if give Ethernet address is all zeros.
745 746 747 748
 * @addr: Pointer to a six-byte array containing the Ethernet address
 *
 * Return true if the address is all zeroes.
 */
749
static inline int is_zero_ethaddr(const u8 *addr)
750 751 752 753 754
{
	return !(addr[0] | addr[1] | addr[2] | addr[3] | addr[4] | addr[5]);
}

/**
755
 * is_multicast_ethaddr - Determine if the Ethernet address is a multicast.
756 757 758 759 760
 * @addr: Pointer to a six-byte array containing the Ethernet address
 *
 * Return true if the address is a multicast address.
 * By definition the broadcast address is also a multicast address.
 */
761
static inline int is_multicast_ethaddr(const u8 *addr)
762
{
763
	return 0x01 & addr[0];
764 765
}

766
/*
767
 * is_broadcast_ethaddr - Determine if the Ethernet address is broadcast
768 769 770 771
 * @addr: Pointer to a six-byte array containing the Ethernet address
 *
 * Return true if the address is the broadcast address.
 */
772
static inline int is_broadcast_ethaddr(const u8 *addr)
773
{
774 775
	return (addr[0] & addr[1] & addr[2] & addr[3] & addr[4] & addr[5]) ==
		0xff;
776 777 778
}

/*
779
 * is_valid_ethaddr - Determine if the given Ethernet address is valid
780 781 782 783 784 785 786
 * @addr: Pointer to a six-byte array containing the Ethernet address
 *
 * Check that the Ethernet address (MAC) is not 00:00:00:00:00:00, is not
 * a multicast address, and is not FF:FF:FF:FF:FF:FF.
 *
 * Return true if the address is valid.
 */
787
static inline int is_valid_ethaddr(const u8 *addr)
788 789 790
{
	/* FF:FF:FF:FF:FF:FF is a multicast address so we don't need to
	 * explicitly check for it here. */
791
	return !is_multicast_ethaddr(addr) && !is_zero_ethaddr(addr);
792 793
}

794
/**
795
 * net_random_ethaddr - Generate software assigned random Ethernet address
796 797 798 799 800
 * @addr: Pointer to a six-byte array containing the Ethernet address
 *
 * Generate a random Ethernet address (MAC) that is not multicast
 * and has the local assigned bit set.
 */
801
static inline void net_random_ethaddr(uchar *addr)
802 803 804 805 806 807 808 809 810 811 812
{
	int i;
	unsigned int seed = get_timer(0);

	for (i = 0; i < 6; i++)
		addr[i] = rand_r(&seed);

	addr[0] &= 0xfe;	/* clear multicast bit */
	addr[0] |= 0x02;	/* set local assignment bit (IEEE802) */
}

wdenk's avatar
wdenk committed
813
/* Convert an IP address to a string */
814
void ip_to_string(struct in_addr x, char *s);
wdenk's avatar
wdenk committed
815

wdenk's avatar
wdenk committed
816
/* Convert a string to ip address */
817
struct in_addr string_to_ip(const char *s);
wdenk's avatar
wdenk committed
818

819
/* Convert a VLAN id to a string */
820
void vlan_to_string(ushort x, char *s);
821 822

/* Convert a string to a vlan id */
823
ushort string_to_vlan(const char *s);
824 825

/* read a VLAN id from an environment variable */
826
ushort getenv_vlan(char *);
827

wdenk's avatar
wdenk committed
828
/* copy a filename (allow for "..." notation, limit length) */
829
void copy_filename(char *dst, const char *src, int size);
wdenk's avatar
wdenk committed
830

831
/* get a random source port */
832
unsigned int random_port(void);
833

834 835 836 837 838 839 840 841 842 843 844 845
/**
 * update_tftp - Update firmware over TFTP (via DFU)
 *
 * This function updates board's firmware via TFTP
 *
 * @param addr - memory address where data is stored
 * @param interface - the DFU medium name - e.g. "mmc"
 * @param devstring - the DFU medium number - e.g. "1"
 *
 * @return - 0 on success, other value on failure
 */
int update_tftp(ulong addr, char *interface, char *devstring);
846

wdenk's avatar
wdenk committed
847 848 849
/**********************************************************************/

#endif /* __NET_H__ */