]> git.sur5r.net Git - u-boot/blob - include/net.h
9c5dea58f9dc93b7412491cc35e9e550cd745259
[u-boot] / include / net.h
1 /*
2  *      LiMon Monitor (LiMon) - Network.
3  *
4  *      Copyright 1994 - 2000 Neil Russell.
5  *      (See License)
6  *      SPDX-License-Identifier:        GPL-2.0
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 __be32          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 #ifdef CONFIG_DM_ETH
82 /**
83  * struct eth_pdata - Platform data for Ethernet MAC controllers
84  *
85  * @iobase: The base address of the hardware registers
86  * @enetaddr: The Ethernet MAC address that is loaded from EEPROM or env
87  */
88 struct eth_pdata {
89         phys_addr_t iobase;
90         unsigned char enetaddr[6];
91 };
92
93 /**
94  * struct eth_ops - functions of Ethernet MAC controllers
95  *
96  * start: Prepare the hardware to send and receive packets
97  * send: Send the bytes passed in "packet" as a packet on the wire
98  * recv: Check if the hardware received a packet. Call the network stack if so
99  * stop: Stop the hardware from looking for packets - may be called even if
100  *       state == PASSIVE
101  * mcast: Join or leave a multicast group (for TFTP) - optional
102  * write_hwaddr: Write a MAC address to the hardware (used to pass it to Linux
103  *               on some platforms like ARM). This function expects the
104  *               eth_pdata::enetaddr field to be populated - optional
105  * read_rom_hwaddr: Some devices have a backup of the MAC address stored in a
106  *                  ROM on the board. This is how the driver should expose it
107  *                  to the network stack. This function should fill in the
108  *                  eth_pdata::enetaddr field - optional
109  */
110 struct eth_ops {
111         int (*start)(struct udevice *dev);
112         int (*send)(struct udevice *dev, void *packet, int length);
113         int (*recv)(struct udevice *dev);
114         void (*stop)(struct udevice *dev);
115 #ifdef CONFIG_MCAST_TFTP
116         int (*mcast)(struct udevice *dev, const u8 *enetaddr, int join);
117 #endif
118         int (*write_hwaddr)(struct udevice *dev);
119         int (*read_rom_hwaddr)(struct udevice *dev);
120 };
121
122 #define eth_get_ops(dev) ((struct eth_ops *)(dev)->driver->ops)
123
124 struct udevice *eth_get_dev(void); /* get the current device */
125 unsigned char *eth_get_ethaddr(void); /* get the current device MAC */
126 /* Used only when NetConsole is enabled */
127 int eth_init_state_only(void); /* Set active state */
128 void eth_halt_state_only(void); /* Set passive state */
129 #endif
130
131 #ifndef CONFIG_DM_ETH
132 struct eth_device {
133         char name[16];
134         unsigned char enetaddr[6];
135         phys_addr_t iobase;
136         int state;
137
138         int  (*init) (struct eth_device *, bd_t *);
139         int  (*send) (struct eth_device *, void *packet, int length);
140         int  (*recv) (struct eth_device *);
141         void (*halt) (struct eth_device *);
142 #ifdef CONFIG_MCAST_TFTP
143         int (*mcast) (struct eth_device *, const u8 *enetaddr, u8 set);
144 #endif
145         int  (*write_hwaddr) (struct eth_device *);
146         struct eth_device *next;
147         int index;
148         void *priv;
149 };
150
151 int eth_register(struct eth_device *dev);/* Register network device */
152 int eth_unregister(struct eth_device *dev);/* Remove network device */
153
154 extern struct eth_device *eth_current;
155
156 static inline __attribute__((always_inline))
157 struct eth_device *eth_get_dev(void)
158 {
159         return eth_current;
160 }
161 struct eth_device *eth_get_dev_by_name(const char *devname);
162 struct eth_device *eth_get_dev_by_index(int index); /* get dev @ index */
163
164 /* get the current device MAC */
165 static inline unsigned char *eth_get_ethaddr(void)
166 {
167         if (eth_current)
168                 return eth_current->enetaddr;
169         return NULL;
170 }
171
172 /* Set active state */
173 static inline __attribute__((always_inline)) int eth_init_state_only(void)
174 {
175         eth_get_dev()->state = ETH_STATE_ACTIVE;
176
177         return 0;
178 }
179 /* Set passive state */
180 static inline __attribute__((always_inline)) void eth_halt_state_only(void)
181 {
182         eth_get_dev()->state = ETH_STATE_PASSIVE;
183 }
184
185 /*
186  * Set the hardware address for an ethernet interface based on 'eth%daddr'
187  * environment variable (or just 'ethaddr' if eth_number is 0).
188  * Args:
189  *      base_name - base name for device (normally "eth")
190  *      eth_number - value of %d (0 for first device of this type)
191  * Returns:
192  *      0 is success, non-zero is error status from driver.
193  */
194 int eth_write_hwaddr(struct eth_device *dev, const char *base_name,
195                      int eth_number);
196
197 int usb_eth_initialize(bd_t *bi);
198 #endif
199
200 int eth_initialize(void);               /* Initialize network subsystem */
201 void eth_try_another(int first_restart);        /* Change the device */
202 void eth_set_current(void);             /* set nterface to ethcur var */
203
204 int eth_get_dev_index(void);            /* get the device index */
205 void eth_parse_enetaddr(const char *addr, uchar *enetaddr);
206 int eth_getenv_enetaddr(char *name, uchar *enetaddr);
207 int eth_setenv_enetaddr(char *name, const uchar *enetaddr);
208
209 /*
210  * Get the hardware address for an ethernet interface .
211  * Args:
212  *      base_name - base name for device (normally "eth")
213  *      index - device index number (0 for first)
214  *      enetaddr - returns 6 byte hardware address
215  * Returns:
216  *      Return true if the address is valid.
217  */
218 int eth_getenv_enetaddr_by_index(const char *base_name, int index,
219                                  uchar *enetaddr);
220
221 int eth_init(void);                     /* Initialize the device */
222 int eth_send(void *packet, int length);    /* Send a packet */
223
224 #ifdef CONFIG_API
225 int eth_receive(void *packet, int length); /* Receive a packet*/
226 extern void (*push_packet)(void *packet, int length);
227 #endif
228 int eth_rx(void);                       /* Check for received packets */
229 void eth_halt(void);                    /* stop SCC */
230 const char *eth_get_name(void);         /* get name of current device */
231
232 #ifdef CONFIG_MCAST_TFTP
233 int eth_mcast_join(IPaddr_t mcast_addr, int join);
234 u32 ether_crc(size_t len, unsigned char const *p);
235 #endif
236
237
238 /**********************************************************************/
239 /*
240  *      Protocol headers.
241  */
242
243 /*
244  *      Ethernet header
245  */
246
247 struct ethernet_hdr {
248         uchar           et_dest[6];     /* Destination node             */
249         uchar           et_src[6];      /* Source node                  */
250         ushort          et_protlen;     /* Protocol or length           */
251 };
252
253 /* Ethernet header size */
254 #define ETHER_HDR_SIZE  (sizeof(struct ethernet_hdr))
255
256 #define ETH_FCS_LEN     4               /* Octets in the FCS            */
257
258 struct e802_hdr {
259         uchar           et_dest[6];     /* Destination node             */
260         uchar           et_src[6];      /* Source node                  */
261         ushort          et_protlen;     /* Protocol or length           */
262         uchar           et_dsap;        /* 802 DSAP                     */
263         uchar           et_ssap;        /* 802 SSAP                     */
264         uchar           et_ctl;         /* 802 control                  */
265         uchar           et_snap1;       /* SNAP                         */
266         uchar           et_snap2;
267         uchar           et_snap3;
268         ushort          et_prot;        /* 802 protocol                 */
269 };
270
271 /* 802 + SNAP + ethernet header size */
272 #define E802_HDR_SIZE   (sizeof(struct e802_hdr))
273
274 /*
275  *      Virtual LAN Ethernet header
276  */
277 struct vlan_ethernet_hdr {
278         uchar           vet_dest[6];    /* Destination node             */
279         uchar           vet_src[6];     /* Source node                  */
280         ushort          vet_vlan_type;  /* PROT_VLAN                    */
281         ushort          vet_tag;        /* TAG of VLAN                  */
282         ushort          vet_type;       /* protocol type                */
283 };
284
285 /* VLAN Ethernet header size */
286 #define VLAN_ETHER_HDR_SIZE     (sizeof(struct vlan_ethernet_hdr))
287
288 #define PROT_IP         0x0800          /* IP protocol                  */
289 #define PROT_ARP        0x0806          /* IP ARP protocol              */
290 #define PROT_RARP       0x8035          /* IP ARP protocol              */
291 #define PROT_VLAN       0x8100          /* IEEE 802.1q protocol         */
292
293 #define IPPROTO_ICMP     1      /* Internet Control Message Protocol    */
294 #define IPPROTO_UDP     17      /* User Datagram Protocol               */
295
296 /*
297  *      Internet Protocol (IP) header.
298  */
299 struct ip_hdr {
300         uchar           ip_hl_v;        /* header length and version    */
301         uchar           ip_tos;         /* type of service              */
302         ushort          ip_len;         /* total length                 */
303         ushort          ip_id;          /* identification               */
304         ushort          ip_off;         /* fragment offset field        */
305         uchar           ip_ttl;         /* time to live                 */
306         uchar           ip_p;           /* protocol                     */
307         ushort          ip_sum;         /* checksum                     */
308         IPaddr_t        ip_src;         /* Source IP address            */
309         IPaddr_t        ip_dst;         /* Destination IP address       */
310 };
311
312 #define IP_OFFS         0x1fff /* ip offset *= 8 */
313 #define IP_FLAGS        0xe000 /* first 3 bits */
314 #define IP_FLAGS_RES    0x8000 /* reserved */
315 #define IP_FLAGS_DFRAG  0x4000 /* don't fragments */
316 #define IP_FLAGS_MFRAG  0x2000 /* more fragments */
317
318 #define IP_HDR_SIZE             (sizeof(struct ip_hdr))
319
320 /*
321  *      Internet Protocol (IP) + UDP header.
322  */
323 struct ip_udp_hdr {
324         uchar           ip_hl_v;        /* header length and version    */
325         uchar           ip_tos;         /* type of service              */
326         ushort          ip_len;         /* total length                 */
327         ushort          ip_id;          /* identification               */
328         ushort          ip_off;         /* fragment offset field        */
329         uchar           ip_ttl;         /* time to live                 */
330         uchar           ip_p;           /* protocol                     */
331         ushort          ip_sum;         /* checksum                     */
332         IPaddr_t        ip_src;         /* Source IP address            */
333         IPaddr_t        ip_dst;         /* Destination IP address       */
334         ushort          udp_src;        /* UDP source port              */
335         ushort          udp_dst;        /* UDP destination port         */
336         ushort          udp_len;        /* Length of UDP packet         */
337         ushort          udp_xsum;       /* Checksum                     */
338 };
339
340 #define IP_UDP_HDR_SIZE         (sizeof(struct ip_udp_hdr))
341 #define UDP_HDR_SIZE            (IP_UDP_HDR_SIZE - IP_HDR_SIZE)
342
343 /*
344  *      Address Resolution Protocol (ARP) header.
345  */
346 struct arp_hdr {
347         ushort          ar_hrd;         /* Format of hardware address   */
348 #   define ARP_ETHER        1           /* Ethernet  hardware address   */
349         ushort          ar_pro;         /* Format of protocol address   */
350         uchar           ar_hln;         /* Length of hardware address   */
351 #   define ARP_HLEN     6
352         uchar           ar_pln;         /* Length of protocol address   */
353 #   define ARP_PLEN     4
354         ushort          ar_op;          /* Operation                    */
355 #   define ARPOP_REQUEST    1           /* Request  to resolve  address */
356 #   define ARPOP_REPLY      2           /* Response to previous request */
357
358 #   define RARPOP_REQUEST   3           /* Request  to resolve  address */
359 #   define RARPOP_REPLY     4           /* Response to previous request */
360
361         /*
362          * The remaining fields are variable in size, according to
363          * the sizes above, and are defined as appropriate for
364          * specific hardware/protocol combinations.
365          */
366         uchar           ar_data[0];
367 #define ar_sha          ar_data[0]
368 #define ar_spa          ar_data[ARP_HLEN]
369 #define ar_tha          ar_data[ARP_HLEN + ARP_PLEN]
370 #define ar_tpa          ar_data[ARP_HLEN + ARP_PLEN + ARP_HLEN]
371 #if 0
372         uchar           ar_sha[];       /* Sender hardware address      */
373         uchar           ar_spa[];       /* Sender protocol address      */
374         uchar           ar_tha[];       /* Target hardware address      */
375         uchar           ar_tpa[];       /* Target protocol address      */
376 #endif /* 0 */
377 };
378
379 #define ARP_HDR_SIZE    (8+20)          /* Size assuming ethernet       */
380
381 /*
382  * ICMP stuff (just enough to handle (host) redirect messages)
383  */
384 #define ICMP_ECHO_REPLY         0       /* Echo reply                   */
385 #define ICMP_NOT_REACH          3       /* Detination unreachable       */
386 #define ICMP_REDIRECT           5       /* Redirect (change route)      */
387 #define ICMP_ECHO_REQUEST       8       /* Echo request                 */
388
389 /* Codes for REDIRECT. */
390 #define ICMP_REDIR_NET          0       /* Redirect Net                 */
391 #define ICMP_REDIR_HOST         1       /* Redirect Host                */
392
393 /* Codes for NOT_REACH */
394 #define ICMP_NOT_REACH_PORT     3       /* Port unreachable             */
395
396 struct icmp_hdr {
397         uchar           type;
398         uchar           code;
399         ushort          checksum;
400         union {
401                 struct {
402                         ushort  id;
403                         ushort  sequence;
404                 } echo;
405                 ulong   gateway;
406                 struct {
407                         ushort  unused;
408                         ushort  mtu;
409                 } frag;
410                 uchar data[0];
411         } un;
412 };
413
414 #define ICMP_HDR_SIZE           (sizeof(struct icmp_hdr))
415 #define IP_ICMP_HDR_SIZE        (IP_HDR_SIZE + ICMP_HDR_SIZE)
416
417 /*
418  * Maximum packet size; used to allocate packet storage.
419  * TFTP packets can be 524 bytes + IP header + ethernet header.
420  * Lets be conservative, and go for 38 * 16.  (Must also be
421  * a multiple of 32 bytes).
422  */
423 /*
424  * AS.HARNOIS : Better to set PKTSIZE to maximum size because
425  * traffic type is not always controlled
426  * maximum packet size =  1518
427  * maximum packet size and multiple of 32 bytes =  1536
428  */
429 #define PKTSIZE                 1518
430 #define PKTSIZE_ALIGN           1536
431 /*#define PKTSIZE               608*/
432
433 /*
434  * Maximum receive ring size; that is, the number of packets
435  * we can buffer before overflow happens. Basically, this just
436  * needs to be enough to prevent a packet being discarded while
437  * we are processing the previous one.
438  */
439 #define RINGSZ          4
440 #define RINGSZ_LOG2     2
441
442 /**********************************************************************/
443 /*
444  *      Globals.
445  *
446  * Note:
447  *
448  * All variables of type IPaddr_t are stored in NETWORK byte order
449  * (big endian).
450  */
451
452 /* net.c */
453 /** BOOTP EXTENTIONS **/
454 extern IPaddr_t NetOurGatewayIP;        /* Our gateway IP address */
455 extern IPaddr_t NetOurSubnetMask;       /* Our subnet mask (0 = unknown) */
456 extern IPaddr_t NetOurDNSIP;    /* Our Domain Name Server (0 = unknown) */
457 #if defined(CONFIG_BOOTP_DNS2)
458 extern IPaddr_t NetOurDNS2IP;   /* Our 2nd Domain Name Server (0 = unknown) */
459 #endif
460 extern char     NetOurNISDomain[32];    /* Our NIS domain */
461 extern char     NetOurHostName[32];     /* Our hostname */
462 extern char     NetOurRootPath[64];     /* Our root path */
463 extern ushort   NetBootFileSize;        /* Our boot file size in blocks */
464 /** END OF BOOTP EXTENTIONS **/
465 extern ulong            NetBootFileXferSize;    /* size of bootfile in bytes */
466 extern uchar            NetOurEther[6];         /* Our ethernet address */
467 extern uchar            NetServerEther[6];      /* Boot server enet address */
468 extern IPaddr_t         NetOurIP;       /* Our    IP addr (0 = unknown) */
469 extern IPaddr_t         NetServerIP;    /* Server IP addr (0 = unknown) */
470 extern uchar            *NetTxPacket;           /* THE transmit packet */
471 extern uchar            *NetRxPackets[PKTBUFSRX]; /* Receive packets */
472 extern uchar            *NetRxPacket;           /* Current receive packet */
473 extern int              NetRxPacketLen;         /* Current rx packet length */
474 extern unsigned         NetIPID;                /* IP ID (counting) */
475 extern uchar            NetBcastAddr[6];        /* Ethernet boardcast address */
476 extern uchar            NetEtherNullAddr[6];
477
478 #define VLAN_NONE       4095                    /* untagged */
479 #define VLAN_IDMASK     0x0fff                  /* mask of valid vlan id */
480 extern ushort           NetOurVLAN;             /* Our VLAN */
481 extern ushort           NetOurNativeVLAN;       /* Our Native VLAN */
482
483 extern int              NetRestartWrap;         /* Tried all network devices */
484
485 enum proto_t {
486         BOOTP, RARP, ARP, TFTPGET, DHCP, PING, DNS, NFS, CDP, NETCONS, SNTP,
487         TFTPSRV, TFTPPUT, LINKLOCAL
488 };
489
490 /* from net/net.c */
491 extern char     BootFile[128];                  /* Boot File name */
492
493 #if defined(CONFIG_CMD_DNS)
494 extern char *NetDNSResolve;             /* The host to resolve  */
495 extern char *NetDNSenvvar;              /* the env var to put the ip into */
496 #endif
497
498 #if defined(CONFIG_CMD_PING)
499 extern IPaddr_t NetPingIP;                      /* the ip address to ping */
500 #endif
501
502 #if defined(CONFIG_CMD_CDP)
503 /* when CDP completes these hold the return values */
504 extern ushort CDPNativeVLAN;            /* CDP returned native VLAN */
505 extern ushort CDPApplianceVLAN;         /* CDP returned appliance VLAN */
506
507 /*
508  * Check for a CDP packet by examining the received MAC address field
509  */
510 static inline int is_cdp_packet(const uchar *et_addr)
511 {
512         extern const uchar NetCDPAddr[6];
513
514         return memcmp(et_addr, NetCDPAddr, 6) == 0;
515 }
516 #endif
517
518 #if defined(CONFIG_CMD_SNTP)
519 extern IPaddr_t NetNtpServerIP;                 /* the ip address to NTP */
520 extern int NetTimeOffset;                       /* offset time from UTC */
521 #endif
522
523 #if defined(CONFIG_MCAST_TFTP)
524 extern IPaddr_t Mcast_addr;
525 #endif
526
527 /* Initialize the network adapter */
528 void net_init(void);
529 int NetLoop(enum proto_t);
530
531 /* Shutdown adapters and cleanup */
532 void    NetStop(void);
533
534 /* Load failed.  Start again. */
535 void    NetStartAgain(void);
536
537 /* Get size of the ethernet header when we send */
538 int     NetEthHdrSize(void);
539
540 /* Set ethernet header; returns the size of the header */
541 int NetSetEther(uchar *, uchar *, uint);
542 int net_update_ether(struct ethernet_hdr *et, uchar *addr, uint prot);
543
544 /* Set IP header */
545 void net_set_ip_header(uchar *pkt, IPaddr_t dest, IPaddr_t source);
546 void net_set_udp_header(uchar *pkt, IPaddr_t dest, int dport,
547                                 int sport, int len);
548
549 /**
550  * compute_ip_checksum() - Compute IP checksum
551  *
552  * @addr:       Address to check (must be 16-bit aligned)
553  * @nbytes:     Number of bytes to check (normally a multiple of 2)
554  * @return 16-bit IP checksum
555  */
556 unsigned compute_ip_checksum(const void *addr, unsigned nbytes);
557
558 /**
559  * add_ip_checksums() - add two IP checksums
560  *
561  * @offset:     Offset of first sum (if odd we do a byte-swap)
562  * @sum:        First checksum
563  * @new_sum:    New checksum to add
564  * @return updated 16-bit IP checksum
565  */
566 unsigned add_ip_checksums(unsigned offset, unsigned sum, unsigned new_sum);
567
568 /**
569  * ip_checksum_ok() - check if a checksum is correct
570  *
571  * This works by making sure the checksum sums to 0
572  *
573  * @addr:       Address to check (must be 16-bit aligned)
574  * @nbytes:     Number of bytes to check (normally a multiple of 2)
575  * @return true if the checksum matches, false if not
576  */
577 int ip_checksum_ok(const void *addr, unsigned nbytes);
578
579 /* Callbacks */
580 rxhand_f *net_get_udp_handler(void);    /* Get UDP RX packet handler */
581 void net_set_udp_handler(rxhand_f *);   /* Set UDP RX packet handler */
582 rxhand_f *net_get_arp_handler(void);    /* Get ARP RX packet handler */
583 void net_set_arp_handler(rxhand_f *);   /* Set ARP RX packet handler */
584 void net_set_icmp_handler(rxhand_icmp_f *f); /* Set ICMP RX handler */
585 void    NetSetTimeout(ulong, thand_f *);/* Set timeout handler */
586
587 /* Network loop state */
588 enum net_loop_state {
589         NETLOOP_CONTINUE,
590         NETLOOP_RESTART,
591         NETLOOP_SUCCESS,
592         NETLOOP_FAIL
593 };
594 extern enum net_loop_state net_state;
595
596 static inline void net_set_state(enum net_loop_state state)
597 {
598         debug_cond(DEBUG_INT_STATE, "--- NetState set to %d\n", state);
599         net_state = state;
600 }
601
602 /* Transmit a packet */
603 static inline void NetSendPacket(uchar *pkt, int len)
604 {
605         (void) eth_send(pkt, len);
606 }
607
608 /*
609  * Transmit "NetTxPacket" as UDP packet, performing ARP request if needed
610  *  (ether will be populated)
611  *
612  * @param ether Raw packet buffer
613  * @param dest IP address to send the datagram to
614  * @param dport Destination UDP port
615  * @param sport Source UDP port
616  * @param payload_len Length of data after the UDP header
617  */
618 int NetSendUDPPacket(uchar *ether, IPaddr_t dest, int dport,
619                         int sport, int payload_len);
620
621 /* Processes a received packet */
622 void NetReceive(uchar *, int);
623
624 #ifdef CONFIG_NETCONSOLE
625 void NcStart(void);
626 int nc_input_packet(uchar *pkt, IPaddr_t src_ip, unsigned dest_port,
627         unsigned src_port, unsigned len);
628 #endif
629
630 static inline __attribute__((always_inline)) int eth_is_on_demand_init(void)
631 {
632 #ifdef CONFIG_NETCONSOLE
633         extern enum proto_t net_loop_last_protocol;
634
635         return net_loop_last_protocol != NETCONS;
636 #else
637         return 1;
638 #endif
639 }
640
641 static inline void eth_set_last_protocol(int protocol)
642 {
643 #ifdef CONFIG_NETCONSOLE
644         extern enum proto_t net_loop_last_protocol;
645
646         net_loop_last_protocol = protocol;
647 #endif
648 }
649
650 /*
651  * Check if autoload is enabled. If so, use either NFS or TFTP to download
652  * the boot file.
653  */
654 void net_auto_load(void);
655
656 /*
657  * The following functions are a bit ugly, but necessary to deal with
658  * alignment restrictions on ARM.
659  *
660  * We're using inline functions, which had the smallest memory
661  * footprint in our tests.
662  */
663 /* return IP *in network byteorder* */
664 static inline IPaddr_t NetReadIP(void *from)
665 {
666         IPaddr_t ip;
667
668         memcpy((void *)&ip, (void *)from, sizeof(ip));
669         return ip;
670 }
671
672 /* return ulong *in network byteorder* */
673 static inline ulong NetReadLong(ulong *from)
674 {
675         ulong l;
676
677         memcpy((void *)&l, (void *)from, sizeof(l));
678         return l;
679 }
680
681 /* write IP *in network byteorder* */
682 static inline void NetWriteIP(void *to, IPaddr_t ip)
683 {
684         memcpy(to, (void *)&ip, sizeof(ip));
685 }
686
687 /* copy IP */
688 static inline void NetCopyIP(void *to, void *from)
689 {
690         memcpy((void *)to, from, sizeof(IPaddr_t));
691 }
692
693 /* copy ulong */
694 static inline void NetCopyLong(ulong *to, ulong *from)
695 {
696         memcpy((void *)to, (void *)from, sizeof(ulong));
697 }
698
699 /**
700  * is_zero_ether_addr - Determine if give Ethernet address is all zeros.
701  * @addr: Pointer to a six-byte array containing the Ethernet address
702  *
703  * Return true if the address is all zeroes.
704  */
705 static inline int is_zero_ether_addr(const u8 *addr)
706 {
707         return !(addr[0] | addr[1] | addr[2] | addr[3] | addr[4] | addr[5]);
708 }
709
710 /**
711  * is_multicast_ether_addr - Determine if the Ethernet address is a multicast.
712  * @addr: Pointer to a six-byte array containing the Ethernet address
713  *
714  * Return true if the address is a multicast address.
715  * By definition the broadcast address is also a multicast address.
716  */
717 static inline int is_multicast_ether_addr(const u8 *addr)
718 {
719         return 0x01 & addr[0];
720 }
721
722 /*
723  * is_broadcast_ether_addr - Determine if the Ethernet address is broadcast
724  * @addr: Pointer to a six-byte array containing the Ethernet address
725  *
726  * Return true if the address is the broadcast address.
727  */
728 static inline int is_broadcast_ether_addr(const u8 *addr)
729 {
730         return (addr[0] & addr[1] & addr[2] & addr[3] & addr[4] & addr[5]) ==
731                 0xff;
732 }
733
734 /*
735  * is_valid_ether_addr - Determine if the given Ethernet address is valid
736  * @addr: Pointer to a six-byte array containing the Ethernet address
737  *
738  * Check that the Ethernet address (MAC) is not 00:00:00:00:00:00, is not
739  * a multicast address, and is not FF:FF:FF:FF:FF:FF.
740  *
741  * Return true if the address is valid.
742  */
743 static inline int is_valid_ether_addr(const u8 *addr)
744 {
745         /* FF:FF:FF:FF:FF:FF is a multicast address so we don't need to
746          * explicitly check for it here. */
747         return !is_multicast_ether_addr(addr) && !is_zero_ether_addr(addr);
748 }
749
750 /**
751  * eth_random_addr - Generate software assigned random Ethernet address
752  * @addr: Pointer to a six-byte array containing the Ethernet address
753  *
754  * Generate a random Ethernet address (MAC) that is not multicast
755  * and has the local assigned bit set.
756  */
757 static inline void eth_random_addr(uchar *addr)
758 {
759         int i;
760         unsigned int seed = get_timer(0);
761
762         for (i = 0; i < 6; i++)
763                 addr[i] = rand_r(&seed);
764
765         addr[0] &= 0xfe;        /* clear multicast bit */
766         addr[0] |= 0x02;        /* set local assignment bit (IEEE802) */
767 }
768
769 /* Convert an IP address to a string */
770 void ip_to_string(IPaddr_t x, char *s);
771
772 /* Convert a string to ip address */
773 IPaddr_t string_to_ip(const char *s);
774
775 /* Convert a VLAN id to a string */
776 void VLAN_to_string(ushort x, char *s);
777
778 /* Convert a string to a vlan id */
779 ushort string_to_VLAN(const char *s);
780
781 /* read a VLAN id from an environment variable */
782 ushort getenv_VLAN(char *);
783
784 /* copy a filename (allow for "..." notation, limit length) */
785 void copy_filename(char *dst, const char *src, int size);
786
787 /* get a random source port */
788 unsigned int random_port(void);
789
790 /* Update U-Boot over TFTP */
791 int update_tftp(ulong addr);
792
793 /**********************************************************************/
794
795 #endif /* __NET_H__ */