[linux-2.6-block.git] / drivers / net / e1000 / e1000.h

/*******************************************************************************

  Intel PRO/1000 Linux driver
  Copyright(c) 1999 - 2006 Intel Corporation.

  This program is free software; you can redistribute it and/or modify it
  under the terms and conditions of the GNU General Public License,
  version 2, as published by the Free Software Foundation.

  This program is distributed in the hope it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  more details.

  You should have received a copy of the GNU General Public License along with
  this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.

  The full GNU General Public License is included in this distribution in
  the file called "COPYING".

  Contact Information:
  Linux NICS <linux.nics@intel.com>
  e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
  Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497

*******************************************************************************/


/* Linux PRO/1000 Ethernet Driver main header file */

#ifndef _E1000_H_
#define _E1000_H_

#include <linux/stddef.h>
#include <linux/module.h>
#include <linux/types.h>
#include <asm/byteorder.h>
#include <linux/init.h>
#include <linux/mm.h>
#include <linux/errno.h>
#include <linux/ioport.h>
#include <linux/pci.h>
#include <linux/kernel.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.h>
#include <linux/delay.h>
#include <linux/timer.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/interrupt.h>
#include <linux/string.h>
#include <linux/pagemap.h>
#include <linux/dma-mapping.h>
#include <linux/bitops.h>
#include <asm/io.h>
#include <asm/irq.h>
#include <linux/capability.h>
#include <linux/in.h>
#include <linux/ip.h>
#include <linux/ipv6.h>
#include <linux/tcp.h>
#include <linux/udp.h>
#include <net/pkt_sched.h>
#include <linux/list.h>
#include <linux/reboot.h>
#include <net/checksum.h>
#include <linux/mii.h>
#include <linux/ethtool.h>
#include <linux/if_vlan.h>

#define BAR_0		0
#define BAR_1		1
#define BAR_5		5

#define INTEL_E1000_ETHERNET_DEVICE(device_id) {\
	PCI_DEVICE(PCI_VENDOR_ID_INTEL, device_id)}

struct e1000_adapter;

#include "e1000_hw.h"

#ifdef DBG
#define E1000_DBG(args...) printk(KERN_DEBUG "e1000: " args)
#else
#define E1000_DBG(args...)
#endif

#define E1000_ERR(args...) printk(KERN_ERR "e1000: " args)

#define PFX "e1000: "

#define DPRINTK(nlevel, klevel, fmt, args...)				\
do {									\
	if (NETIF_MSG_##nlevel & adapter->msg_enable)			\
		printk(KERN_##klevel PFX "%s: %s: " fmt,		\
		       adapter->netdev->name, __func__, ##args);	\
} while (0)

#define E1000_MAX_INTR 10

/* TX/RX descriptor defines */
#define E1000_DEFAULT_TXD                  256
#define E1000_MAX_TXD                      256
#define E1000_MIN_TXD                       80
#define E1000_MAX_82544_TXD               4096

#define E1000_DEFAULT_RXD                  256
#define E1000_MAX_RXD                      256
#define E1000_MIN_RXD                       80
#define E1000_MAX_82544_RXD               4096

/* this is the size past which hardware will drop packets when setting LPE=0 */
#define MAXIMUM_ETHERNET_VLAN_SIZE 1522

/* Supported Rx Buffer Sizes */
#define E1000_RXBUFFER_128   128    /* Used for packet split */
#define E1000_RXBUFFER_256   256    /* Used for packet split */
#define E1000_RXBUFFER_512   512
#define E1000_RXBUFFER_1024  1024
#define E1000_RXBUFFER_2048  2048
#define E1000_RXBUFFER_4096  4096
#define E1000_RXBUFFER_8192  8192
#define E1000_RXBUFFER_16384 16384

/* SmartSpeed delimiters */
#define E1000_SMARTSPEED_DOWNSHIFT 3
#define E1000_SMARTSPEED_MAX       15

/* Packet Buffer allocations */
#define E1000_PBA_BYTES_SHIFT 0xA
#define E1000_TX_HEAD_ADDR_SHIFT 7
#define E1000_PBA_TX_MASK 0xFFFF0000

/* Flow Control Watermarks */
#define E1000_FC_HIGH_DIFF 0x1638  /* High: 5688 bytes below Rx FIFO size */
#define E1000_FC_LOW_DIFF 0x1640   /* Low:  5696 bytes below Rx FIFO size */

#define E1000_FC_PAUSE_TIME 0x0680 /* 858 usec */

/* How many Tx Descriptors do we need to call netif_wake_queue ? */
#define E1000_TX_QUEUE_WAKE	16
/* How many Rx Buffers do we bundle into one write to the hardware ? */
#define E1000_RX_BUFFER_WRITE	16	/* Must be power of 2 */

#define AUTO_ALL_MODES            0
#define E1000_EEPROM_82544_APM    0x0004
#define E1000_EEPROM_ICH8_APME    0x0004
#define E1000_EEPROM_APME         0x0400

#ifndef E1000_MASTER_SLAVE
/* Switch to override PHY master/slave setting */
#define E1000_MASTER_SLAVE	e1000_ms_hw_default
#endif

#define E1000_MNG_VLAN_NONE (-1)

/* wrapper around a pointer to a socket buffer,
 * so a DMA handle can be stored along with the buffer */
struct e1000_buffer {
	struct sk_buff *skb;
	dma_addr_t dma;
	unsigned long time_stamp;
	u16 length;
	u16 next_to_watch;
};

struct e1000_tx_ring {
	/* pointer to the descriptor ring memory */
	void *desc;
	/* physical address of the descriptor ring */
	dma_addr_t dma;
	/* length of descriptor ring in bytes */
	unsigned int size;
	/* number of descriptors in the ring */
	unsigned int count;
	/* next descriptor to associate a buffer with */
	unsigned int next_to_use;
	/* next descriptor to check for DD status bit */
	unsigned int next_to_clean;
	/* array of buffer information structs */
	struct e1000_buffer *buffer_info;

	spinlock_t tx_lock;
	u16 tdh;
	u16 tdt;
	bool last_tx_tso;
};

struct e1000_rx_ring {
	/* pointer to the descriptor ring memory */
	void *desc;
	/* physical address of the descriptor ring */
	dma_addr_t dma;
	/* length of descriptor ring in bytes */
	unsigned int size;
	/* number of descriptors in the ring */
	unsigned int count;
	/* next descriptor to associate a buffer with */
	unsigned int next_to_use;
	/* next descriptor to check for DD status bit */
	unsigned int next_to_clean;
	/* array of buffer information structs */
	struct e1000_buffer *buffer_info;

	/* cpu for rx queue */
	int cpu;

	u16 rdh;
	u16 rdt;
};

#define E1000_DESC_UNUSED(R)						\
	((((R)->next_to_clean > (R)->next_to_use)			\
	  ? 0 : (R)->count) + (R)->next_to_clean - (R)->next_to_use - 1)

#define E1000_RX_DESC_EXT(R, i)						\
	(&(((union e1000_rx_desc_extended *)((R).desc))[i]))
#define E1000_GET_DESC(R, i, type)	(&(((struct type *)((R).desc))[i]))
#define E1000_RX_DESC(R, i)		E1000_GET_DESC(R, i, e1000_rx_desc)
#define E1000_TX_DESC(R, i)		E1000_GET_DESC(R, i, e1000_tx_desc)
#define E1000_CONTEXT_DESC(R, i)	E1000_GET_DESC(R, i, e1000_context_desc)

/* board specific private data structure */

struct e1000_adapter {
	struct timer_list tx_fifo_stall_timer;
	struct timer_list watchdog_timer;
	struct timer_list phy_info_timer;
	struct vlan_group *vlgrp;
	u16 mng_vlan_id;
	u32 bd_number;
	u32 rx_buffer_len;
	u32 wol;
	u32 smartspeed;
	u32 en_mng_pt;
	u16 link_speed;
	u16 link_duplex;
	spinlock_t stats_lock;
	spinlock_t tx_queue_lock;
	unsigned int total_tx_bytes;
	unsigned int total_tx_packets;
	unsigned int total_rx_bytes;
	unsigned int total_rx_packets;
	/* Interrupt Throttle Rate */
	u32 itr;
	u32 itr_setting;
	u16 tx_itr;
	u16 rx_itr;

	struct work_struct reset_task;
	u8 fc_autoneg;

	struct timer_list blink_timer;
	unsigned long led_status;

	/* TX */
	struct e1000_tx_ring *tx_ring;      /* One per active queue */
	unsigned int restart_queue;
	unsigned long tx_queue_len;
	u32 txd_cmd;
	u32 tx_int_delay;
	u32 tx_abs_int_delay;
	u32 gotcl;
	u64 gotcl_old;
	u64 tpt_old;
	u64 colc_old;
	u32 tx_timeout_count;
	u32 tx_fifo_head;
	u32 tx_head_addr;
	u32 tx_fifo_size;
	u8  tx_timeout_factor;
	atomic_t tx_fifo_stall;
	bool pcix_82544;
	bool detect_tx_hung;

	/* RX */
	bool (*clean_rx)(struct e1000_adapter *adapter,
			 struct e1000_rx_ring *rx_ring,
			 int *work_done, int work_to_do);
	void (*alloc_rx_buf)(struct e1000_adapter *adapter,
			     struct e1000_rx_ring *rx_ring,
			     int cleaned_count);
	struct e1000_rx_ring *rx_ring;      /* One per active queue */
	struct napi_struct napi;
	struct net_device *polling_netdev;  /* One per active queue */

	int num_tx_queues;
	int num_rx_queues;

	u64 hw_csum_err;
	u64 hw_csum_good;
	u64 rx_hdr_split;
	u32 alloc_rx_buff_failed;
	u32 rx_int_delay;
	u32 rx_abs_int_delay;
	bool rx_csum;
	u32 gorcl;
	u64 gorcl_old;

	/* OS defined structs */
	struct net_device *netdev;
	struct pci_dev *pdev;
	struct net_device_stats net_stats;

	/* structs defined in e1000_hw.h */
	struct e1000_hw hw;
	struct e1000_hw_stats stats;
	struct e1000_phy_info phy_info;
	struct e1000_phy_stats phy_stats;

	u32 test_icr;
	struct e1000_tx_ring test_tx_ring;
	struct e1000_rx_ring test_rx_ring;

	int msg_enable;
	bool have_msi;

	/* to not mess up cache alignment, always add to the bottom */
	bool tso_force;
	bool smart_power_down;	/* phy smart power down */
	bool quad_port_a;
	unsigned long flags;
	u32 eeprom_wol;

	/* for ioport free */
	int bars;
	int need_ioport;
};

enum e1000_state_t {
	__E1000_TESTING,
	__E1000_RESETTING,
	__E1000_DOWN
};

extern char e1000_driver_name[];
extern const char e1000_driver_version[];

extern int e1000_up(struct e1000_adapter *adapter);
extern void e1000_down(struct e1000_adapter *adapter);
extern void e1000_reinit_locked(struct e1000_adapter *adapter);
extern void e1000_reset(struct e1000_adapter *adapter);
extern int e1000_set_spd_dplx(struct e1000_adapter *adapter, u16 spddplx);
extern int e1000_setup_all_rx_resources(struct e1000_adapter *adapter);
extern int e1000_setup_all_tx_resources(struct e1000_adapter *adapter);
extern void e1000_free_all_rx_resources(struct e1000_adapter *adapter);
extern void e1000_free_all_tx_resources(struct e1000_adapter *adapter);
extern void e1000_update_stats(struct e1000_adapter *adapter);
extern void e1000_power_up_phy(struct e1000_adapter *);
extern void e1000_set_ethtool_ops(struct net_device *netdev);
extern void e1000_check_options(struct e1000_adapter *adapter);

#endif /* _E1000_H_ */
Commit	Line	Data
1da177e4 LT	1	/*******************************************************************************
1da177e4 LT	2
0abb6eb1 AK	3	Intel PRO/1000 Linux driver
	4	Copyright(c) 1999 - 2006 Intel Corporation.
	5
	6	This program is free software; you can redistribute it and/or modify it
	7	under the terms and conditions of the GNU General Public License,
	8	version 2, as published by the Free Software Foundation.
	9
	10	This program is distributed in the hope it will be useful, but WITHOUT
	11	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	12	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
1da177e4	13	more details.
0abb6eb1	14
1da177e4	15	You should have received a copy of the GNU General Public License along with
0abb6eb1 AK	16	this program; if not, write to the Free Software Foundation, Inc.,
	17	51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
	18
	19	The full GNU General Public License is included in this distribution in
	20	the file called "COPYING".
	21
1da177e4 LT	22	Contact Information:
1da177e4 LT	23	Linux NICS <linux.nics@intel.com>
3d41e30a	24	e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
1da177e4 LT	25	Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
	26
	27	*******************************************************************************/
	28
	29
	30	/* Linux PRO/1000 Ethernet Driver main header file */
	31
	32	#ifndef _E1000_H_
	33	#define _E1000_H_
	34
	35	#include <linux/stddef.h>
1da177e4 LT	36	#include <linux/module.h>
	37	#include <linux/types.h>
	38	#include <asm/byteorder.h>
	39	#include <linux/init.h>
	40	#include <linux/mm.h>
	41	#include <linux/errno.h>
	42	#include <linux/ioport.h>
	43	#include <linux/pci.h>
	44	#include <linux/kernel.h>
	45	#include <linux/netdevice.h>
	46	#include <linux/etherdevice.h>
	47	#include <linux/skbuff.h>
	48	#include <linux/delay.h>
	49	#include <linux/timer.h>
	50	#include <linux/slab.h>
	51	#include <linux/vmalloc.h>
	52	#include <linux/interrupt.h>
	53	#include <linux/string.h>
	54	#include <linux/pagemap.h>
	55	#include <linux/dma-mapping.h>
	56	#include <linux/bitops.h>
	57	#include <asm/io.h>
	58	#include <asm/irq.h>
	59	#include <linux/capability.h>
	60	#include <linux/in.h>
	61	#include <linux/ip.h>
87ca4e5b	62	#include <linux/ipv6.h>
1da177e4 LT	63	#include <linux/tcp.h>
	64	#include <linux/udp.h>
	65	#include <net/pkt_sched.h>
	66	#include <linux/list.h>
	67	#include <linux/reboot.h>
1da177e4	68	#include <net/checksum.h>
1da177e4 LT	69	#include <linux/mii.h>
	70	#include <linux/ethtool.h>
	71	#include <linux/if_vlan.h>
	72
	73	#define BAR_0 0
	74	#define BAR_1 1
	75	#define BAR_5 5
	76
	77	#define INTEL_E1000_ETHERNET_DEVICE(device_id) {\
	78	PCI_DEVICE(PCI_VENDOR_ID_INTEL, device_id)}
	79
	80	struct e1000_adapter;
	81
	82	#include "e1000_hw.h"
	83
	84	#ifdef DBG
	85	#define E1000_DBG(args...) printk(KERN_DEBUG "e1000: " args)
	86	#else
	87	#define E1000_DBG(args...)
	88	#endif
	89
	90	#define E1000_ERR(args...) printk(KERN_ERR "e1000: " args)
	91
	92	#define PFX "e1000: "
b1184020 JP	93
	94	#define DPRINTK(nlevel, klevel, fmt, args...) \
	95	do { \
	96	if (NETIF_MSG_##nlevel & adapter->msg_enable) \
	97	printk(KERN_##klevel PFX "%s: %s: " fmt, \
	98	adapter->netdev->name, __func__, ##args); \
	99	} while (0)
1da177e4 LT	100
	101	#define E1000_MAX_INTR 10
	102
	103	/* TX/RX descriptor defines */
	104	#define E1000_DEFAULT_TXD 256
	105	#define E1000_MAX_TXD 256
	106	#define E1000_MIN_TXD 80
	107	#define E1000_MAX_82544_TXD 4096
	108
	109	#define E1000_DEFAULT_RXD 256
	110	#define E1000_MAX_RXD 256
	111	#define E1000_MIN_RXD 80
	112	#define E1000_MAX_82544_RXD 4096
	113
eb0f8054 AK	114	/* this is the size past which hardware will drop packets when setting LPE=0 */
	115	#define MAXIMUM_ETHERNET_VLAN_SIZE 1522
	116
1da177e4	117	/* Supported Rx Buffer Sizes */
2d7edb92 MC	118	#define E1000_RXBUFFER_128 128 /* Used for packet split */
2d7edb92 MC	119	#define E1000_RXBUFFER_256 256 /* Used for packet split */
9e2feace AK	120	#define E1000_RXBUFFER_512 512
9e2feace AK	121	#define E1000_RXBUFFER_1024 1024
1da177e4 LT	122	#define E1000_RXBUFFER_2048 2048
	123	#define E1000_RXBUFFER_4096 4096
	124	#define E1000_RXBUFFER_8192 8192
	125	#define E1000_RXBUFFER_16384 16384
	126
	127	/* SmartSpeed delimiters */
	128	#define E1000_SMARTSPEED_DOWNSHIFT 3
	129	#define E1000_SMARTSPEED_MAX 15
	130
	131	/* Packet Buffer allocations */
	132	#define E1000_PBA_BYTES_SHIFT 0xA
	133	#define E1000_TX_HEAD_ADDR_SHIFT 7
	134	#define E1000_PBA_TX_MASK 0xFFFF0000
	135
	136	/* Flow Control Watermarks */
	137	#define E1000_FC_HIGH_DIFF 0x1638 /* High: 5688 bytes below Rx FIFO size */
	138	#define E1000_FC_LOW_DIFF 0x1640 /* Low: 5696 bytes below Rx FIFO size */
	139
	140	#define E1000_FC_PAUSE_TIME 0x0680 /* 858 usec */
	141
	142	/* How many Tx Descriptors do we need to call netif_wake_queue ? */
	143	#define E1000_TX_QUEUE_WAKE 16
	144	/* How many Rx Buffers do we bundle into one write to the hardware ? */
	145	#define E1000_RX_BUFFER_WRITE 16 /* Must be power of 2 */
	146
2648345f	147	#define AUTO_ALL_MODES 0
70cf362b	148	#define E1000_EEPROM_82544_APM 0x0004
cd94dd0b	149	#define E1000_EEPROM_ICH8_APME 0x0004
2648345f	150	#define E1000_EEPROM_APME 0x0400
1da177e4 LT	151
	152	#ifndef E1000_MASTER_SLAVE
	153	/* Switch to override PHY master/slave setting */
	154	#define E1000_MASTER_SLAVE e1000_ms_hw_default
	155	#endif
	156
b1184020	157	#define E1000_MNG_VLAN_NONE (-1)
2d7edb92	158
1da177e4 LT	159	/* wrapper around a pointer to a socket buffer,
	160	* so a DMA handle can be stored along with the buffer */
	161	struct e1000_buffer {
	162	struct sk_buff *skb;
c6963ef5	163	dma_addr_t dma;
1da177e4	164	unsigned long time_stamp;
406874a7 JP	165	u16 length;
406874a7 JP	166	u16 next_to_watch;
1da177e4 LT	167	};
1da177e4 LT	168
581d708e MC	169	struct e1000_tx_ring {
	170	/* pointer to the descriptor ring memory */
	171	void *desc;
	172	/* physical address of the descriptor ring */
	173	dma_addr_t dma;
	174	/* length of descriptor ring in bytes */
	175	unsigned int size;
	176	/* number of descriptors in the ring */
	177	unsigned int count;
	178	/* next descriptor to associate a buffer with */
	179	unsigned int next_to_use;
	180	/* next descriptor to check for DD status bit */
	181	unsigned int next_to_clean;
	182	/* array of buffer information structs */
	183	struct e1000_buffer *buffer_info;
	184
581d708e	185	spinlock_t tx_lock;
406874a7 JP	186	u16 tdh;
406874a7 JP	187	u16 tdt;
c3033b01	188	bool last_tx_tso;
581d708e MC	189	};
	190
	191	struct e1000_rx_ring {
1da177e4 LT	192	/* pointer to the descriptor ring memory */
	193	void *desc;
	194	/* physical address of the descriptor ring */
	195	dma_addr_t dma;
	196	/* length of descriptor ring in bytes */
	197	unsigned int size;
	198	/* number of descriptors in the ring */
	199	unsigned int count;
	200	/* next descriptor to associate a buffer with */
	201	unsigned int next_to_use;
	202	/* next descriptor to check for DD status bit */
	203	unsigned int next_to_clean;
	204	/* array of buffer information structs */
	205	struct e1000_buffer *buffer_info;
581d708e	206
545c67c0 JK	207	/* cpu for rx queue */
	208	int cpu;
	209
406874a7 JP	210	u16 rdh;
406874a7 JP	211	u16 rdt;
1da177e4 LT	212	};
1da177e4 LT	213
b1184020 JP	214	#define E1000_DESC_UNUSED(R) \
	215	((((R)->next_to_clean > (R)->next_to_use) \
	216	? 0 : (R)->count) + (R)->next_to_clean - (R)->next_to_use - 1)
1da177e4	217
b1184020	218	#define E1000_RX_DESC_EXT(R, i) \
2d7edb92	219	(&(((union e1000_rx_desc_extended *)((R).desc))[i]))
1da177e4 LT	220	#define E1000_GET_DESC(R, i, type) (&(((struct type *)((R).desc))[i]))
	221	#define E1000_RX_DESC(R, i) E1000_GET_DESC(R, i, e1000_rx_desc)
	222	#define E1000_TX_DESC(R, i) E1000_GET_DESC(R, i, e1000_tx_desc)
	223	#define E1000_CONTEXT_DESC(R, i) E1000_GET_DESC(R, i, e1000_context_desc)
	224
	225	/* board specific private data structure */
	226
	227	struct e1000_adapter {
	228	struct timer_list tx_fifo_stall_timer;
	229	struct timer_list watchdog_timer;
	230	struct timer_list phy_info_timer;
	231	struct vlan_group *vlgrp;
406874a7 JP	232	u16 mng_vlan_id;
	233	u32 bd_number;
	234	u32 rx_buffer_len;
	235	u32 wol;
	236	u32 smartspeed;
	237	u32 en_mng_pt;
	238	u16 link_speed;
	239	u16 link_duplex;
1da177e4	240	spinlock_t stats_lock;
7bfa4816	241	spinlock_t tx_queue_lock;
835bb129 JB	242	unsigned int total_tx_bytes;
	243	unsigned int total_tx_packets;
	244	unsigned int total_rx_bytes;
	245	unsigned int total_rx_packets;
	246	/* Interrupt Throttle Rate */
406874a7 JP	247	u32 itr;
	248	u32 itr_setting;
	249	u16 tx_itr;
	250	u16 rx_itr;
835bb129	251
87041639	252	struct work_struct reset_task;
406874a7	253	u8 fc_autoneg;
1da177e4 LT	254
	255	struct timer_list blink_timer;
	256	unsigned long led_status;
	257
	258	/* TX */
581d708e	259	struct e1000_tx_ring tx_ring; / One per active queue */
fcfb1224	260	unsigned int restart_queue;
f56799ea	261	unsigned long tx_queue_len;
406874a7 JP	262	u32 txd_cmd;
	263	u32 tx_int_delay;
	264	u32 tx_abs_int_delay;
	265	u32 gotcl;
	266	u64 gotcl_old;
	267	u64 tpt_old;
	268	u64 colc_old;
	269	u32 tx_timeout_count;
	270	u32 tx_fifo_head;
	271	u32 tx_head_addr;
	272	u32 tx_fifo_size;
	273	u8 tx_timeout_factor;
1da177e4	274	atomic_t tx_fifo_stall;
c3033b01 JP	275	bool pcix_82544;
c3033b01 JP	276	bool detect_tx_hung;
1da177e4 LT	277
1da177e4 LT	278	/* RX */
e982f17c JP	279	bool (clean_rx)(struct e1000_adapter adapter,
	280	struct e1000_rx_ring *rx_ring,
	281	int *work_done, int work_to_do);
e982f17c JP	282	void (alloc_rx_buf)(struct e1000_adapter adapter,
	283	struct e1000_rx_ring *rx_ring,
	284	int cleaned_count);
581d708e	285	struct e1000_rx_ring rx_ring; / One per active queue */
bea3348e	286	struct napi_struct napi;
581d708e	287	struct net_device polling_netdev; / One per active queue */
c3570acb	288
f56799ea JK	289	int num_tx_queues;
f56799ea JK	290	int num_rx_queues;
581d708e	291
406874a7 JP	292	u64 hw_csum_err;
	293	u64 hw_csum_good;
	294	u64 rx_hdr_split;
	295	u32 alloc_rx_buff_failed;
	296	u32 rx_int_delay;
	297	u32 rx_abs_int_delay;
c3033b01	298	bool rx_csum;
406874a7 JP	299	u32 gorcl;
406874a7 JP	300	u64 gorcl_old;
1da177e4	301
1da177e4 LT	302	/* OS defined structs */
	303	struct net_device *netdev;
	304	struct pci_dev *pdev;
	305	struct net_device_stats net_stats;
	306
	307	/* structs defined in e1000_hw.h */
	308	struct e1000_hw hw;
	309	struct e1000_hw_stats stats;
	310	struct e1000_phy_info phy_info;
	311	struct e1000_phy_stats phy_stats;
	312
406874a7	313	u32 test_icr;
581d708e MC	314	struct e1000_tx_ring test_tx_ring;
581d708e MC	315	struct e1000_rx_ring test_rx_ring;
1da177e4	316
1da177e4	317	int msg_enable;
c3033b01	318	bool have_msi;
e94bd23f	319
7e6c9861	320	/* to not mess up cache alignment, always add to the bottom */
c3033b01 JP	321	bool tso_force;
	322	bool smart_power_down; /* phy smart power down */
	323	bool quad_port_a;
2db10a08	324	unsigned long flags;
406874a7	325	u32 eeprom_wol;
81250297 TI	326
	327	/* for ioport free */
	328	int bars;
	329	int need_ioport;
1da177e4	330	};
30dcbf29	331
2db10a08	332	enum e1000_state_t {
1314bbf3	333	__E1000_TESTING,
2db10a08	334	__E1000_RESETTING,
1314bbf3	335	__E1000_DOWN
2db10a08	336	};
30dcbf29	337
abec42a4 SH	338	extern char e1000_driver_name[];
	339	extern const char e1000_driver_version[];
	340
c03e83b0 JP	341	extern int e1000_up(struct e1000_adapter *adapter);
	342	extern void e1000_down(struct e1000_adapter *adapter);
	343	extern void e1000_reinit_locked(struct e1000_adapter *adapter);
	344	extern void e1000_reset(struct e1000_adapter *adapter);
	345	extern int e1000_set_spd_dplx(struct e1000_adapter *adapter, u16 spddplx);
	346	extern int e1000_setup_all_rx_resources(struct e1000_adapter *adapter);
	347	extern int e1000_setup_all_tx_resources(struct e1000_adapter *adapter);
	348	extern void e1000_free_all_rx_resources(struct e1000_adapter *adapter);
	349	extern void e1000_free_all_tx_resources(struct e1000_adapter *adapter);
	350	extern void e1000_update_stats(struct e1000_adapter *adapter);
abec42a4 SH	351	extern void e1000_power_up_phy(struct e1000_adapter *);
	352	extern void e1000_set_ethtool_ops(struct net_device *netdev);
	353	extern void e1000_check_options(struct e1000_adapter *adapter);
	354
1da177e4	355	#endif /* _E1000_H_ */