开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
netdevice.h
资源名称：arm_cross-3.4.4.tar.gz　[点击查看]
上传用户：szlgq88
上传日期：2009-04-28
资源大小：48287k
文件大小：28k
源码类别：

嵌入式Linux

开发平台：

Unix_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
  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
  28. #include <linux/if.h>
  29. #include <linux/if_ether.h>
  30. #include <linux/if_packet.h>
  32. #ifdef __KERNEL__
  33. #include <asm/atomic.h>
  34. #include <asm/cache.h>
  35. #include <asm/byteorder.h>
  37. #include <linux/config.h>
  38. #include <linux/device.h>
  39. #include <linux/percpu.h>
  41. struct divert_blk;
  42. struct vlan_group;
  43. struct ethtool_ops;
  44. struct netpoll_info;
  45. /* source back-compat hooks */
  46. #define SET_ETHTOOL_OPS(netdev,ops) 
  47. ( (netdev)->ethtool_ops = (ops) )
  49. #define HAVE_ALLOC_NETDEV /* feature macro: alloc_xxxdev
  50.    functions are available. */
  51. #define HAVE_FREE_NETDEV /* free_netdev() */
  52. #define HAVE_NETDEV_PRIV /* netdev_priv() */
  54. #define NET_XMIT_SUCCESS 0
  55. #define NET_XMIT_DROP 1 /* skb dropped */
  56. #define NET_XMIT_CN 2 /* congestion notification */
  57. #define NET_XMIT_POLICED 3 /* skb is shot by police */
  58. #define NET_XMIT_BYPASS 4 /* packet does not leave via dequeue;
  59.    (TC use only - dev_queue_xmit
  60.    returns this as NET_XMIT_SUCCESS) */
  62. /* Backlog congestion levels */
  63. #define NET_RX_SUCCESS 0   /* keep 'em coming, baby */
  64. #define NET_RX_DROP 1  /* packet dropped */
  65. #define NET_RX_CN_LOW 2   /* storm alert, just in case */
  66. #define NET_RX_CN_MOD 3   /* Storm on its way! */
  67. #define NET_RX_CN_HIGH 4   /* The storm is here */
  68. #define NET_RX_BAD 5  /* packet dropped due to kernel error */
  70. #define net_xmit_errno(e) ((e) != NET_XMIT_CN ? -ENOBUFS : 0)
  72. #endif
  74. #define MAX_ADDR_LEN 32 /* Largest hardware address length */
  76. /* Driver transmit return codes */
  77. #define NETDEV_TX_OK 0 /* driver took care of packet */
  78. #define NETDEV_TX_BUSY 1 /* driver tx path was busy*/
  79. #define NETDEV_TX_LOCKED -1 /* driver tx lock was already taken */
  81. /*
  82.  * Compute the worst case header length according to the protocols
  83.  * used.
  84.  */
  85.  
  86. #if !defined(CONFIG_AX25) && !defined(CONFIG_AX25_MODULE) && !defined(CONFIG_TR)
  87. #define LL_MAX_HEADER 32
  88. #else
  89. #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
  90. #define LL_MAX_HEADER 96
  91. #else
  92. #define LL_MAX_HEADER 48
  93. #endif
  94. #endif
  96. #if !defined(CONFIG_NET_IPIP) && 
  97.     !defined(CONFIG_IPV6) && !defined(CONFIG_IPV6_MODULE)
  98. #define MAX_HEADER LL_MAX_HEADER
  99. #else
  100. #define MAX_HEADER (LL_MAX_HEADER + 48)
  101. #endif
  103. /*
  104.  * Network device statistics. Akin to the 2.0 ether stats but
  105.  * with byte counters.
  106.  */
  107.  
  108. struct net_device_stats
  109. {
  110. unsigned long rx_packets; /* total packets received */
  111. unsigned long tx_packets; /* total packets transmitted */
  112. unsigned long rx_bytes; /* total bytes received  */
  113. unsigned long tx_bytes; /* total bytes transmitted */
  114. unsigned long rx_errors; /* bad packets received */
  115. unsigned long tx_errors; /* packet transmit problems */
  116. unsigned long rx_dropped; /* no space in linux buffers */
  117. unsigned long tx_dropped; /* no space available in linux */
  118. unsigned long multicast; /* multicast packets received */
  119. unsigned long collisions;
  121. /* detailed rx_errors: */
  122. unsigned long rx_length_errors;
  123. unsigned long rx_over_errors; /* receiver ring buff overflow */
  124. unsigned long rx_crc_errors; /* recved pkt with crc error */
  125. unsigned long rx_frame_errors; /* recv'd frame alignment error */
  126. unsigned long rx_fifo_errors; /* recv'r fifo overrun */
  127. unsigned long rx_missed_errors; /* receiver missed packet */
  129. /* detailed tx_errors */
  130. unsigned long tx_aborted_errors;
  131. unsigned long tx_carrier_errors;
  132. unsigned long tx_fifo_errors;
  133. unsigned long tx_heartbeat_errors;
  134. unsigned long tx_window_errors;
  136. /* for cslip etc */
  137. unsigned long rx_compressed;
  138. unsigned long tx_compressed;
  139. };
  142. /* Media selection options. */
  143. enum {
  144.         IF_PORT_UNKNOWN = 0,
  145.         IF_PORT_10BASE2,
  146.         IF_PORT_10BASET,
  147.         IF_PORT_AUI,
  148.         IF_PORT_100BASET,
  149.         IF_PORT_100BASETX,
  150.         IF_PORT_100BASEFX
  151. };
  153. #ifdef __KERNEL__
  155. #include <linux/cache.h>
  156. #include <linux/skbuff.h>
  158. struct neighbour;
  159. struct neigh_parms;
  160. struct sk_buff;
  162. struct netif_rx_stats
  163. {
  164. unsigned total;
  165. unsigned dropped;
  166. unsigned time_squeeze;
  167. unsigned cpu_collision;
  168. };
  170. DECLARE_PER_CPU(struct netif_rx_stats, netdev_rx_stat);
  173. /*
  174.  * We tag multicasts with these structures.
  175.  */
  176.  
  177. struct dev_mc_list
  178. {
  179. struct dev_mc_list *next;
  180. __u8 dmi_addr[MAX_ADDR_LEN];
  181. unsigned char dmi_addrlen;
  182. int dmi_users;
  183. int dmi_gusers;
  184. };
  186. struct hh_cache
  187. {
  188. struct hh_cache *hh_next; /* Next entry      */
  189. atomic_t hh_refcnt; /* number of users                   */
  190. unsigned short  hh_type; /* protocol identifier, f.e ETH_P_IP
  191.                                          *  NOTE:  For VLANs, this will be the
  192.                                          *  encapuslated type. --BLG
  193.                                          */
  194. int hh_len; /* length of header */
  195. int (*hh_output)(struct sk_buff *skb);
  196. rwlock_t hh_lock;
  198. /* cached hardware header; allow for machine alignment needs.        */
  199. #define HH_DATA_MOD 16
  200. #define HH_DATA_OFF(__len) 
  201. (HH_DATA_MOD - (((__len - 1) & (HH_DATA_MOD - 1)) + 1))
  202. #define HH_DATA_ALIGN(__len) 
  203. (((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1))
  204. unsigned long hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)];
  205. };
  207. /* Reserve HH_DATA_MOD byte aligned hard_header_len, but at least that much.
  208.  * Alternative is:
  209.  *   dev->hard_header_len ? (dev->hard_header_len +
  210.  *                           (HH_DATA_MOD - 1)) & ~(HH_DATA_MOD - 1) : 0
  211.  *
  212.  * We could use other alignment values, but we must maintain the
  213.  * relationship HH alignment <= LL alignment.
  214.  */
  215. #define LL_RESERVED_SPACE(dev) 
  216. (((dev)->hard_header_len&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
  217. #define LL_RESERVED_SPACE_EXTRA(dev,extra) 
  218. ((((dev)->hard_header_len+extra)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
  220. /* These flag bits are private to the generic network queueing
  221.  * layer, they may not be explicitly referenced by any other
  222.  * code.
  223.  */
  225. enum netdev_state_t
  226. {
  227. __LINK_STATE_XOFF=0,
  228. __LINK_STATE_START,
  229. __LINK_STATE_PRESENT,
  230. __LINK_STATE_SCHED,
  231. __LINK_STATE_NOCARRIER,
  232. __LINK_STATE_RX_SCHED,
  233. __LINK_STATE_LINKWATCH_PENDING
  234. };
  237. /*
  238.  * This structure holds at boot time configured netdevice settings. They
  239.  * are then used in the device probing. 
  240.  */
  241. struct netdev_boot_setup {
  242. char name[IFNAMSIZ];
  243. struct ifmap map;
  244. };
  245. #define NETDEV_BOOT_SETUP_MAX 8
  247. extern int __init netdev_boot_setup(char *str);
  249. /*
  250.  * The DEVICE structure.
  251.  * Actually, this whole structure is a big mistake.  It mixes I/O
  252.  * data with strictly "high-level" data, and it has to know about
  253.  * almost every data structure used in the INET module.
  254.  *
  255.  * FIXME: cleanup struct net_device such that network protocol info
  256.  * moves out.
  257.  */
  259. struct net_device
  260. {
  262. /*
  263.  * This is the first field of the "visible" part of this structure
  264.  * (i.e. as seen by users in the "Space.c" file).  It is the name
  265.  * the interface.
  266.  */
  267. char name[IFNAMSIZ];
  268. /* device name hash chain */
  269. struct hlist_node name_hlist;
  271. /*
  272.  * I/O specific fields
  273.  * FIXME: Merge these and struct ifmap into one
  274.  */
  275. unsigned long mem_end; /* shared mem end */
  276. unsigned long mem_start; /* shared mem start */
  277. unsigned long base_addr; /* device I/O address */
  278. unsigned int irq; /* device IRQ number */
  280. /*
  281.  * Some hardware also needs these fields, but they are not
  282.  * part of the usual set specified in Space.c.
  283.  */
  285. unsigned char if_port; /* Selectable AUI, TP,..*/
  286. unsigned char dma; /* DMA channel */
  288. unsigned long state;
  290. struct net_device *next;
  292. /* The device initialization function. Called only once. */
  293. int (*init)(struct net_device *dev);
  295. /* ------- Fields preinitialized in Space.c finish here ------- */
  297. /* Net device features */
  298. unsigned long features;
  299. #define NETIF_F_SG 1 /* Scatter/gather IO. */
  300. #define NETIF_F_IP_CSUM 2 /* Can checksum only TCP/UDP over IPv4. */
  301. #define NETIF_F_NO_CSUM 4 /* Does not require checksum. F.e. loopack. */
  302. #define NETIF_F_HW_CSUM 8 /* Can checksum all the packets. */
  303. #define NETIF_F_HIGHDMA 32 /* Can DMA to high memory. */
  304. #define NETIF_F_FRAGLIST 64 /* Scatter/gather IO. */
  305. #define NETIF_F_HW_VLAN_TX 128 /* Transmit VLAN hw acceleration */
  306. #define NETIF_F_HW_VLAN_RX 256 /* Receive VLAN hw acceleration */
  307. #define NETIF_F_HW_VLAN_FILTER 512 /* Receive filtering on VLAN */
  308. #define NETIF_F_VLAN_CHALLENGED 1024 /* Device cannot handle VLAN packets */
  309. #define NETIF_F_TSO 2048 /* Can offload TCP/IP segmentation */
  310. #define NETIF_F_LLTX 4096 /* LockLess TX */
  312. struct net_device *next_sched;
  314. /* Interface index. Unique device identifier */
  315. int ifindex;
  316. int iflink;
  319. struct net_device_stats* (*get_stats)(struct net_device *dev);
  320. struct iw_statistics* (*get_wireless_stats)(struct net_device *dev);
  322. /* List of functions to handle Wireless Extensions (instead of ioctl).
  323.  * See <net/iw_handler.h> for details. Jean II */
  324. const struct iw_handler_def * wireless_handlers;
  325. /* Instance data managed by the core of Wireless Extensions. */
  326. struct iw_public_data * wireless_data;
  328. struct ethtool_ops *ethtool_ops;
  330. /*
  331.  * This marks the end of the "visible" part of the structure. All
  332.  * fields hereafter are internal to the system, and may change at
  333.  * will (read: may be cleaned up at will).
  334.  */
  337. unsigned short flags; /* interface flags (a la BSD) */
  338. unsigned short gflags;
  339.         unsigned short          priv_flags; /* Like 'flags' but invisible to userspace. */
  340. unsigned short padded; /* How much padding added by alloc_netdev() */
  342. unsigned mtu; /* interface MTU value */
  343. unsigned short type; /* interface hardware type */
  344. unsigned short hard_header_len; /* hardware hdr length */
  346. struct net_device *master; /* Pointer to master device of a group,
  347.   * which this device is member of.
  348.   */
  350. /* Interface address info. */
  351. unsigned char perm_addr[MAX_ADDR_LEN]; /* permanent hw address */
  352. unsigned char addr_len; /* hardware address length */
  353. unsigned short          dev_id; /* for shared network cards */
  355. struct dev_mc_list *mc_list; /* Multicast mac addresses */
  356. int mc_count; /* Number of installed mcasts */
  357. int promiscuity;
  358. int allmulti;
  361. /* Protocol specific pointers */
  363. void  *atalk_ptr; /* AppleTalk link  */
  364. void *ip_ptr; /* IPv4 specific data */  
  365. void                    *dn_ptr;        /* DECnet specific data */
  366. void                    *ip6_ptr;       /* IPv6 specific data */
  367. void *ec_ptr; /* Econet specific data */
  368. void *ax25_ptr; /* AX.25 specific data */
  370. /*
  371.  * Cache line mostly used on receive path (including eth_type_trans())
  372.  */
  373. struct list_head poll_list ____cacheline_aligned_in_smp;
  374. /* Link to poll list */
  376. int (*poll) (struct net_device *dev, int *quota);
  377. int quota;
  378. int weight;
  379. unsigned long last_rx; /* Time of last Rx */
  380. /* Interface address info used in eth_type_trans() */
  381. unsigned char dev_addr[MAX_ADDR_LEN]; /* hw address, (before bcast 
  382. because most packets are unicast) */
  384. unsigned char broadcast[MAX_ADDR_LEN]; /* hw bcast add */
  386. /*
  387.  * Cache line mostly used on queue transmit path (qdisc)
  388.  */
  389. /* device queue lock */
  390. spinlock_t queue_lock ____cacheline_aligned_in_smp;
  391. struct Qdisc *qdisc;
  392. struct Qdisc *qdisc_sleeping;
  393. struct list_head qdisc_list;
  394. unsigned long tx_queue_len; /* Max frames per queue allowed */
  396. /* ingress path synchronizer */
  397. spinlock_t ingress_lock;
  398. struct Qdisc *qdisc_ingress;
  400. /*
  401.  * One part is mostly used on xmit path (device)
  402.  */
  403. /* hard_start_xmit synchronizer */
  404. spinlock_t xmit_lock ____cacheline_aligned_in_smp;
  405. /* cpu id of processor entered to hard_start_xmit or -1,
  406.    if nobody entered there.
  407.  */
  408. int xmit_lock_owner;
  409. void *priv; /* pointer to private data */
  410. int (*hard_start_xmit) (struct sk_buff *skb,
  411.     struct net_device *dev);
  412. /* These may be needed for future network-power-down code. */
  413. unsigned long trans_start; /* Time (in jiffies) of last Tx */
  415. int watchdog_timeo; /* used by dev_watchdog() */
  416. struct timer_list watchdog_timer;
  418. /*
  419.  * refcnt is a very hot point, so align it on SMP
  420.  */
  421. /* Number of references to this device */
  422. atomic_t refcnt ____cacheline_aligned_in_smp;
  424. /* delayed register/unregister */
  425. struct list_head todo_list;
  426. /* device index hash chain */
  427. struct hlist_node index_hlist;
  429. /* register/unregister state machine */
  430. enum { NETREG_UNINITIALIZED=0,
  431.        NETREG_REGISTERING, /* called register_netdevice */
  432.        NETREG_REGISTERED, /* completed register todo */
  433.        NETREG_UNREGISTERING, /* called unregister_netdevice */
  434.        NETREG_UNREGISTERED, /* completed unregister todo */
  435.        NETREG_RELEASED, /* called free_netdev */
  436. } reg_state;
  438. /* Called after device is detached from network. */
  439. void (*uninit)(struct net_device *dev);
  440. /* Called after last user reference disappears. */
  441. void (*destructor)(struct net_device *dev);
  443. /* Pointers to interface service routines. */
  444. int (*open)(struct net_device *dev);
  445. int (*stop)(struct net_device *dev);
  446. #define HAVE_NETDEV_POLL
  447. int (*hard_header) (struct sk_buff *skb,
  448. struct net_device *dev,
  449. unsigned short type,
  450. void *daddr,
  451. void *saddr,
  452. unsigned len);
  453. int (*rebuild_header)(struct sk_buff *skb);
  454. #define HAVE_MULTICAST  
  455. void (*set_multicast_list)(struct net_device *dev);
  456. #define HAVE_SET_MAC_ADDR    
  457. int (*set_mac_address)(struct net_device *dev,
  458.    void *addr);
  459. #define HAVE_PRIVATE_IOCTL
  460. int (*do_ioctl)(struct net_device *dev,
  461.     struct ifreq *ifr, int cmd);
  462. #define HAVE_SET_CONFIG
  463. int (*set_config)(struct net_device *dev,
  464.       struct ifmap *map);
  465. #define HAVE_HEADER_CACHE
  466. int (*hard_header_cache)(struct neighbour *neigh,
  467.      struct hh_cache *hh);
  468. void (*header_cache_update)(struct hh_cache *hh,
  469.        struct net_device *dev,
  470.        unsigned char *  haddr);
  471. #define HAVE_CHANGE_MTU
  472. int (*change_mtu)(struct net_device *dev, int new_mtu);
  474. #define HAVE_TX_TIMEOUT
  475. void (*tx_timeout) (struct net_device *dev);
  477. void (*vlan_rx_register)(struct net_device *dev,
  478.     struct vlan_group *grp);
  479. void (*vlan_rx_add_vid)(struct net_device *dev,
  480.    unsigned short vid);
  481. void (*vlan_rx_kill_vid)(struct net_device *dev,
  482.     unsigned short vid);
  484. int (*hard_header_parse)(struct sk_buff *skb,
  485.      unsigned char *haddr);
  486. int (*neigh_setup)(struct net_device *dev, struct neigh_parms *);
  487. #ifdef CONFIG_NETPOLL
  488. struct netpoll_info *npinfo;
  489. #endif
  490. #ifdef CONFIG_NET_POLL_CONTROLLER
  491. void                    (*poll_controller)(struct net_device *dev);
  492. #endif
  494. /* bridge stuff */
  495. struct net_bridge_port *br_port;
  497. #ifdef CONFIG_NET_DIVERT
  498. /* this will get initialized at each interface type init routine */
  499. struct divert_blk *divert;
  500. #endif /* CONFIG_NET_DIVERT */
  502. /* class/net/name entry */
  503. struct class_device class_dev;
  504. };
  506. #define NETDEV_ALIGN 32
  507. #define NETDEV_ALIGN_CONST (NETDEV_ALIGN - 1)
  509. static inline void *netdev_priv(struct net_device *dev)
  510. {
  511. return (char *)dev + ((sizeof(struct net_device)
  512. + NETDEV_ALIGN_CONST)
  513. & ~NETDEV_ALIGN_CONST);
  514. }
  516. #define SET_MODULE_OWNER(dev) do { } while (0)
  517. /* Set the sysfs physical device reference for the network logical device
  518.  * if set prior to registration will cause a symlink during initialization.
  519.  */
  520. #define SET_NETDEV_DEV(net, pdev) ((net)->class_dev.dev = (pdev))
  522. struct packet_type {
  523. __be16 type; /* This is really htons(ether_type). */
  524. struct net_device *dev; /* NULL is wildcarded here      */
  525. int (*func) (struct sk_buff *,
  526.  struct net_device *,
  527.  struct packet_type *,
  528.  struct net_device *);
  529. void *af_packet_priv;
  530. struct list_head list;
  531. };
  533. #include <linux/interrupt.h>
  534. #include <linux/notifier.h>
  536. extern struct net_device loopback_dev; /* The loopback */
  537. extern struct net_device *dev_base; /* All devices */
  538. extern rwlock_t dev_base_lock; /* Device list lock */
  540. extern int  netdev_boot_setup_check(struct net_device *dev);
  541. extern unsigned long netdev_boot_base(const char *prefix, int unit);
  542. extern struct net_device    *dev_getbyhwaddr(unsigned short type, char *hwaddr);
  543. extern struct net_device *dev_getfirstbyhwtype(unsigned short type);
  544. extern void dev_add_pack(struct packet_type *pt);
  545. extern void dev_remove_pack(struct packet_type *pt);
  546. extern void __dev_remove_pack(struct packet_type *pt);
  548. extern struct net_device *dev_get_by_flags(unsigned short flags,
  549.   unsigned short mask);
  550. extern struct net_device *dev_get_by_name(const char *name);
  551. extern struct net_device *__dev_get_by_name(const char *name);
  552. extern int dev_alloc_name(struct net_device *dev, const char *name);
  553. extern int dev_open(struct net_device *dev);
  554. extern int dev_close(struct net_device *dev);
  555. extern int dev_queue_xmit(struct sk_buff *skb);
  556. extern int register_netdevice(struct net_device *dev);
  557. extern int unregister_netdevice(struct net_device *dev);
  558. extern void free_netdev(struct net_device *dev);
  559. extern void synchronize_net(void);
  560. extern int  register_netdevice_notifier(struct notifier_block *nb);
  561. extern int unregister_netdevice_notifier(struct notifier_block *nb);
  562. extern int call_netdevice_notifiers(unsigned long val, void *v);
  563. extern struct net_device *dev_get_by_index(int ifindex);
  564. extern struct net_device *__dev_get_by_index(int ifindex);
  565. extern int dev_restart(struct net_device *dev);
  566. #ifdef CONFIG_NETPOLL_TRAP
  567. extern int netpoll_trap(void);
  568. #endif
  570. typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len);
  571. extern int register_gifconf(unsigned int family, gifconf_func_t * gifconf);
  572. static inline int unregister_gifconf(unsigned int family)
  573. {
  574. return register_gifconf(family, NULL);
  575. }
  577. /*
  578.  * Incoming packets are placed on per-cpu queues so that
  579.  * no locking is needed.
  580.  */
  582. struct softnet_data
  583. {
  584. struct net_device *output_queue;
  585. struct sk_buff_head input_pkt_queue;
  586. struct list_head poll_list;
  587. struct sk_buff *completion_queue;
  589. struct net_device backlog_dev; /* Sorry. 8) */
  590. };
  592. DECLARE_PER_CPU(struct softnet_data,softnet_data);
  594. #define HAVE_NETIF_QUEUE
  596. static inline void __netif_schedule(struct net_device *dev)
  597. {
  598. if (!test_and_set_bit(__LINK_STATE_SCHED, &dev->state)) {
  599. unsigned long flags;
  600. struct softnet_data *sd;
  602. local_irq_save(flags);
  603. sd = &__get_cpu_var(softnet_data);
  604. dev->next_sched = sd->output_queue;
  605. sd->output_queue = dev;
  606. raise_softirq_irqoff(NET_TX_SOFTIRQ);
  607. local_irq_restore(flags);
  608. }
  609. }
  611. static inline void netif_schedule(struct net_device *dev)
  612. {
  613. if (!test_bit(__LINK_STATE_XOFF, &dev->state))
  614. __netif_schedule(dev);
  615. }
  617. static inline void netif_start_queue(struct net_device *dev)
  618. {
  619. clear_bit(__LINK_STATE_XOFF, &dev->state);
  620. }
  622. static inline void netif_wake_queue(struct net_device *dev)
  623. {
  624. #ifdef CONFIG_NETPOLL_TRAP
  625. if (netpoll_trap())
  626. return;
  627. #endif
  628. if (test_and_clear_bit(__LINK_STATE_XOFF, &dev->state))
  629. __netif_schedule(dev);
  630. }
  632. static inline void netif_stop_queue(struct net_device *dev)
  633. {
  634. #ifdef CONFIG_NETPOLL_TRAP
  635. if (netpoll_trap())
  636. return;
  637. #endif
  638. set_bit(__LINK_STATE_XOFF, &dev->state);
  639. }
  641. static inline int netif_queue_stopped(const struct net_device *dev)
  642. {
  643. return test_bit(__LINK_STATE_XOFF, &dev->state);
  644. }
  646. static inline int netif_running(const struct net_device *dev)
  647. {
  648. return test_bit(__LINK_STATE_START, &dev->state);
  649. }
  652. /* Use this variant when it is known for sure that it
  653.  * is executing from interrupt context.
  654.  */
  655. static inline void dev_kfree_skb_irq(struct sk_buff *skb)
  656. {
  657. if (atomic_dec_and_test(&skb->users)) {
  658. struct softnet_data *sd;
  659. unsigned long flags;
  661. local_irq_save(flags);
  662. sd = &__get_cpu_var(softnet_data);
  663. skb->next = sd->completion_queue;
  664. sd->completion_queue = skb;
  665. raise_softirq_irqoff(NET_TX_SOFTIRQ);
  666. local_irq_restore(flags);
  667. }
  668. }
  670. /* Use this variant in places where it could be invoked
  671.  * either from interrupt or non-interrupt context.
  672.  */
  673. static inline void dev_kfree_skb_any(struct sk_buff *skb)
  674. {
  675. if (in_irq() || irqs_disabled())
  676. dev_kfree_skb_irq(skb);
  677. else
  678. dev_kfree_skb(skb);
  679. }
  681. #define HAVE_NETIF_RX 1
  682. extern int netif_rx(struct sk_buff *skb);
  683. extern int netif_rx_ni(struct sk_buff *skb);
  684. #define HAVE_NETIF_RECEIVE_SKB 1
  685. extern int netif_receive_skb(struct sk_buff *skb);
  686. extern int dev_ioctl(unsigned int cmd, void __user *);
  687. extern int dev_ethtool(struct ifreq *);
  688. extern unsigned dev_get_flags(const struct net_device *);
  689. extern int dev_change_flags(struct net_device *, unsigned);
  690. extern int dev_change_name(struct net_device *, char *);
  691. extern int dev_set_mtu(struct net_device *, int);
  692. extern int dev_set_mac_address(struct net_device *,
  693.     struct sockaddr *);
  694. extern void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev);
  696. extern void dev_init(void);
  698. extern int netdev_nit;
  699. extern int netdev_budget;
  701. /* Called by rtnetlink.c:rtnl_unlock() */
  702. extern void netdev_run_todo(void);
  704. static inline void dev_put(struct net_device *dev)
  705. {
  706. atomic_dec(&dev->refcnt);
  707. }
  709. #define __dev_put(dev) atomic_dec(&(dev)->refcnt)
  710. #define dev_hold(dev) atomic_inc(&(dev)->refcnt)
  712. /* Carrier loss detection, dial on demand. The functions netif_carrier_on
  713.  * and _off may be called from IRQ context, but it is caller
  714.  * who is responsible for serialization of these calls.
  715.  */
  717. extern void linkwatch_fire_event(struct net_device *dev);
  719. static inline int netif_carrier_ok(const struct net_device *dev)
  720. {
  721. return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
  722. }
  724. extern void __netdev_watchdog_up(struct net_device *dev);
  726. extern void netif_carrier_on(struct net_device *dev);
  728. extern void netif_carrier_off(struct net_device *dev);
  730. /* Hot-plugging. */
  731. static inline int netif_device_present(struct net_device *dev)
  732. {
  733. return test_bit(__LINK_STATE_PRESENT, &dev->state);
  734. }
  736. static inline void netif_device_detach(struct net_device *dev)
  737. {
  738. if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
  739.     netif_running(dev)) {
  740. netif_stop_queue(dev);
  741. }
  742. }
  744. static inline void netif_device_attach(struct net_device *dev)
  745. {
  746. if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
  747.     netif_running(dev)) {
  748. netif_wake_queue(dev);
  749.   __netdev_watchdog_up(dev);
  750. }
  751. }
  753. /*
  754.  * Network interface message level settings
  755.  */
  756. #define HAVE_NETIF_MSG 1
  758. enum {
  759. NETIF_MSG_DRV = 0x0001,
  760. NETIF_MSG_PROBE = 0x0002,
  761. NETIF_MSG_LINK = 0x0004,
  762. NETIF_MSG_TIMER = 0x0008,
  763. NETIF_MSG_IFDOWN = 0x0010,
  764. NETIF_MSG_IFUP = 0x0020,
  765. NETIF_MSG_RX_ERR = 0x0040,
  766. NETIF_MSG_TX_ERR = 0x0080,
  767. NETIF_MSG_TX_QUEUED = 0x0100,
  768. NETIF_MSG_INTR = 0x0200,
  769. NETIF_MSG_TX_DONE = 0x0400,
  770. NETIF_MSG_RX_STATUS = 0x0800,
  771. NETIF_MSG_PKTDATA = 0x1000,
  772. NETIF_MSG_HW = 0x2000,
  773. NETIF_MSG_WOL = 0x4000,
  774. };
  776. #define netif_msg_drv(p) ((p)->msg_enable & NETIF_MSG_DRV)
  777. #define netif_msg_probe(p) ((p)->msg_enable & NETIF_MSG_PROBE)
  778. #define netif_msg_link(p) ((p)->msg_enable & NETIF_MSG_LINK)
  779. #define netif_msg_timer(p) ((p)->msg_enable & NETIF_MSG_TIMER)
  780. #define netif_msg_ifdown(p) ((p)->msg_enable & NETIF_MSG_IFDOWN)
  781. #define netif_msg_ifup(p) ((p)->msg_enable & NETIF_MSG_IFUP)
  782. #define netif_msg_rx_err(p) ((p)->msg_enable & NETIF_MSG_RX_ERR)
  783. #define netif_msg_tx_err(p) ((p)->msg_enable & NETIF_MSG_TX_ERR)
  784. #define netif_msg_tx_queued(p) ((p)->msg_enable & NETIF_MSG_TX_QUEUED)
  785. #define netif_msg_intr(p) ((p)->msg_enable & NETIF_MSG_INTR)
  786. #define netif_msg_tx_done(p) ((p)->msg_enable & NETIF_MSG_TX_DONE)
  787. #define netif_msg_rx_status(p) ((p)->msg_enable & NETIF_MSG_RX_STATUS)
  788. #define netif_msg_pktdata(p) ((p)->msg_enable & NETIF_MSG_PKTDATA)
  789. #define netif_msg_hw(p) ((p)->msg_enable & NETIF_MSG_HW)
  790. #define netif_msg_wol(p) ((p)->msg_enable & NETIF_MSG_WOL)
  792. static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits)
  793. {
  794. /* use default */
  795. if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))
  796. return default_msg_enable_bits;
  797. if (debug_value == 0) /* no output */
  798. return 0;
  799. /* set low N bits */
  800. return (1 << debug_value) - 1;
  801. }
  803. /* Schedule rx intr now? */
  805. static inline int netif_rx_schedule_prep(struct net_device *dev)
  806. {
  807. return netif_running(dev) &&
  808. !test_and_set_bit(__LINK_STATE_RX_SCHED, &dev->state);
  809. }
  811. /* Add interface to tail of rx poll list. This assumes that _prep has
  812.  * already been called and returned 1.
  813.  */
  815. static inline void __netif_rx_schedule(struct net_device *dev)
  816. {
  817. unsigned long flags;
  819. local_irq_save(flags);
  820. dev_hold(dev);
  821. list_add_tail(&dev->poll_list, &__get_cpu_var(softnet_data).poll_list);
  822. if (dev->quota < 0)
  823. dev->quota += dev->weight;
  824. else
  825. dev->quota = dev->weight;
  826. __raise_softirq_irqoff(NET_RX_SOFTIRQ);
  827. local_irq_restore(flags);
  828. }
  830. /* Try to reschedule poll. Called by irq handler. */
  832. static inline void netif_rx_schedule(struct net_device *dev)
  833. {
  834. if (netif_rx_schedule_prep(dev))
  835. __netif_rx_schedule(dev);
  836. }
  838. /* Try to reschedule poll. Called by dev->poll() after netif_rx_complete().
  839.  * Do not inline this?
  840.  */
  841. static inline int netif_rx_reschedule(struct net_device *dev, int undo)
  842. {
  843. if (netif_rx_schedule_prep(dev)) {
  844. unsigned long flags;
  846. dev->quota += undo;
  848. local_irq_save(flags);
  849. list_add_tail(&dev->poll_list, &__get_cpu_var(softnet_data).poll_list);
  850. __raise_softirq_irqoff(NET_RX_SOFTIRQ);
  851. local_irq_restore(flags);
  852. return 1;
  853. }
  854. return 0;
  855. }
  857. /* Remove interface from poll list: it must be in the poll list
  858.  * on current cpu. This primitive is called by dev->poll(), when
  859.  * it completes the work. The device cannot be out of poll list at this
  860.  * moment, it is BUG().
  861.  */
  862. static inline void netif_rx_complete(struct net_device *dev)
  863. {
  864. unsigned long flags;
  866. local_irq_save(flags);
  867. BUG_ON(!test_bit(__LINK_STATE_RX_SCHED, &dev->state));
  868. list_del(&dev->poll_list);
  869. smp_mb__before_clear_bit();
  870. clear_bit(__LINK_STATE_RX_SCHED, &dev->state);
  871. local_irq_restore(flags);
  872. }
  874. static inline void netif_poll_disable(struct net_device *dev)
  875. {
  876. while (test_and_set_bit(__LINK_STATE_RX_SCHED, &dev->state)) {
  877. /* No hurry. */
  878. current->state = TASK_INTERRUPTIBLE;
  879. schedule_timeout(1);
  880. }
  881. }
  883. static inline void netif_poll_enable(struct net_device *dev)
  884. {
  885. clear_bit(__LINK_STATE_RX_SCHED, &dev->state);
  886. }
  888. /* same as netif_rx_complete, except that local_irq_save(flags)
  889.  * has already been issued
  890.  */
  891. static inline void __netif_rx_complete(struct net_device *dev)
  892. {
  893. BUG_ON(!test_bit(__LINK_STATE_RX_SCHED, &dev->state));
  894. list_del(&dev->poll_list);
  895. smp_mb__before_clear_bit();
  896. clear_bit(__LINK_STATE_RX_SCHED, &dev->state);
  897. }
  899. static inline void netif_tx_disable(struct net_device *dev)
  900. {
  901. spin_lock_bh(&dev->xmit_lock);
  902. netif_stop_queue(dev);
  903. spin_unlock_bh(&dev->xmit_lock);
  904. }
  906. /* These functions live elsewhere (drivers/net/net_init.c, but related) */
  908. extern void ether_setup(struct net_device *dev);
  910. /* Support for loadable net-drivers */
  911. extern struct net_device *alloc_netdev(int sizeof_priv, const char *name,
  912.        void (*setup)(struct net_device *));
  913. extern int register_netdev(struct net_device *dev);
  914. extern void unregister_netdev(struct net_device *dev);
  915. /* Functions used for multicast support */
  916. extern void dev_mc_upload(struct net_device *dev);
  917. extern int  dev_mc_delete(struct net_device *dev, void *addr, int alen, int all);
  918. extern int dev_mc_add(struct net_device *dev, void *addr, int alen, int newonly);
  919. extern void dev_mc_discard(struct net_device *dev);
  920. extern void dev_set_promiscuity(struct net_device *dev, int inc);
  921. extern void dev_set_allmulti(struct net_device *dev, int inc);
  922. extern void netdev_state_change(struct net_device *dev);
  923. extern void netdev_features_change(struct net_device *dev);
  924. /* Load a device via the kmod */
  925. extern void dev_load(const char *name);
  926. extern void dev_mcast_init(void);
  927. extern int netdev_max_backlog;
  928. extern int weight_p;
  929. extern int netdev_set_master(struct net_device *dev, struct net_device *master);
  930. extern int skb_checksum_help(struct sk_buff *skb, int inward);
  931. /* rx skb timestamps */
  932. extern void net_enable_timestamp(void);
  933. extern void net_disable_timestamp(void);
  935. #ifdef CONFIG_PROC_FS
  936. extern void *dev_seq_start(struct seq_file *seq, loff_t *pos);
  937. extern void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos);
  938. extern void dev_seq_stop(struct seq_file *seq, void *v);
  939. #endif
  941. extern void linkwatch_run_queue(void);
  943. #endif /* __KERNEL__ */
  945. #endif /* _LINUX_DEV_H */