[deliverable/linux.git] / drivers / net / ethernet / intel / 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/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"

#define E1000_MAX_INTR			10

/*
 * Count for polling __E1000_RESET condition every 10-20msec.
 */
#define E1000_CHECK_RESET_COUNT	50

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

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

#define E1000_MIN_ITR_USECS		10 /* 100000 irq/sec */
#define E1000_MAX_ITR_USECS		10000 /* 100    irq/sec */

/* 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	0xFFFF /* pause for the max or until send xon */

/* 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_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_tx_buffer {
	struct sk_buff *skb;
	dma_addr_t dma;
	unsigned long time_stamp;
	u16 length;
	u16 next_to_watch;
	bool mapped_as_page;
	unsigned short segs;
	unsigned int bytecount;
};

struct e1000_rx_buffer {
	union {
		struct page *page; /* jumbo: alloc_page */
		u8 *data; /* else, netdev_alloc_frag */
	} rxbuf;
	dma_addr_t dma;
};

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_tx_buffer *buffer_info;

	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_rx_buffer *buffer_info;
	struct sk_buff *rx_skb_top;

	/* cpu for rx queue */
	int cpu;

	u16 rdh;
	u16 rdt;
};

#define E1000_DESC_UNUSED(R)						\
({									\
	unsigned int clean = smp_load_acquire(&(R)->next_to_clean);	\
	unsigned int use = READ_ONCE((R)->next_to_use);			\
	(clean > use ? 0 : (R)->count) + clean - 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 {
	unsigned long active_vlans[BITS_TO_LONGS(VLAN_N_VID)];
	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;
	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;

	u8 fc_autoneg;

	/* TX */
	struct e1000_tx_ring *tx_ring;      /* One per active queue */
	unsigned int restart_queue;
	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;
	bool dump_buffers;

	/* 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;

	int num_tx_queues;
	int num_rx_queues;

	u64 hw_csum_err;
	u64 hw_csum_good;
	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;

	/* 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;

	/* 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;

	bool discarding;

	struct work_struct reset_task;
	struct delayed_work watchdog_task;
	struct delayed_work fifo_stall_task;
	struct delayed_work phy_info_task;
};

enum e1000_state_t {
	__E1000_TESTING,
	__E1000_RESETTING,
	__E1000_DOWN
};

#undef pr_fmt
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

struct net_device *e1000_get_hw_dev(struct e1000_hw *hw);
#define e_dbg(format, arg...) \
	netdev_dbg(e1000_get_hw_dev(hw), format, ## arg)
#define e_err(msglvl, format, arg...) \
	netif_err(adapter, msglvl, adapter->netdev, format, ## arg)
#define e_info(msglvl, format, arg...) \
	netif_info(adapter, msglvl, adapter->netdev, format, ## arg)
#define e_warn(msglvl, format, arg...) \
	netif_warn(adapter, msglvl, adapter->netdev, format, ## arg)
#define e_notice(msglvl, format, arg...) \
	netif_notice(adapter, msglvl, adapter->netdev, format, ## arg)
#define e_dev_info(format, arg...) \
	dev_info(&adapter->pdev->dev, format, ## arg)
#define e_dev_warn(format, arg...) \
	dev_warn(&adapter->pdev->dev, format, ## arg)
#define e_dev_err(format, arg...) \
	dev_err(&adapter->pdev->dev, format, ## arg)

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

int e1000_open(struct net_device *netdev);
int e1000_close(struct net_device *netdev);
int e1000_up(struct e1000_adapter *adapter);
void e1000_down(struct e1000_adapter *adapter);
void e1000_reinit_locked(struct e1000_adapter *adapter);
void e1000_reset(struct e1000_adapter *adapter);
int e1000_set_spd_dplx(struct e1000_adapter *adapter, u32 spd, u8 dplx);
int e1000_setup_all_rx_resources(struct e1000_adapter *adapter);
int e1000_setup_all_tx_resources(struct e1000_adapter *adapter);
void e1000_free_all_rx_resources(struct e1000_adapter *adapter);
void e1000_free_all_tx_resources(struct e1000_adapter *adapter);
void e1000_update_stats(struct e1000_adapter *adapter);
bool e1000_has_link(struct e1000_adapter *adapter);
void e1000_power_up_phy(struct e1000_adapter *);
void e1000_set_ethtool_ops(struct net_device *netdev);
void e1000_check_options(struct e1000_adapter *adapter);
char *e1000_get_hw_dev_name(struct e1000_hw *hw);

#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>
1da177e4 LT	39	#include <linux/mm.h>
	40	#include <linux/errno.h>
	41	#include <linux/ioport.h>
	42	#include <linux/pci.h>
	43	#include <linux/kernel.h>
	44	#include <linux/netdevice.h>
	45	#include <linux/etherdevice.h>
	46	#include <linux/skbuff.h>
	47	#include <linux/delay.h>
	48	#include <linux/timer.h>
	49	#include <linux/slab.h>
	50	#include <linux/vmalloc.h>
	51	#include <linux/interrupt.h>
	52	#include <linux/string.h>
	53	#include <linux/pagemap.h>
	54	#include <linux/dma-mapping.h>
	55	#include <linux/bitops.h>
	56	#include <asm/io.h>
	57	#include <asm/irq.h>
	58	#include <linux/capability.h>
	59	#include <linux/in.h>
	60	#include <linux/ip.h>
87ca4e5b	61	#include <linux/ipv6.h>
1da177e4 LT	62	#include <linux/tcp.h>
	63	#include <linux/udp.h>
	64	#include <net/pkt_sched.h>
	65	#include <linux/list.h>
	66	#include <linux/reboot.h>
1da177e4	67	#include <net/checksum.h>
1da177e4 LT	68	#include <linux/mii.h>
	69	#include <linux/ethtool.h>
	70	#include <linux/if_vlan.h>
	71
	72	#define BAR_0 0
	73	#define BAR_1 1
	74	#define BAR_5 5
	75
	76	#define INTEL_E1000_ETHERNET_DEVICE(device_id) {\
	77	PCI_DEVICE(PCI_VENDOR_ID_INTEL, device_id)}
	78
	79	struct e1000_adapter;
	80
	81	#include "e1000_hw.h"
	82
6cfbd97b	83	#define E1000_MAX_INTR 10
1da177e4	84
6a7d64e3	85	/*
	86	* Count for polling __E1000_RESET condition every 10-20msec.
	87	*/
	88	#define E1000_CHECK_RESET_COUNT 50
	89
1da177e4	90	/* TX/RX descriptor defines */
6cfbd97b JK	91	#define E1000_DEFAULT_TXD 256
	92	#define E1000_MAX_TXD 256
	93	#define E1000_MIN_TXD 48
	94	#define E1000_MAX_82544_TXD 4096
1da177e4	95
6cfbd97b JK	96	#define E1000_DEFAULT_RXD 256
	97	#define E1000_MAX_RXD 256
	98	#define E1000_MIN_RXD 48
	99	#define E1000_MAX_82544_RXD 4096
1da177e4	100
94c9e5a8 JB	101	#define E1000_MIN_ITR_USECS 10 /* 100000 irq/sec */
	102	#define E1000_MAX_ITR_USECS 10000 /* 100 irq/sec */
	103
eb0f8054	104	/* this is the size past which hardware will drop packets when setting LPE=0 */
6cfbd97b	105	#define MAXIMUM_ETHERNET_VLAN_SIZE 1522
eb0f8054	106
1da177e4	107	/* Supported Rx Buffer Sizes */
6cfbd97b JK	108	#define E1000_RXBUFFER_128 128 /* Used for packet split */
	109	#define E1000_RXBUFFER_256 256 /* Used for packet split */
	110	#define E1000_RXBUFFER_512 512
	111	#define E1000_RXBUFFER_1024 1024
	112	#define E1000_RXBUFFER_2048 2048
	113	#define E1000_RXBUFFER_4096 4096
	114	#define E1000_RXBUFFER_8192 8192
	115	#define E1000_RXBUFFER_16384 16384
1da177e4 LT	116
1da177e4 LT	117	/* SmartSpeed delimiters */
6cfbd97b JK	118	#define E1000_SMARTSPEED_DOWNSHIFT 3
6cfbd97b JK	119	#define E1000_SMARTSPEED_MAX 15
1da177e4 LT	120
1da177e4 LT	121	/* Packet Buffer allocations */
6cfbd97b JK	122	#define E1000_PBA_BYTES_SHIFT 0xA
	123	#define E1000_TX_HEAD_ADDR_SHIFT 7
	124	#define E1000_PBA_TX_MASK 0xFFFF0000
1da177e4 LT	125
1da177e4 LT	126	/* Flow Control Watermarks */
6cfbd97b JK	127	#define E1000_FC_HIGH_DIFF 0x1638 /* High: 5688 bytes below Rx FIFO size */
6cfbd97b JK	128	#define E1000_FC_LOW_DIFF 0x1640 /* Low: 5696 bytes below Rx FIFO size */
1da177e4	129
6cfbd97b	130	#define E1000_FC_PAUSE_TIME 0xFFFF /* pause for the max or until send xon */
1da177e4 LT	131
	132	/* How many Tx Descriptors do we need to call netif_wake_queue ? */
	133	#define E1000_TX_QUEUE_WAKE 16
	134	/* How many Rx Buffers do we bundle into one write to the hardware ? */
6cfbd97b	135	#define E1000_RX_BUFFER_WRITE 16 /* Must be power of 2 */
1da177e4	136
6cfbd97b JK	137	#define AUTO_ALL_MODES 0
	138	#define E1000_EEPROM_82544_APM 0x0004
	139	#define E1000_EEPROM_APME 0x0400
1da177e4 LT	140
	141	#ifndef E1000_MASTER_SLAVE
	142	/* Switch to override PHY master/slave setting */
	143	#define E1000_MASTER_SLAVE e1000_ms_hw_default
	144	#endif
	145
6cfbd97b	146	#define E1000_MNG_VLAN_NONE (-1)
2d7edb92	147
1da177e4	148	/* wrapper around a pointer to a socket buffer,
6cfbd97b JK	149	* so a DMA handle can be stored along with the buffer
6cfbd97b JK	150	*/
580f321d	151	struct e1000_tx_buffer {
1da177e4	152	struct sk_buff *skb;
c6963ef5	153	dma_addr_t dma;
1da177e4	154	unsigned long time_stamp;
406874a7 JP	155	u16 length;
406874a7 JP	156	u16 next_to_watch;
580f321d FW	157	bool mapped_as_page;
580f321d FW	158	unsigned short segs;
31c15a2f	159	unsigned int bytecount;
1da177e4 LT	160	};
1da177e4 LT	161
93f0afe9	162	struct e1000_rx_buffer {
13809609 FW	163	union {
	164	struct page page; / jumbo: alloc_page */
	165	u8 data; / else, netdev_alloc_frag */
	166	} rxbuf;
93f0afe9	167	dma_addr_t dma;
93f0afe9 FW	168	};
93f0afe9 FW	169
581d708e MC	170	struct e1000_tx_ring {
	171	/* pointer to the descriptor ring memory */
	172	void *desc;
	173	/* physical address of the descriptor ring */
	174	dma_addr_t dma;
	175	/* length of descriptor ring in bytes */
	176	unsigned int size;
	177	/* number of descriptors in the ring */
	178	unsigned int count;
	179	/* next descriptor to associate a buffer with */
	180	unsigned int next_to_use;
	181	/* next descriptor to check for DD status bit */
	182	unsigned int next_to_clean;
	183	/* array of buffer information structs */
580f321d	184	struct e1000_tx_buffer *buffer_info;
581d708e	185
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 */
93f0afe9	205	struct e1000_rx_buffer *buffer_info;
edbbb3ca	206	struct sk_buff *rx_skb_top;
581d708e	207
545c67c0 JK	208	/* cpu for rx queue */
	209	int cpu;
	210
406874a7 JP	211	u16 rdh;
406874a7 JP	212	u16 rdt;
1da177e4 LT	213	};
1da177e4 LT	214
b1184020	215	#define E1000_DESC_UNUSED(R) \
9eab46b7 DV	216	({ \
	217	unsigned int clean = smp_load_acquire(&(R)->next_to_clean); \
	218	unsigned int use = READ_ONCE((R)->next_to_use); \
	219	(clean > use ? 0 : (R)->count) + clean - use - 1; \
	220	})
1da177e4	221
b1184020	222	#define E1000_RX_DESC_EXT(R, i) \
2d7edb92	223	(&(((union e1000_rx_desc_extended *)((R).desc))[i]))
1da177e4 LT	224	#define E1000_GET_DESC(R, i, type) (&(((struct type *)((R).desc))[i]))
	225	#define E1000_RX_DESC(R, i) E1000_GET_DESC(R, i, e1000_rx_desc)
	226	#define E1000_TX_DESC(R, i) E1000_GET_DESC(R, i, e1000_tx_desc)
	227	#define E1000_CONTEXT_DESC(R, i) E1000_GET_DESC(R, i, e1000_context_desc)
	228
	229	/* board specific private data structure */
	230
	231	struct e1000_adapter {
5622e404	232	unsigned long active_vlans[BITS_TO_LONGS(VLAN_N_VID)];
406874a7 JP	233	u16 mng_vlan_id;
	234	u32 bd_number;
	235	u32 rx_buffer_len;
	236	u32 wol;
	237	u32 smartspeed;
	238	u32 en_mng_pt;
	239	u16 link_speed;
	240	u16 link_duplex;
1da177e4	241	spinlock_t stats_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
406874a7	252	u8 fc_autoneg;
1da177e4	253
1da177e4	254	/* TX */
581d708e	255	struct e1000_tx_ring tx_ring; / One per active queue */
fcfb1224	256	unsigned int restart_queue;
406874a7 JP	257	u32 txd_cmd;
	258	u32 tx_int_delay;
	259	u32 tx_abs_int_delay;
	260	u32 gotcl;
	261	u64 gotcl_old;
	262	u64 tpt_old;
	263	u64 colc_old;
	264	u32 tx_timeout_count;
	265	u32 tx_fifo_head;
	266	u32 tx_head_addr;
	267	u32 tx_fifo_size;
	268	u8 tx_timeout_factor;
1da177e4	269	atomic_t tx_fifo_stall;
c3033b01 JP	270	bool pcix_82544;
c3033b01 JP	271	bool detect_tx_hung;
b04e36ba	272	bool dump_buffers;
1da177e4 LT	273
1da177e4 LT	274	/* RX */
e982f17c JP	275	bool (clean_rx)(struct e1000_adapter adapter,
	276	struct e1000_rx_ring *rx_ring,
	277	int *work_done, int work_to_do);
e982f17c JP	278	void (alloc_rx_buf)(struct e1000_adapter adapter,
	279	struct e1000_rx_ring *rx_ring,
	280	int cleaned_count);
581d708e	281	struct e1000_rx_ring rx_ring; / One per active queue */
bea3348e	282	struct napi_struct napi;
c3570acb	283
f56799ea JK	284	int num_tx_queues;
f56799ea JK	285	int num_rx_queues;
581d708e	286
406874a7 JP	287	u64 hw_csum_err;
406874a7 JP	288	u64 hw_csum_good;
406874a7 JP	289	u32 alloc_rx_buff_failed;
	290	u32 rx_int_delay;
	291	u32 rx_abs_int_delay;
c3033b01	292	bool rx_csum;
406874a7 JP	293	u32 gorcl;
406874a7 JP	294	u64 gorcl_old;
1da177e4	295
1da177e4 LT	296	/* OS defined structs */
	297	struct net_device *netdev;
	298	struct pci_dev *pdev;
1da177e4 LT	299
	300	/* structs defined in e1000_hw.h */
	301	struct e1000_hw hw;
	302	struct e1000_hw_stats stats;
	303	struct e1000_phy_info phy_info;
	304	struct e1000_phy_stats phy_stats;
	305
406874a7	306	u32 test_icr;
581d708e MC	307	struct e1000_tx_ring test_tx_ring;
581d708e MC	308	struct e1000_rx_ring test_rx_ring;
1da177e4	309
1da177e4	310	int msg_enable;
e94bd23f	311
7e6c9861	312	/* to not mess up cache alignment, always add to the bottom */
c3033b01 JP	313	bool tso_force;
	314	bool smart_power_down; /* phy smart power down */
	315	bool quad_port_a;
2db10a08	316	unsigned long flags;
406874a7	317	u32 eeprom_wol;
81250297 TI	318
	319	/* for ioport free */
	320	int bars;
	321	int need_ioport;
40a14dea JB	322
40a14dea JB	323	bool discarding;
5cf42fcd	324
a4010afe JB	325	struct work_struct reset_task;
	326	struct delayed_work watchdog_task;
	327	struct delayed_work fifo_stall_task;
	328	struct delayed_work phy_info_task;
1da177e4	329	};
30dcbf29	330
2db10a08	331	enum e1000_state_t {
1314bbf3	332	__E1000_TESTING,
2db10a08	333	__E1000_RESETTING,
1314bbf3	334	__E1000_DOWN
2db10a08	335	};
30dcbf29	336
675ad473 ET	337	#undef pr_fmt
	338	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
	339
5ccc921a	340	struct net_device e1000_get_hw_dev(struct e1000_hw hw);
675ad473 ET	341	#define e_dbg(format, arg...) \
675ad473 ET	342	netdev_dbg(e1000_get_hw_dev(hw), format, ## arg)
feb8f478 ET	343	#define e_err(msglvl, format, arg...) \
	344	netif_err(adapter, msglvl, adapter->netdev, format, ## arg)
	345	#define e_info(msglvl, format, arg...) \
	346	netif_info(adapter, msglvl, adapter->netdev, format, ## arg)
	347	#define e_warn(msglvl, format, arg...) \
	348	netif_warn(adapter, msglvl, adapter->netdev, format, ## arg)
	349	#define e_notice(msglvl, format, arg...) \
	350	netif_notice(adapter, msglvl, adapter->netdev, format, ## arg)
675ad473 ET	351	#define e_dev_info(format, arg...) \
	352	dev_info(&adapter->pdev->dev, format, ## arg)
	353	#define e_dev_warn(format, arg...) \
	354	dev_warn(&adapter->pdev->dev, format, ## arg)
feb8f478 ET	355	#define e_dev_err(format, arg...) \
feb8f478 ET	356	dev_err(&adapter->pdev->dev, format, ## arg)
675ad473	357
abec42a4 SH	358	extern char e1000_driver_name[];
	359	extern const char e1000_driver_version[];
	360
1f2f83f8 SA	361	int e1000_open(struct net_device *netdev);
1f2f83f8 SA	362	int e1000_close(struct net_device *netdev);
5ccc921a JP	363	int e1000_up(struct e1000_adapter *adapter);
	364	void e1000_down(struct e1000_adapter *adapter);
	365	void e1000_reinit_locked(struct e1000_adapter *adapter);
	366	void e1000_reset(struct e1000_adapter *adapter);
	367	int e1000_set_spd_dplx(struct e1000_adapter *adapter, u32 spd, u8 dplx);
	368	int e1000_setup_all_rx_resources(struct e1000_adapter *adapter);
	369	int e1000_setup_all_tx_resources(struct e1000_adapter *adapter);
	370	void e1000_free_all_rx_resources(struct e1000_adapter *adapter);
	371	void e1000_free_all_tx_resources(struct e1000_adapter *adapter);
	372	void e1000_update_stats(struct e1000_adapter *adapter);
	373	bool e1000_has_link(struct e1000_adapter *adapter);
	374	void e1000_power_up_phy(struct e1000_adapter *);
	375	void e1000_set_ethtool_ops(struct net_device *netdev);
	376	void e1000_check_options(struct e1000_adapter *adapter);
	377	char e1000_get_hw_dev_name(struct e1000_hw hw);
abec42a4	378
1da177e4	379	#endif /* _E1000_H_ */