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