v2.4.8 -> v2.4.8.1
[opensuse:kernel.git] / include / linux / netdevice.h
1 /*
2  * INET         An implementation of the TCP/IP protocol suite for the LINUX
3  *              operating system.  INET is implemented using the  BSD Socket
4  *              interface as the means of communication with the user level.
5  *
6  *              Definitions for the Interfaces handler.
7  *
8  * Version:     @(#)dev.h       1.0.10  08/12/93
9  *
10  * Authors:     Ross Biro, <bir7@leland.Stanford.Edu>
11  *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12  *              Corey Minyard <wf-rch!minyard@relay.EU.net>
13  *              Donald J. Becker, <becker@cesdis.gsfc.nasa.gov>
14  *              Alan Cox, <Alan.Cox@linux.org>
15  *              Bjorn Ekwall. <bj0rn@blox.se>
16  *              Pekka Riikonen <priikone@poseidon.pspt.fi>
17  *
18  *              This program is free software; you can redistribute it and/or
19  *              modify it under the terms of the GNU General Public License
20  *              as published by the Free Software Foundation; either version
21  *              2 of the License, or (at your option) any later version.
22  *
23  *              Moved to /usr/include/linux for NET3
24  */
25 #ifndef _LINUX_NETDEVICE_H
26 #define _LINUX_NETDEVICE_H
27
28 #include <linux/if.h>
29 #include <linux/if_ether.h>
30 #include <linux/if_packet.h>
31
32 #include <asm/atomic.h>
33 #include <asm/cache.h>
34 #include <asm/byteorder.h>
35
36 #ifdef __KERNEL__
37 #include <linux/config.h>
38 #ifdef CONFIG_NET_PROFILE
39 #include <net/profile.h>
40 #endif
41
42 struct divert_blk;
43
44 #define HAVE_ALLOC_NETDEV               /* feature macro: alloc_xxxdev
45                                            functions are available. */
46
47 #define NET_XMIT_SUCCESS        0
48 #define NET_XMIT_DROP           1       /* skb dropped                  */
49 #define NET_XMIT_CN             2       /* congestion notification      */
50 #define NET_XMIT_POLICED        3       /* skb is shot by police        */
51 #define NET_XMIT_BYPASS         4       /* packet does not leave via dequeue;
52                                            (TC use only - dev_queue_xmit
53                                            returns this as NET_XMIT_SUCCESS) */
54
55 /* Backlog congestion levels */
56 #define NET_RX_SUCCESS          0   /* keep 'em coming, baby */
57 #define NET_RX_DROP             1  /* packet dropped */
58 #define NET_RX_CN_LOW           2   /* storm alert, just in case */
59 #define NET_RX_CN_MOD           3   /* Storm on its way! */
60 #define NET_RX_CN_HIGH          4   /* The storm is here */
61 #define NET_RX_BAD              5  /* packet dropped due to kernel error */
62
63 #define net_xmit_errno(e)       ((e) != NET_XMIT_CN ? -ENOBUFS : 0)
64
65 #endif
66
67 #define MAX_ADDR_LEN    8               /* Largest hardware address length */
68
69 /*
70  *      Compute the worst case header length according to the protocols
71  *      used.
72  */
73  
74 #if !defined(CONFIG_AX25) && !defined(CONFIG_AX25_MODULE) && !defined(CONFIG_TR)
75 #define LL_MAX_HEADER   32
76 #else
77 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
78 #define LL_MAX_HEADER   96
79 #else
80 #define LL_MAX_HEADER   48
81 #endif
82 #endif
83
84 #if !defined(CONFIG_NET_IPIP) && \
85     !defined(CONFIG_IPV6) && !defined(CONFIG_IPV6_MODULE)
86 #define MAX_HEADER LL_MAX_HEADER
87 #else
88 #define MAX_HEADER (LL_MAX_HEADER + 48)
89 #endif
90
91 /*
92  *      Network device statistics. Akin to the 2.0 ether stats but
93  *      with byte counters.
94  */
95  
96 struct net_device_stats
97 {
98         unsigned long   rx_packets;             /* total packets received       */
99         unsigned long   tx_packets;             /* total packets transmitted    */
100         unsigned long   rx_bytes;               /* total bytes received         */
101         unsigned long   tx_bytes;               /* total bytes transmitted      */
102         unsigned long   rx_errors;              /* bad packets received         */
103         unsigned long   tx_errors;              /* packet transmit problems     */
104         unsigned long   rx_dropped;             /* no space in linux buffers    */
105         unsigned long   tx_dropped;             /* no space available in linux  */
106         unsigned long   multicast;              /* multicast packets received   */
107         unsigned long   collisions;
108
109         /* detailed rx_errors: */
110         unsigned long   rx_length_errors;
111         unsigned long   rx_over_errors;         /* receiver ring buff overflow  */
112         unsigned long   rx_crc_errors;          /* recved pkt with crc error    */
113         unsigned long   rx_frame_errors;        /* recv'd frame alignment error */
114         unsigned long   rx_fifo_errors;         /* recv'r fifo overrun          */
115         unsigned long   rx_missed_errors;       /* receiver missed packet       */
116
117         /* detailed tx_errors */
118         unsigned long   tx_aborted_errors;
119         unsigned long   tx_carrier_errors;
120         unsigned long   tx_fifo_errors;
121         unsigned long   tx_heartbeat_errors;
122         unsigned long   tx_window_errors;
123         
124         /* for cslip etc */
125         unsigned long   rx_compressed;
126         unsigned long   tx_compressed;
127 };
128
129
130 /* Media selection options. */
131 enum {
132         IF_PORT_UNKNOWN = 0,
133         IF_PORT_10BASE2,
134         IF_PORT_10BASET,
135         IF_PORT_AUI,
136         IF_PORT_100BASET,
137         IF_PORT_100BASETX,
138         IF_PORT_100BASEFX
139 };
140
141 #ifdef __KERNEL__
142
143 extern const char *if_port_text[];
144
145 #include <linux/cache.h>
146 #include <linux/skbuff.h>
147
148 struct neighbour;
149 struct neigh_parms;
150 struct sk_buff;
151
152 struct netif_rx_stats
153 {
154         unsigned total;
155         unsigned dropped;
156         unsigned time_squeeze;
157         unsigned throttled;
158         unsigned fastroute_hit;
159         unsigned fastroute_success;
160         unsigned fastroute_defer;
161         unsigned fastroute_deferred_out;
162         unsigned fastroute_latency_reduction;
163         unsigned cpu_collision;
164 } __attribute__ ((__aligned__(SMP_CACHE_BYTES)));
165
166 extern struct netif_rx_stats netdev_rx_stat[];
167
168
169 /*
170  *      We tag multicasts with these structures.
171  */
172  
173 struct dev_mc_list
174 {       
175         struct dev_mc_list      *next;
176         __u8                    dmi_addr[MAX_ADDR_LEN];
177         unsigned char           dmi_addrlen;
178         int                     dmi_users;
179         int                     dmi_gusers;
180 };
181
182 struct hh_cache
183 {
184         struct hh_cache *hh_next;       /* Next entry                        */
185         atomic_t        hh_refcnt;      /* number of users                   */
186         unsigned short  hh_type;        /* protocol identifier, f.e ETH_P_IP */
187         int             hh_len;         /* length of header */
188         int             (*hh_output)(struct sk_buff *skb);
189         rwlock_t        hh_lock;
190         /* cached hardware header; allow for machine alignment needs.        */
191         unsigned long   hh_data[16/sizeof(unsigned long)];
192 };
193
194 /* These flag bits are private to the generic network queueing
195  * layer, they may not be explicitly referenced by any other
196  * code.
197  */
198
199 enum netdev_state_t
200 {
201         __LINK_STATE_XOFF=0,
202         __LINK_STATE_START,
203         __LINK_STATE_PRESENT,
204         __LINK_STATE_SCHED,
205         __LINK_STATE_NOCARRIER
206 };
207
208
209 /*
210  * This structure holds at boot time configured netdevice settings. They
211  * are then used in the device probing. 
212  */
213 struct netdev_boot_setup {
214         char name[IFNAMSIZ];
215         struct ifmap map;
216 };
217 #define NETDEV_BOOT_SETUP_MAX 8
218
219
220 /*
221  *      The DEVICE structure.
222  *      Actually, this whole structure is a big mistake.  It mixes I/O
223  *      data with strictly "high-level" data, and it has to know about
224  *      almost every data structure used in the INET module.
225  *
226  *      FIXME: cleanup struct net_device such that network protocol info
227  *      moves out.
228  */
229
230 struct net_device
231 {
232
233         /*
234          * This is the first field of the "visible" part of this structure
235          * (i.e. as seen by users in the "Space.c" file).  It is the name
236          * the interface.
237          */
238         char                    name[IFNAMSIZ];
239
240         /*
241          *      I/O specific fields
242          *      FIXME: Merge these and struct ifmap into one
243          */
244         unsigned long           rmem_end;       /* shmem "recv" end     */
245         unsigned long           rmem_start;     /* shmem "recv" start   */
246         unsigned long           mem_end;        /* shared mem end       */
247         unsigned long           mem_start;      /* shared mem start     */
248         unsigned long           base_addr;      /* device I/O address   */
249         unsigned int            irq;            /* device IRQ number    */
250
251         /*
252          *      Some hardware also needs these fields, but they are not
253          *      part of the usual set specified in Space.c.
254          */
255
256         unsigned char           if_port;        /* Selectable AUI, TP,..*/
257         unsigned char           dma;            /* DMA channel          */
258
259         unsigned long           state;
260
261         struct net_device       *next;
262         
263         /* The device initialization function. Called only once. */
264         int                     (*init)(struct net_device *dev);
265
266         /* ------- Fields preinitialized in Space.c finish here ------- */
267
268         struct net_device       *next_sched;
269
270         /* Interface index. Unique device identifier    */
271         int                     ifindex;
272         int                     iflink;
273
274
275         struct net_device_stats* (*get_stats)(struct net_device *dev);
276         struct iw_statistics*   (*get_wireless_stats)(struct net_device *dev);
277
278         /*
279          * This marks the end of the "visible" part of the structure. All
280          * fields hereafter are internal to the system, and may change at
281          * will (read: may be cleaned up at will).
282          */
283
284         /* These may be needed for future network-power-down code. */
285         unsigned long           trans_start;    /* Time (in jiffies) of last Tx */
286         unsigned long           last_rx;        /* Time of last Rx      */
287
288         unsigned short          flags;  /* interface flags (a la BSD)   */
289         unsigned short          gflags;
290         unsigned                mtu;    /* interface MTU value          */
291         unsigned short          type;   /* interface hardware type      */
292         unsigned short          hard_header_len;        /* hardware hdr length  */
293         void                    *priv;  /* pointer to private data      */
294
295         struct net_device       *master; /* Pointer to master device of a group,
296                                           * which this device is member of.
297                                           */
298
299         /* Interface address info. */
300         unsigned char           broadcast[MAX_ADDR_LEN];        /* hw bcast add */
301         unsigned char           dev_addr[MAX_ADDR_LEN]; /* hw address   */
302         unsigned char           addr_len;       /* hardware address length      */
303
304         struct dev_mc_list      *mc_list;       /* Multicast mac addresses      */
305         int                     mc_count;       /* Number of installed mcasts   */
306         int                     promiscuity;
307         int                     allmulti;
308
309         int                     watchdog_timeo;
310         struct timer_list       watchdog_timer;
311
312         /* Protocol specific pointers */
313         
314         void                    *atalk_ptr;     /* AppleTalk link       */
315         void                    *ip_ptr;        /* IPv4 specific data   */  
316         void                    *dn_ptr;        /* DECnet specific data */
317         void                    *ip6_ptr;       /* IPv6 specific data */
318         void                    *ec_ptr;        /* Econet specific data */
319
320         struct Qdisc            *qdisc;
321         struct Qdisc            *qdisc_sleeping;
322         struct Qdisc            *qdisc_list;
323         struct Qdisc            *qdisc_ingress;
324         unsigned long           tx_queue_len;   /* Max frames per queue allowed */
325
326         /* hard_start_xmit synchronizer */
327         spinlock_t              xmit_lock;
328         /* cpu id of processor entered to hard_start_xmit or -1,
329            if nobody entered there.
330          */
331         int                     xmit_lock_owner;
332         /* device queue lock */
333         spinlock_t              queue_lock;
334         /* Number of references to this device */
335         atomic_t                refcnt;
336         /* The flag marking that device is unregistered, but held by an user */
337         int                     deadbeaf;
338
339         /* Net device features */
340         int                     features;
341 #define NETIF_F_SG              1       /* Scatter/gather IO. */
342 #define NETIF_F_IP_CSUM         2       /* Can checksum only TCP/UDP over IPv4. */
343 #define NETIF_F_NO_CSUM         4       /* Does not require checksum. F.e. loopack. */
344 #define NETIF_F_HW_CSUM         8       /* Can checksum all the packets. */
345 #define NETIF_F_DYNALLOC        16      /* Self-dectructable device. */
346 #define NETIF_F_HIGHDMA         32      /* Can DMA to high memory. */
347 #define NETIF_F_FRAGLIST        64      /* Scatter/gather IO. */
348
349         /* Called after device is detached from network. */
350         void                    (*uninit)(struct net_device *dev);
351         /* Called after last user reference disappears. */
352         void                    (*destructor)(struct net_device *dev);
353
354         /* Pointers to interface service routines.      */
355         int                     (*open)(struct net_device *dev);
356         int                     (*stop)(struct net_device *dev);
357         int                     (*hard_start_xmit) (struct sk_buff *skb,
358                                                     struct net_device *dev);
359         int                     (*hard_header) (struct sk_buff *skb,
360                                                 struct net_device *dev,
361                                                 unsigned short type,
362                                                 void *daddr,
363                                                 void *saddr,
364                                                 unsigned len);
365         int                     (*rebuild_header)(struct sk_buff *skb);
366 #define HAVE_MULTICAST                   
367         void                    (*set_multicast_list)(struct net_device *dev);
368 #define HAVE_SET_MAC_ADDR                
369         int                     (*set_mac_address)(struct net_device *dev,
370                                                    void *addr);
371 #define HAVE_PRIVATE_IOCTL
372         int                     (*do_ioctl)(struct net_device *dev,
373                                             struct ifreq *ifr, int cmd);
374 #define HAVE_SET_CONFIG
375         int                     (*set_config)(struct net_device *dev,
376                                               struct ifmap *map);
377 #define HAVE_HEADER_CACHE
378         int                     (*hard_header_cache)(struct neighbour *neigh,
379                                                      struct hh_cache *hh);
380         void                    (*header_cache_update)(struct hh_cache *hh,
381                                                        struct net_device *dev,
382                                                        unsigned char *  haddr);
383 #define HAVE_CHANGE_MTU
384         int                     (*change_mtu)(struct net_device *dev, int new_mtu);
385
386 #define HAVE_TX_TIMEOUT
387         void                    (*tx_timeout) (struct net_device *dev);
388
389         int                     (*hard_header_parse)(struct sk_buff *skb,
390                                                      unsigned char *haddr);
391         int                     (*neigh_setup)(struct net_device *dev, struct neigh_parms *);
392         int                     (*accept_fastpath)(struct net_device *, struct dst_entry*);
393
394         /* open/release and usage marking */
395         struct module *owner;
396
397         /* bridge stuff */
398         struct net_bridge_port  *br_port;
399
400 #ifdef CONFIG_NET_FASTROUTE
401 #define NETDEV_FASTROUTE_HMASK 0xF
402         /* Semi-private data. Keep it at the end of device struct. */
403         rwlock_t                fastpath_lock;
404         struct dst_entry        *fastpath[NETDEV_FASTROUTE_HMASK+1];
405 #endif
406 #ifdef CONFIG_NET_DIVERT
407         /* this will get initialized at each interface type init routine */
408         struct divert_blk       *divert;
409 #endif /* CONFIG_NET_DIVERT */
410 };
411
412
413 struct packet_type 
414 {
415         unsigned short          type;   /* This is really htons(ether_type).    */
416         struct net_device               *dev;   /* NULL is wildcarded here              */
417         int                     (*func) (struct sk_buff *, struct net_device *,
418                                          struct packet_type *);
419         void                    *data;  /* Private to the packet type           */
420         struct packet_type      *next;
421 };
422
423
424 #include <linux/interrupt.h>
425 #include <linux/notifier.h>
426
427 extern struct net_device                loopback_dev;           /* The loopback */
428 extern struct net_device                *dev_base;              /* All devices */
429 extern rwlock_t                         dev_base_lock;          /* Device list lock */
430
431 extern int                      netdev_boot_setup_add(char *name, struct ifmap *map);
432 extern int                      netdev_boot_setup_check(struct net_device *dev);
433 extern struct net_device    *dev_getbyhwaddr(unsigned short type, char *hwaddr);
434 extern void             dev_add_pack(struct packet_type *pt);
435 extern void             dev_remove_pack(struct packet_type *pt);
436 extern int              dev_get(const char *name);
437 extern struct net_device        *dev_get_by_name(const char *name);
438 extern struct net_device        *__dev_get_by_name(const char *name);
439 extern struct net_device        *dev_alloc(const char *name, int *err);
440 extern int              dev_alloc_name(struct net_device *dev, const char *name);
441 extern int              dev_open(struct net_device *dev);
442 extern int              dev_close(struct net_device *dev);
443 extern int              dev_queue_xmit(struct sk_buff *skb);
444 extern int              register_netdevice(struct net_device *dev);
445 extern int              unregister_netdevice(struct net_device *dev);
446 extern int              register_netdevice_notifier(struct notifier_block *nb);
447 extern int              unregister_netdevice_notifier(struct notifier_block *nb);
448 extern int              dev_new_index(void);
449 extern struct net_device        *dev_get_by_index(int ifindex);
450 extern struct net_device        *__dev_get_by_index(int ifindex);
451 extern int              dev_restart(struct net_device *dev);
452
453 typedef int gifconf_func_t(struct net_device * dev, char * bufptr, int len);
454 extern int              register_gifconf(unsigned int family, gifconf_func_t * gifconf);
455 static inline int unregister_gifconf(unsigned int family)
456 {
457         return register_gifconf(family, 0);
458 }
459
460 /*
461  * Incoming packets are placed on per-cpu queues so that
462  * no locking is needed.
463  */
464
465 struct softnet_data
466 {
467         int                     throttle;
468         int                     cng_level;
469         int                     avg_blog;
470         struct sk_buff_head     input_pkt_queue;
471         struct net_device       *output_queue;
472         struct sk_buff          *completion_queue;
473 } __attribute__((__aligned__(SMP_CACHE_BYTES)));
474
475
476 extern struct softnet_data softnet_data[NR_CPUS];
477
478 #define HAVE_NETIF_QUEUE
479
480 static inline void __netif_schedule(struct net_device *dev)
481 {
482         if (!test_and_set_bit(__LINK_STATE_SCHED, &dev->state)) {
483                 unsigned long flags;
484                 int cpu = smp_processor_id();
485
486                 local_irq_save(flags);
487                 dev->next_sched = softnet_data[cpu].output_queue;
488                 softnet_data[cpu].output_queue = dev;
489                 cpu_raise_softirq(cpu, NET_TX_SOFTIRQ);
490                 local_irq_restore(flags);
491         }
492 }
493
494 static inline void netif_schedule(struct net_device *dev)
495 {
496         if (!test_bit(__LINK_STATE_XOFF, &dev->state))
497                 __netif_schedule(dev);
498 }
499
500 static inline void netif_start_queue(struct net_device *dev)
501 {
502         clear_bit(__LINK_STATE_XOFF, &dev->state);
503 }
504
505 static inline void netif_wake_queue(struct net_device *dev)
506 {
507         if (test_and_clear_bit(__LINK_STATE_XOFF, &dev->state))
508                 __netif_schedule(dev);
509 }
510
511 static inline void netif_stop_queue(struct net_device *dev)
512 {
513         set_bit(__LINK_STATE_XOFF, &dev->state);
514 }
515
516 static inline int netif_queue_stopped(struct net_device *dev)
517 {
518         return test_bit(__LINK_STATE_XOFF, &dev->state);
519 }
520
521 static inline int netif_running(struct net_device *dev)
522 {
523         return test_bit(__LINK_STATE_START, &dev->state);
524 }
525
526 /* Use this variant when it is known for sure that it
527  * is executing from interrupt context.
528  */
529 static inline void dev_kfree_skb_irq(struct sk_buff *skb)
530 {
531         if (atomic_dec_and_test(&skb->users)) {
532                 int cpu =smp_processor_id();
533                 unsigned long flags;
534
535                 local_irq_save(flags);
536                 skb->next = softnet_data[cpu].completion_queue;
537                 softnet_data[cpu].completion_queue = skb;
538                 cpu_raise_softirq(cpu, NET_TX_SOFTIRQ);
539                 local_irq_restore(flags);
540         }
541 }
542
543 /* Use this variant in places where it could be invoked
544  * either from interrupt or non-interrupt context.
545  */
546 static inline void dev_kfree_skb_any(struct sk_buff *skb)
547 {
548         if (in_irq())
549                 dev_kfree_skb_irq(skb);
550         else
551                 dev_kfree_skb(skb);
552 }
553
554 extern void             net_call_rx_atomic(void (*fn)(void));
555 #define HAVE_NETIF_RX 1
556 extern int              netif_rx(struct sk_buff *skb);
557 extern int              dev_ioctl(unsigned int cmd, void *);
558 extern int              dev_change_flags(struct net_device *, unsigned);
559 extern void             dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev);
560
561 extern void             dev_init(void);
562
563 extern int              netdev_nit;
564
565 /* Post buffer to the network code from _non interrupt_ context.
566  * see net/core/dev.c for netif_rx description.
567  */
568 static inline int netif_rx_ni(struct sk_buff *skb)
569 {
570        int err = netif_rx(skb);
571        if (softirq_pending(smp_processor_id()))
572                do_softirq();
573        return err;
574 }
575
576 static inline void dev_init_buffers(struct net_device *dev)
577 {
578         /* WILL BE REMOVED IN 2.5.0 */
579 }
580
581 extern int netdev_finish_unregister(struct net_device *dev);
582
583 static inline void dev_put(struct net_device *dev)
584 {
585         if (atomic_dec_and_test(&dev->refcnt))
586                 netdev_finish_unregister(dev);
587 }
588
589 #define __dev_put(dev) atomic_dec(&(dev)->refcnt)
590 #define dev_hold(dev) atomic_inc(&(dev)->refcnt)
591
592 /* Carrier loss detection, dial on demand. The functions netif_carrier_on
593  * and _off may be called from IRQ context, but it is caller
594  * who is responsible for serialization of these calls.
595  */
596
597 static inline int netif_carrier_ok(struct net_device *dev)
598 {
599         return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
600 }
601
602 extern void __netdev_watchdog_up(struct net_device *dev);
603
604 static inline void netif_carrier_on(struct net_device *dev)
605 {
606         clear_bit(__LINK_STATE_NOCARRIER, &dev->state);
607         if (netif_running(dev))
608                 __netdev_watchdog_up(dev);
609 }
610
611 static inline void netif_carrier_off(struct net_device *dev)
612 {
613         set_bit(__LINK_STATE_NOCARRIER, &dev->state);
614 }
615
616 /* Hot-plugging. */
617 static inline int netif_device_present(struct net_device *dev)
618 {
619         return test_bit(__LINK_STATE_PRESENT, &dev->state);
620 }
621
622 static inline void netif_device_detach(struct net_device *dev)
623 {
624         if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
625             netif_running(dev)) {
626                 netif_stop_queue(dev);
627         }
628 }
629
630 static inline void netif_device_attach(struct net_device *dev)
631 {
632         if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
633             netif_running(dev)) {
634                 netif_wake_queue(dev);
635                 __netdev_watchdog_up(dev);
636         }
637 }
638
639 /* These functions live elsewhere (drivers/net/net_init.c, but related) */
640
641 extern void             ether_setup(struct net_device *dev);
642 extern void             fddi_setup(struct net_device *dev);
643 extern void             tr_setup(struct net_device *dev);
644 extern void             fc_setup(struct net_device *dev);
645 extern void             fc_freedev(struct net_device *dev);
646 /* Support for loadable net-drivers */
647 extern int              register_netdev(struct net_device *dev);
648 extern void             unregister_netdev(struct net_device *dev);
649 /* Functions used for multicast support */
650 extern void             dev_mc_upload(struct net_device *dev);
651 extern int              dev_mc_delete(struct net_device *dev, void *addr, int alen, int all);
652 extern int              dev_mc_add(struct net_device *dev, void *addr, int alen, int newonly);
653 extern void             dev_mc_discard(struct net_device *dev);
654 extern void             dev_set_promiscuity(struct net_device *dev, int inc);
655 extern void             dev_set_allmulti(struct net_device *dev, int inc);
656 extern void             netdev_state_change(struct net_device *dev);
657 /* Load a device via the kmod */
658 extern void             dev_load(const char *name);
659 extern void             dev_mcast_init(void);
660 extern int              netdev_register_fc(struct net_device *dev, void (*stimul)(struct net_device *dev));
661 extern void             netdev_unregister_fc(int bit);
662 extern int              netdev_max_backlog;
663 extern unsigned long    netdev_fc_xoff;
664 extern atomic_t netdev_dropping;
665 extern int              netdev_set_master(struct net_device *dev, struct net_device *master);
666 extern struct sk_buff * skb_checksum_help(struct sk_buff *skb);
667 #ifdef CONFIG_NET_FASTROUTE
668 extern int              netdev_fastroute;
669 extern int              netdev_fastroute_obstacles;
670 extern void             dev_clear_fastroute(struct net_device *dev);
671 #endif
672
673
674 #endif /* __KERNEL__ */
675
676 #endif  /* _LINUX_DEV_H */