LXR uboot/include/net.h

   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# if !defined(CONFIG_NET_MULTI)
  18#  if defined(FEC_ENET) || defined(SCC_ENET)
  19#   define CONFIG_NET_MULTI
  20#  endif
  21# endif
  22#endif  /* CONFIG_8xx */
  23
  24#if defined(CONFIG_MPC5xxx)
  25# if !defined(CONFIG_NET_MULTI)
  26#  if defined(CONFIG_MPC5xxx_FEC)
  27#   define CONFIG_NET_MULTI
  28#  endif
  29# endif
  30#endif  /* CONFIG_MPC5xxx */
  31
  32#if !defined(CONFIG_NET_MULTI) && defined(CONFIG_CPM2)
  33#include <config.h>
  34#if defined(CONFIG_ETHER_ON_FCC)
  35#if defined(CONFIG_ETHER_ON_SCC)
  36#error "Ethernet not correctly defined"
  37#endif /* CONFIG_ETHER_ON_SCC */
  38#define CONFIG_NET_MULTI
  39#if (CONFIG_ETHER_INDEX == 1)
  40#define CONFIG_ETHER_ON_FCC1
  41# define CONFIG_SYS_CMXFCR_MASK1        CONFIG_SYS_CMXFCR_MASK
  42# define CONFIG_SYS_CMXFCR_VALUE1       CONFIG_SYS_CMXFCR_VALUE
  43#elif (CONFIG_ETHER_INDEX == 2)
  44#define CONFIG_ETHER_ON_FCC2
  45# define CONFIG_SYS_CMXFCR_MASK2        CONFIG_SYS_CMXFCR_MASK
  46# define CONFIG_SYS_CMXFCR_VALUE2       CONFIG_SYS_CMXFCR_VALUE
  47#elif (CONFIG_ETHER_INDEX == 3)
  48#define CONFIG_ETHER_ON_FCC3
  49# define CONFIG_SYS_CMXFCR_MASK3        CONFIG_SYS_CMXFCR_MASK
  50# define CONFIG_SYS_CMXFCR_VALUE3       CONFIG_SYS_CMXFCR_VALUE
  51#endif /* CONFIG_ETHER_INDEX */
  52#endif /* CONFIG_ETHER_ON_FCC */
  53#endif /* !CONFIG_NET_MULTI && CONFIG_8260 */
  54
  55#include <asm/byteorder.h>      /* for nton* / ntoh* stuff */
  56
  57
  58/*
  59 *      The number of receive packet buffers, and the required packet buffer
  60 *      alignment in memory.
  61 *
  62 */
  63
  64#ifdef CONFIG_SYS_RX_ETH_BUFFER
  65# define PKTBUFSRX      CONFIG_SYS_RX_ETH_BUFFER
  66#else
  67# define PKTBUFSRX      4
  68#endif
  69
  70#define PKTALIGN        32
  71
  72typedef ulong           IPaddr_t;
  73
  74
  75/*
  76 * The current receive packet handler.  Called with a pointer to the
  77 * application packet, and a protocol type (PORT_BOOTPC or PORT_TFTP).
  78 * All other packets are dealt with without calling the handler.
  79 */
  80typedef void    rxhand_f(uchar *, unsigned, unsigned, unsigned);
  81
  82/*
  83 *      A timeout handler.  Called after time interval has expired.
  84 */
  85typedef void    thand_f(void);
  86
  87#define NAMESIZE 16
  88
  89enum eth_state_t {
  90        ETH_STATE_INIT,
  91        ETH_STATE_PASSIVE,
  92        ETH_STATE_ACTIVE
  93};
  94
  95struct eth_device {
  96        char name[NAMESIZE];
  97        unsigned char enetaddr[6];
  98        int iobase;
  99        int state;
 100
 101        int  (*init) (struct eth_device*, bd_t*);
 102        int  (*send) (struct eth_device*, volatile void* packet, int length);
 103        int  (*recv) (struct eth_device*);
 104        void (*halt) (struct eth_device*);
 105#ifdef CONFIG_MCAST_TFTP
 106        int (*mcast) (struct eth_device*, u32 ip, u8 set);
 107#endif
 108        struct eth_device *next;
 109        void *priv;
 110};
 111
 112extern int eth_initialize(bd_t *bis);   /* Initialize network subsystem */
 113extern int eth_register(struct eth_device* dev);/* Register network device */
 114extern void eth_try_another(int first_restart); /* Change the device */
 115#ifdef CONFIG_NET_MULTI
 116extern void eth_set_current(void);              /* set nterface to ethcur var */
 117#endif
 118extern struct eth_device *eth_get_dev(void);    /* get the current device MAC */
 119extern struct eth_device *eth_get_dev_by_name(char *devname); /* get device */
 120extern struct eth_device *eth_get_dev_by_index(int index); /* get dev @ index */
 121extern int eth_get_dev_index (void);            /* get the device index */
 122extern void eth_parse_enetaddr(const char *addr, uchar *enetaddr);
 123extern int eth_getenv_enetaddr(char *name, uchar *enetaddr);
 124extern int eth_setenv_enetaddr(char *name, const uchar *enetaddr);
 125extern int eth_getenv_enetaddr_by_index(int index, uchar *enetaddr);
 126
 127extern int eth_init(bd_t *bis);                 /* Initialize the device */
 128extern int eth_send(volatile void *packet, int length);    /* Send a packet */
 129#ifdef CONFIG_API
 130extern int eth_receive(volatile void *packet, int length); /* Receive a packet*/
 131#endif
 132extern int eth_rx(void);                        /* Check for received packets */
 133extern void eth_halt(void);                     /* stop SCC */
 134extern char *eth_get_name(void);                /* get name of current device */
 135
 136#ifdef CONFIG_MCAST_TFTP
 137int eth_mcast_join( IPaddr_t mcast_addr, u8 join);
 138u32 ether_crc (size_t len, unsigned char const *p);
 139#endif
 140
 141
 142/**********************************************************************/
 143/*
 144 *      Protocol headers.
 145 */
 146
 147/*
 148 *      Ethernet header
 149 */
 150typedef struct {
 151        uchar           et_dest[6];     /* Destination node             */
 152        uchar           et_src[6];      /* Source node                  */
 153        ushort          et_protlen;     /* Protocol or length           */
 154        uchar           et_dsap;        /* 802 DSAP                     */
 155        uchar           et_ssap;        /* 802 SSAP                     */
 156        uchar           et_ctl;         /* 802 control                  */
 157        uchar           et_snap1;       /* SNAP                         */
 158        uchar           et_snap2;
 159        uchar           et_snap3;
 160        ushort          et_prot;        /* 802 protocol                 */
 161} Ethernet_t;
 162
 163#define ETHER_HDR_SIZE  14              /* Ethernet header size         */
 164#define E802_HDR_SIZE   22              /* 802 ethernet header size     */
 165
 166/*
 167 *      Ethernet header
 168 */
 169typedef struct {
 170        uchar           vet_dest[6];    /* Destination node             */
 171        uchar           vet_src[6];     /* Source node                  */
 172        ushort          vet_vlan_type;  /* PROT_VLAN                    */
 173        ushort          vet_tag;        /* TAG of VLAN                  */
 174        ushort          vet_type;       /* protocol type                */
 175} VLAN_Ethernet_t;
 176
 177#define VLAN_ETHER_HDR_SIZE     18      /* VLAN Ethernet header size    */
 178
 179#define PROT_IP         0x0800          /* IP protocol                  */
 180#define PROT_ARP        0x0806          /* IP ARP protocol              */
 181#define PROT_RARP       0x8035          /* IP ARP protocol              */
 182#define PROT_VLAN       0x8100          /* IEEE 802.1q protocol         */
 183
 184#define IPPROTO_ICMP     1      /* Internet Control Message Protocol    */
 185#define IPPROTO_UDP     17      /* User Datagram Protocol               */
 186
 187/*
 188 *      Internet Protocol (IP) header.
 189 */
 190typedef struct {
 191        uchar           ip_hl_v;        /* header length and version    */
 192        uchar           ip_tos;         /* type of service              */
 193        ushort          ip_len;         /* total length                 */
 194        ushort          ip_id;          /* identification               */
 195        ushort          ip_off;         /* fragment offset field        */
 196        uchar           ip_ttl;         /* time to live                 */
 197        uchar           ip_p;           /* protocol                     */
 198        ushort          ip_sum;         /* checksum                     */
 199        IPaddr_t        ip_src;         /* Source IP address            */
 200        IPaddr_t        ip_dst;         /* Destination IP address       */
 201        ushort          udp_src;        /* UDP source port              */
 202        ushort          udp_dst;        /* UDP destination port         */
 203        ushort          udp_len;        /* Length of UDP packet         */
 204        ushort          udp_xsum;       /* Checksum                     */
 205} IP_t;
 206
 207#define IP_OFFS         0x1fff /* ip offset *= 8 */
 208#define IP_FLAGS        0xe000 /* first 3 bits */
 209#define IP_FLAGS_RES    0x8000 /* reserved */
 210#define IP_FLAGS_DFRAG  0x4000 /* don't fragments */
 211#define IP_FLAGS_MFRAG  0x2000 /* more fragments */
 212
 213#define IP_HDR_SIZE_NO_UDP      (sizeof (IP_t) - 8)
 214#define IP_HDR_SIZE             (sizeof (IP_t))
 215
 216
 217/*
 218 *      Address Resolution Protocol (ARP) header.
 219 */
 220typedef struct
 221{
 222        ushort          ar_hrd;         /* Format of hardware address   */
 223#   define ARP_ETHER        1           /* Ethernet  hardware address   */
 224        ushort          ar_pro;         /* Format of protocol address   */
 225        uchar           ar_hln;         /* Length of hardware address   */
 226        uchar           ar_pln;         /* Length of protocol address   */
 227        ushort          ar_op;          /* Operation                    */
 228#   define ARPOP_REQUEST    1           /* Request  to resolve  address */
 229#   define ARPOP_REPLY      2           /* Response to previous request */
 230
 231#   define RARPOP_REQUEST   3           /* Request  to resolve  address */
 232#   define RARPOP_REPLY     4           /* Response to previous request */
 233
 234        /*
 235         * The remaining fields are variable in size, according to
 236         * the sizes above, and are defined as appropriate for
 237         * specific hardware/protocol combinations.
 238         */
 239        uchar           ar_data[0];
 240#if 0
 241        uchar           ar_sha[];       /* Sender hardware address      */
 242        uchar           ar_spa[];       /* Sender protocol address      */
 243        uchar           ar_tha[];       /* Target hardware address      */
 244        uchar           ar_tpa[];       /* Target protocol address      */
 245#endif /* 0 */
 246} ARP_t;
 247
 248#define ARP_HDR_SIZE    (8+20)          /* Size assuming ethernet       */
 249
 250/*
 251 * ICMP stuff (just enough to handle (host) redirect messages)
 252 */
 253#define ICMP_ECHO_REPLY         0       /* Echo reply                   */
 254#define ICMP_REDIRECT           5       /* Redirect (change route)      */
 255#define ICMP_ECHO_REQUEST       8       /* Echo request                 */
 256
 257/* Codes for REDIRECT. */
 258#define ICMP_REDIR_NET          0       /* Redirect Net                 */
 259#define ICMP_REDIR_HOST         1       /* Redirect Host                */
 260
 261typedef struct icmphdr {
 262        uchar           type;
 263        uchar           code;
 264        ushort          checksum;
 265        union {
 266                struct {
 267                        ushort  id;
 268                        ushort  sequence;
 269                } echo;
 270                ulong   gateway;
 271                struct {
 272                        ushort  __unused;
 273                        ushort  mtu;
 274                } frag;
 275        } un;
 276} ICMP_t;
 277
 278
 279/*
 280 * Maximum packet size; used to allocate packet storage.
 281 * TFTP packets can be 524 bytes + IP header + ethernet header.
 282 * Lets be conservative, and go for 38 * 16.  (Must also be
 283 * a multiple of 32 bytes).
 284 */
 285/*
 286 * AS.HARNOIS : Better to set PKTSIZE to maximum size because
 287 * traffic type is not always controlled
 288 * maximum packet size =  1518
 289 * maximum packet size and multiple of 32 bytes =  1536
 290 */
 291#define PKTSIZE                 1518
 292#define PKTSIZE_ALIGN           1536
 293/*#define PKTSIZE               608*/
 294
 295/*
 296 * Maximum receive ring size; that is, the number of packets
 297 * we can buffer before overflow happens. Basically, this just
 298 * needs to be enough to prevent a packet being discarded while
 299 * we are processing the previous one.
 300 */
 301#define RINGSZ          4
 302#define RINGSZ_LOG2     2
 303
 304/**********************************************************************/
 305/*
 306 *      Globals.
 307 *
 308 * Note:
 309 *
 310 * All variables of type IPaddr_t are stored in NETWORK byte order
 311 * (big endian).
 312 */
 313
 314/* net.c */
 315/** BOOTP EXTENTIONS **/
 316extern IPaddr_t         NetOurGatewayIP;        /* Our gateway IP addresse      */
 317extern IPaddr_t         NetOurSubnetMask;       /* Our subnet mask (0 = unknown)*/
 318extern IPaddr_t         NetOurDNSIP;     /* Our Domain Name Server (0 = unknown)*/
 319#if defined(CONFIG_BOOTP_DNS2)
 320extern IPaddr_t         NetOurDNS2IP;    /* Our 2nd Domain Name Server (0 = unknown)*/
 321#endif
 322extern char             NetOurNISDomain[32];    /* Our NIS domain               */
 323extern char             NetOurHostName[32];     /* Our hostname                 */
 324extern char             NetOurRootPath[64];     /* Our root path                */
 325extern ushort           NetBootFileSize;        /* Our boot file size in blocks */
 326/** END OF BOOTP EXTENTIONS **/
 327extern ulong            NetBootFileXferSize;    /* size of bootfile in bytes    */
 328extern uchar            NetOurEther[6];         /* Our ethernet address         */
 329extern uchar            NetServerEther[6];      /* Boot server enet address     */
 330extern IPaddr_t         NetOurIP;               /* Our    IP addr (0 = unknown) */
 331extern IPaddr_t         NetServerIP;            /* Server IP addr (0 = unknown) */
 332extern volatile uchar * NetTxPacket;            /* THE transmit packet          */
 333extern volatile uchar * NetRxPackets[PKTBUFSRX];/* Receive packets              */
 334extern volatile uchar * NetRxPacket;            /* Current receive packet       */
 335extern int              NetRxPacketLen;         /* Current rx packet length     */
 336extern unsigned         NetIPID;                /* IP ID (counting)             */
 337extern uchar            NetBcastAddr[6];        /* Ethernet boardcast address   */
 338extern uchar            NetEtherNullAddr[6];
 339
 340#define VLAN_NONE       4095                    /* untagged                     */
 341#define VLAN_IDMASK     0x0fff                  /* mask of valid vlan id        */
 342extern ushort           NetOurVLAN;             /* Our VLAN                     */
 343extern ushort           NetOurNativeVLAN;       /* Our Native VLAN              */
 344
 345extern uchar            NetCDPAddr[6];          /* Ethernet CDP address         */
 346extern ushort           CDPNativeVLAN;          /* CDP returned native VLAN     */
 347extern ushort           CDPApplianceVLAN;       /* CDP returned appliance VLAN  */
 348
 349extern int              NetState;               /* Network loop state           */
 350#define NETLOOP_CONTINUE        1
 351#define NETLOOP_RESTART         2
 352#define NETLOOP_SUCCESS         3
 353#define NETLOOP_FAIL            4
 354
 355#ifdef CONFIG_NET_MULTI
 356extern int              NetRestartWrap;         /* Tried all network devices    */
 357#endif
 358
 359typedef enum { BOOTP, RARP, ARP, TFTP, DHCP, PING, DNS, NFS, CDP, NETCONS, SNTP } proto_t;
 360
 361/* from net/net.c */
 362extern char     BootFile[128];                  /* Boot File name               */
 363
 364#if defined(CONFIG_CMD_DNS)
 365extern char *NetDNSResolve;             /* The host to resolve  */
 366extern char *NetDNSenvvar;              /* the env var to put the ip into */
 367#endif
 368
 369#if defined(CONFIG_CMD_PING)
 370extern IPaddr_t NetPingIP;                      /* the ip address to ping               */
 371#endif
 372
 373#if defined(CONFIG_CMD_CDP)
 374/* when CDP completes these hold the return values */
 375extern ushort CDPNativeVLAN;
 376extern ushort CDPApplianceVLAN;
 377#endif
 378
 379#if defined(CONFIG_CMD_SNTP)
 380extern IPaddr_t NetNtpServerIP;                 /* the ip address to NTP        */
 381extern int NetTimeOffset;                       /* offset time from UTC         */
 382#endif
 383
 384/* Initialize the network adapter */
 385extern int      NetLoop(proto_t);
 386
 387/* Shutdown adapters and cleanup */
 388extern void     NetStop(void);
 389
 390/* Load failed.  Start again. */
 391extern void     NetStartAgain(void);
 392
 393/* Get size of the ethernet header when we send */
 394extern int      NetEthHdrSize(void);
 395
 396/* Set ethernet header; returns the size of the header */
 397extern int      NetSetEther(volatile uchar *, uchar *, uint);
 398
 399/* Set IP header */
 400extern void     NetSetIP(volatile uchar *, IPaddr_t, int, int, int);
 401
 402/* Checksum */
 403extern int      NetCksumOk(uchar *, int);       /* Return true if cksum OK      */
 404extern uint     NetCksum(uchar *, int);         /* Calculate the checksum       */
 405
 406/* Set callbacks */
 407extern void     NetSetHandler(rxhand_f *);      /* Set RX packet handler        */
 408extern void     NetSetTimeout(ulong, thand_f *);/* Set timeout handler          */
 409
 410/* Transmit "NetTxPacket" */
 411extern void     NetSendPacket(volatile uchar *, int);
 412
 413/* Transmit UDP packet, performing ARP request if needed */
 414extern int      NetSendUDPPacket(uchar *ether, IPaddr_t dest, int dport, int sport, int len);
 415
 416/* Processes a received packet */
 417extern void     NetReceive(volatile uchar *, int);
 418
 419/*
 420 * The following functions are a bit ugly, but necessary to deal with
 421 * alignment restrictions on ARM.
 422 *
 423 * We're using inline functions, which had the smallest memory
 424 * footprint in our tests.
 425 */
 426/* return IP *in network byteorder* */
 427static inline IPaddr_t NetReadIP(volatile void *from)
 428{
 429        IPaddr_t ip;
 430        memcpy((void*)&ip, (void*)from, sizeof(ip));
 431        return ip;
 432}
 433
 434/* return ulong *in network byteorder* */
 435static inline ulong NetReadLong(ulong *from)
 436{
 437        ulong l;
 438        memcpy((void*)&l, (void*)from, sizeof(l));
 439        return l;
 440}
 441
 442/* write IP *in network byteorder* */
 443static inline void NetWriteIP(void *to, IPaddr_t ip)
 444{
 445        memcpy(to, (void*)&ip, sizeof(ip));
 446}
 447
 448/* copy IP */
 449static inline void NetCopyIP(volatile void *to, void *from)
 450{
 451        memcpy((void*)to, from, sizeof(IPaddr_t));
 452}
 453
 454/* copy ulong */
 455static inline void NetCopyLong(ulong *to, ulong *from)
 456{
 457        memcpy((void*)to, (void*)from, sizeof(ulong));
 458}
 459
 460/**
 461 * is_zero_ether_addr - Determine if give Ethernet address is all zeros.
 462 * @addr: Pointer to a six-byte array containing the Ethernet address
 463 *
 464 * Return true if the address is all zeroes.
 465 */
 466static inline int is_zero_ether_addr(const u8 *addr)
 467{
 468        return !(addr[0] | addr[1] | addr[2] | addr[3] | addr[4] | addr[5]);
 469}
 470
 471/**
 472 * is_multicast_ether_addr - Determine if the Ethernet address is a multicast.
 473 * @addr: Pointer to a six-byte array containing the Ethernet address
 474 *
 475 * Return true if the address is a multicast address.
 476 * By definition the broadcast address is also a multicast address.
 477 */
 478static inline int is_multicast_ether_addr(const u8 *addr)
 479{
 480        return (0x01 & addr[0]);
 481}
 482
 483/**
 484 * is_valid_ether_addr - Determine if the given Ethernet address is valid
 485 * @addr: Pointer to a six-byte array containing the Ethernet address
 486 *
 487 * Check that the Ethernet address (MAC) is not 00:00:00:00:00:00, is not
 488 * a multicast address, and is not FF:FF:FF:FF:FF:FF.
 489 *
 490 * Return true if the address is valid.
 491 */
 492static inline int is_valid_ether_addr(const u8 * addr)
 493{
 494        /* FF:FF:FF:FF:FF:FF is a multicast address so we don't need to
 495         * explicitly check for it here. */
 496        return !is_multicast_ether_addr(addr) && !is_zero_ether_addr(addr);
 497}
 498
 499/* Convert an IP address to a string */
 500extern void     ip_to_string (IPaddr_t x, char *s);
 501
 502/* Convert a string to ip address */
 503extern IPaddr_t string_to_ip(char *s);
 504
 505/* Convert a VLAN id to a string */
 506extern void     VLAN_to_string (ushort x, char *s);
 507
 508/* Convert a string to a vlan id */
 509extern ushort string_to_VLAN(char *s);
 510
 511/* read an IP address from a environment variable */
 512extern IPaddr_t getenv_IPaddr (char *);
 513
 514/* read a VLAN id from an environment variable */
 515extern ushort getenv_VLAN(char *);
 516
 517/* copy a filename (allow for "..." notation, limit length) */
 518extern void     copy_filename (char *dst, char *src, int size);
 519
 520/* get a random source port */
 521extern unsigned int random_port(void);
 522
 523/**********************************************************************/
 524
 525#endif /* __NET_H__ */
 526