[deliverable/linux.git] / drivers / net / ethernet / intel / igbvf / igbvf.h

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

  Intel(R) 82576 Virtual Function Linux driver
  Copyright(c) 2009 - 2010 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:
  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 _IGBVF_H_
#define _IGBVF_H_

#include <linux/types.h>
#include <linux/timer.h>
#include <linux/io.h>
#include <linux/netdevice.h>
#include <linux/if_vlan.h>

#include "vf.h"

/* Forward declarations */
struct igbvf_info;
struct igbvf_adapter;

/* Interrupt defines */
#define IGBVF_START_ITR                 648 /* ~6000 ints/sec */

/* Interrupt modes, as used by the IntMode parameter */
#define IGBVF_INT_MODE_LEGACY           0
#define IGBVF_INT_MODE_MSI              1
#define IGBVF_INT_MODE_MSIX             2

/* Tx/Rx descriptor defines */
#define IGBVF_DEFAULT_TXD               256
#define IGBVF_MAX_TXD                   4096
#define IGBVF_MIN_TXD                   80

#define IGBVF_DEFAULT_RXD               256
#define IGBVF_MAX_RXD                   4096
#define IGBVF_MIN_RXD                   80

#define IGBVF_MIN_ITR_USECS             10 /* 100000 irq/sec */
#define IGBVF_MAX_ITR_USECS             10000 /* 100    irq/sec */

/* RX descriptor control thresholds.
 * PTHRESH - MAC will consider prefetch if it has fewer than this number of
 *           descriptors available in its onboard memory.
 *           Setting this to 0 disables RX descriptor prefetch.
 * HTHRESH - MAC will only prefetch if there are at least this many descriptors
 *           available in host memory.
 *           If PTHRESH is 0, this should also be 0.
 * WTHRESH - RX descriptor writeback threshold - MAC will delay writing back
 *           descriptors until either it has this many to write back, or the
 *           ITR timer expires.
 */
#define IGBVF_RX_PTHRESH                16
#define IGBVF_RX_HTHRESH                8
#define IGBVF_RX_WTHRESH                1

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

#define IGBVF_FC_PAUSE_TIME             0x0680 /* 858 usec */

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

#define AUTO_ALL_MODES                  0
#define IGBVF_EEPROM_APME               0x0400

#define IGBVF_MNG_VLAN_NONE             (-1)

/* Number of packet split data buffers (not including the header buffer) */
#define PS_PAGE_BUFFERS                 (MAX_PS_BUFFERS - 1)

enum igbvf_boards {
	board_vf,
	board_i350_vf,
};

struct igbvf_queue_stats {
	u64 packets;
	u64 bytes;
};

/*
 * wrappers around a pointer to a socket buffer,
 * so a DMA handle can be stored along with the buffer
 */
struct igbvf_buffer {
	dma_addr_t dma;
	struct sk_buff *skb;
	union {
		/* Tx */
		struct {
			unsigned long time_stamp;
			u16 length;
			u16 next_to_watch;
			u16 mapped_as_page;
		};
		/* Rx */
		struct {
			struct page *page;
			u64 page_dma;
			unsigned int page_offset;
		};
	};
};

union igbvf_desc {
	union e1000_adv_rx_desc rx_desc;
	union e1000_adv_tx_desc tx_desc;
	struct e1000_adv_tx_context_desc tx_context_desc;
};

struct igbvf_ring {
	struct igbvf_adapter *adapter;  /* backlink */
	union igbvf_desc *desc;         /* pointer to ring memory  */
	dma_addr_t dma;                 /* phys address of ring    */
	unsigned int size;              /* length of ring in bytes */
	unsigned int count;             /* number of desc. in ring */

	u16 next_to_use;
	u16 next_to_clean;

	u16 head;
	u16 tail;

	/* array of buffer information structs */
	struct igbvf_buffer *buffer_info;
	struct napi_struct napi;

	char name[IFNAMSIZ + 5];
	u32 eims_value;
	u32 itr_val;
	u16 itr_register;
	int set_itr;

	struct sk_buff *rx_skb_top;

	struct igbvf_queue_stats stats;
};

/* board specific private data structure */
struct igbvf_adapter {
	struct timer_list watchdog_timer;
	struct timer_list blink_timer;

	struct work_struct reset_task;
	struct work_struct watchdog_task;

	const struct igbvf_info *ei;

	unsigned long active_vlans[BITS_TO_LONGS(VLAN_N_VID)];
	u32 bd_number;
	u32 rx_buffer_len;
	u32 polling_interval;
	u16 mng_vlan_id;
	u16 link_speed;
	u16 link_duplex;

	spinlock_t tx_queue_lock; /* prevent concurrent tail updates */

	/* track device up/down/testing state */
	unsigned long state;

	/* Interrupt Throttle Rate */
	u32 itr;
	u32 itr_setting;
	u16 tx_itr;
	u16 rx_itr;

	/*
	 * Tx
	 */
	struct igbvf_ring *tx_ring /* One per active queue */
	____cacheline_aligned_in_smp;

	unsigned int restart_queue;
	u32 txd_cmd;

	u32 tx_int_delay;
	u32 tx_abs_int_delay;

	unsigned int total_tx_bytes;
	unsigned int total_tx_packets;
	unsigned int total_rx_bytes;
	unsigned int total_rx_packets;

	/* Tx stats */
	u32 tx_timeout_count;
	u32 tx_fifo_head;
	u32 tx_head_addr;
	u32 tx_fifo_size;
	u32 tx_dma_failed;

	/*
	 * Rx
	 */
	struct igbvf_ring *rx_ring;

	u32 rx_int_delay;
	u32 rx_abs_int_delay;

	/* Rx stats */
	u64 hw_csum_err;
	u64 hw_csum_good;
	u64 rx_hdr_split;
	u32 alloc_rx_buff_failed;
	u32 rx_dma_failed;

	unsigned int rx_ps_hdr_size;
	u32 max_frame_size;
	u32 min_frame_size;

	/* OS defined structs */
	struct net_device *netdev;
	struct pci_dev *pdev;
	struct net_device_stats net_stats;
	spinlock_t stats_lock;      /* prevent concurrent stats updates */

	/* structs defined in e1000_hw.h */
	struct e1000_hw hw;

	/* The VF counters don't clear on read so we have to get a base
	 * count on driver start up and always subtract that base on
	 * on the first update, thus the flag..
	 */
	struct e1000_vf_stats stats;
	u64 zero_base;

	struct igbvf_ring test_tx_ring;
	struct igbvf_ring test_rx_ring;
	u32 test_icr;

	u32 msg_enable;
	struct msix_entry *msix_entries;
	int int_mode;
	u32 eims_enable_mask;
	u32 eims_other;
	u32 int_counter0;
	u32 int_counter1;

	u32 eeprom_wol;
	u32 wol;
	u32 pba;

	bool fc_autoneg;

	unsigned long led_status;

	unsigned int flags;
	unsigned long last_reset;
};

struct igbvf_info {
	enum e1000_mac_type     mac;
	unsigned int            flags;
	u32                     pba;
	void                    (*init_ops)(struct e1000_hw *);
	s32                     (*get_variants)(struct igbvf_adapter *);
};

/* hardware capability, feature, and workaround flags */
#define IGBVF_FLAG_RX_CSUM_DISABLED             (1 << 0)

#define IGBVF_RX_DESC_ADV(R, i)     \
	(&((((R).desc))[i].rx_desc))
#define IGBVF_TX_DESC_ADV(R, i)     \
	(&((((R).desc))[i].tx_desc))
#define IGBVF_TX_CTXTDESC_ADV(R, i) \
	(&((((R).desc))[i].tx_context_desc))

enum igbvf_state_t {
	__IGBVF_TESTING,
	__IGBVF_RESETTING,
	__IGBVF_DOWN
};

enum latency_range {
	lowest_latency = 0,
	low_latency = 1,
	bulk_latency = 2,
	latency_invalid = 255
};

extern char igbvf_driver_name[];
extern const char igbvf_driver_version[];

extern void igbvf_check_options(struct igbvf_adapter *);
extern void igbvf_set_ethtool_ops(struct net_device *);

extern int igbvf_up(struct igbvf_adapter *);
extern void igbvf_down(struct igbvf_adapter *);
extern void igbvf_reinit_locked(struct igbvf_adapter *);
extern int igbvf_setup_rx_resources(struct igbvf_adapter *, struct igbvf_ring *);
extern int igbvf_setup_tx_resources(struct igbvf_adapter *, struct igbvf_ring *);
extern void igbvf_free_rx_resources(struct igbvf_ring *);
extern void igbvf_free_tx_resources(struct igbvf_ring *);
extern void igbvf_update_stats(struct igbvf_adapter *);

extern unsigned int copybreak;

#endif /* _IGBVF_H_ */
Commit	Line	Data
d4e0fe01 AD	1	/*******************************************************************************
	2
	3	Intel(R) 82576 Virtual Function Linux driver
2c20ebba	4	Copyright(c) 2009 - 2010 Intel Corporation.
d4e0fe01 AD	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
	13	more details.
	14
	15	You should have received a copy of the GNU General Public License along with
	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
	22	Contact Information:
	23	e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
	24	Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
	25
	26	*******************************************************************************/
	27
	28	/* Linux PRO/1000 Ethernet Driver main header file */
	29
	30	#ifndef _IGBVF_H_
	31	#define _IGBVF_H_
	32
	33	#include <linux/types.h>
	34	#include <linux/timer.h>
	35	#include <linux/io.h>
	36	#include <linux/netdevice.h>
a0f1d603	37	#include <linux/if_vlan.h>
d4e0fe01 AD	38
	39	#include "vf.h"
	40
	41	/* Forward declarations */
	42	struct igbvf_info;
	43	struct igbvf_adapter;
	44
	45	/* Interrupt defines */
	46	#define IGBVF_START_ITR 648 /* ~6000 ints/sec */
	47
98a1708d	48	/* Interrupt modes, as used by the IntMode parameter */
d4e0fe01 AD	49	#define IGBVF_INT_MODE_LEGACY 0
	50	#define IGBVF_INT_MODE_MSI 1
	51	#define IGBVF_INT_MODE_MSIX 2
	52
	53	/* Tx/Rx descriptor defines */
	54	#define IGBVF_DEFAULT_TXD 256
	55	#define IGBVF_MAX_TXD 4096
	56	#define IGBVF_MIN_TXD 80
	57
	58	#define IGBVF_DEFAULT_RXD 256
	59	#define IGBVF_MAX_RXD 4096
	60	#define IGBVF_MIN_RXD 80
	61
	62	#define IGBVF_MIN_ITR_USECS 10 /* 100000 irq/sec */
	63	#define IGBVF_MAX_ITR_USECS 10000 /* 100 irq/sec */
	64
	65	/* RX descriptor control thresholds.
	66	* PTHRESH - MAC will consider prefetch if it has fewer than this number of
	67	* descriptors available in its onboard memory.
	68	* Setting this to 0 disables RX descriptor prefetch.
	69	* HTHRESH - MAC will only prefetch if there are at least this many descriptors
	70	* available in host memory.
	71	* If PTHRESH is 0, this should also be 0.
	72	* WTHRESH - RX descriptor writeback threshold - MAC will delay writing back
	73	* descriptors until either it has this many to write back, or the
	74	* ITR timer expires.
	75	*/
	76	#define IGBVF_RX_PTHRESH 16
	77	#define IGBVF_RX_HTHRESH 8
	78	#define IGBVF_RX_WTHRESH 1
	79
	80	/* this is the size past which hardware will drop packets when setting LPE=0 */
	81	#define MAXIMUM_ETHERNET_VLAN_SIZE 1522
	82
	83	#define IGBVF_FC_PAUSE_TIME 0x0680 /* 858 usec */
	84
	85	/* How many Tx Descriptors do we need to call netif_wake_queue ? */
	86	#define IGBVF_TX_QUEUE_WAKE 32
	87	/* How many Rx Buffers do we bundle into one write to the hardware ? */
	88	#define IGBVF_RX_BUFFER_WRITE 16 /* Must be power of 2 */
	89
	90	#define AUTO_ALL_MODES 0
	91	#define IGBVF_EEPROM_APME 0x0400
	92
	93	#define IGBVF_MNG_VLAN_NONE (-1)
	94
	95	/* Number of packet split data buffers (not including the header buffer) */
	96	#define PS_PAGE_BUFFERS (MAX_PS_BUFFERS - 1)
	97
	98	enum igbvf_boards {
	99	board_vf,
031d7952	100	board_i350_vf,
d4e0fe01 AD	101	};
	102
	103	struct igbvf_queue_stats {
	104	u64 packets;
	105	u64 bytes;
	106	};
	107
	108	/*
	109	* wrappers around a pointer to a socket buffer,
	110	* so a DMA handle can be stored along with the buffer
	111	*/
	112	struct igbvf_buffer {
	113	dma_addr_t dma;
	114	struct sk_buff *skb;
	115	union {
	116	/* Tx */
	117	struct {
	118	unsigned long time_stamp;
	119	u16 length;
	120	u16 next_to_watch;
a7d5ca40	121	u16 mapped_as_page;
d4e0fe01 AD	122	};
	123	/* Rx */
	124	struct {
	125	struct page *page;
	126	u64 page_dma;
	127	unsigned int page_offset;
	128	};
	129	};
d4e0fe01 AD	130	};
	131
	132	union igbvf_desc {
	133	union e1000_adv_rx_desc rx_desc;
	134	union e1000_adv_tx_desc tx_desc;
	135	struct e1000_adv_tx_context_desc tx_context_desc;
	136	};
	137
	138	struct igbvf_ring {
	139	struct igbvf_adapter adapter; / backlink */
	140	union igbvf_desc desc; / pointer to ring memory */
	141	dma_addr_t dma; /* phys address of ring */
	142	unsigned int size; /* length of ring in bytes */
	143	unsigned int count; /* number of desc. in ring */
	144
	145	u16 next_to_use;
	146	u16 next_to_clean;
	147
	148	u16 head;
	149	u16 tail;
	150
	151	/* array of buffer information structs */
	152	struct igbvf_buffer *buffer_info;
	153	struct napi_struct napi;
	154
	155	char name[IFNAMSIZ + 5];
	156	u32 eims_value;
	157	u32 itr_val;
	158	u16 itr_register;
	159	int set_itr;
	160
	161	struct sk_buff *rx_skb_top;
	162
	163	struct igbvf_queue_stats stats;
	164	};
	165
	166	/* board specific private data structure */
	167	struct igbvf_adapter {
	168	struct timer_list watchdog_timer;
	169	struct timer_list blink_timer;
	170
	171	struct work_struct reset_task;
	172	struct work_struct watchdog_task;
	173
	174	const struct igbvf_info *ei;
	175
a0f1d603	176	unsigned long active_vlans[BITS_TO_LONGS(VLAN_N_VID)];
d4e0fe01 AD	177	u32 bd_number;
	178	u32 rx_buffer_len;
	179	u32 polling_interval;
	180	u16 mng_vlan_id;
	181	u16 link_speed;
	182	u16 link_duplex;
	183
	184	spinlock_t tx_queue_lock; /* prevent concurrent tail updates */
	185
	186	/* track device up/down/testing state */
	187	unsigned long state;
	188
	189	/* Interrupt Throttle Rate */
	190	u32 itr;
	191	u32 itr_setting;
	192	u16 tx_itr;
	193	u16 rx_itr;
	194
	195	/*
	196	* Tx
	197	*/
	198	struct igbvf_ring tx_ring / One per active queue */
	199	____cacheline_aligned_in_smp;
	200
d4e0fe01 AD	201	unsigned int restart_queue;
	202	u32 txd_cmd;
	203
d4e0fe01 AD	204	u32 tx_int_delay;
	205	u32 tx_abs_int_delay;
	206
	207	unsigned int total_tx_bytes;
	208	unsigned int total_tx_packets;
	209	unsigned int total_rx_bytes;
	210	unsigned int total_rx_packets;
	211
	212	/* Tx stats */
	213	u32 tx_timeout_count;
	214	u32 tx_fifo_head;
	215	u32 tx_head_addr;
	216	u32 tx_fifo_size;
	217	u32 tx_dma_failed;
	218
	219	/*
	220	* Rx
	221	*/
	222	struct igbvf_ring *rx_ring;
	223
	224	u32 rx_int_delay;
	225	u32 rx_abs_int_delay;
	226
	227	/* Rx stats */
	228	u64 hw_csum_err;
	229	u64 hw_csum_good;
	230	u64 rx_hdr_split;
	231	u32 alloc_rx_buff_failed;
	232	u32 rx_dma_failed;
	233
	234	unsigned int rx_ps_hdr_size;
	235	u32 max_frame_size;
	236	u32 min_frame_size;
	237
	238	/* OS defined structs */
	239	struct net_device *netdev;
	240	struct pci_dev *pdev;
	241	struct net_device_stats net_stats;
	242	spinlock_t stats_lock; /* prevent concurrent stats updates */
	243
	244	/* structs defined in e1000_hw.h */
	245	struct e1000_hw hw;
	246
	247	/* The VF counters don't clear on read so we have to get a base
	248	* count on driver start up and always subtract that base on
	249	* on the first update, thus the flag..
	250	*/
	251	struct e1000_vf_stats stats;
	252	u64 zero_base;
	253
	254	struct igbvf_ring test_tx_ring;
	255	struct igbvf_ring test_rx_ring;
	256	u32 test_icr;
	257
	258	u32 msg_enable;
	259	struct msix_entry *msix_entries;
	260	int int_mode;
	261	u32 eims_enable_mask;
	262	u32 eims_other;
	263	u32 int_counter0;
	264	u32 int_counter1;
	265
	266	u32 eeprom_wol;
	267	u32 wol;
268	u32 pba;
269
270	bool fc_autoneg;
271
272	unsigned long led_status;
273
274	unsigned int flags;
72279093	275	unsigned long last_reset;
d4e0fe01 AD	276	};
	277
	278	struct igbvf_info {
	279	enum e1000_mac_type mac;
	280	unsigned int flags;
	281	u32 pba;
	282	void (init_ops)(struct e1000_hw );
	283	s32 (get_variants)(struct igbvf_adapter );
	284	};
	285
	286	/* hardware capability, feature, and workaround flags */
0364d6fd	287	#define IGBVF_FLAG_RX_CSUM_DISABLED (1 << 0)
d4e0fe01 AD	288
	289	#define IGBVF_RX_DESC_ADV(R, i) \
	290	(&((((R).desc))[i].rx_desc))
	291	#define IGBVF_TX_DESC_ADV(R, i) \
	292	(&((((R).desc))[i].tx_desc))
	293	#define IGBVF_TX_CTXTDESC_ADV(R, i) \
	294	(&((((R).desc))[i].tx_context_desc))
	295
	296	enum igbvf_state_t {
	297	__IGBVF_TESTING,
	298	__IGBVF_RESETTING,
	299	__IGBVF_DOWN
	300	};
	301
	302	enum latency_range {
	303	lowest_latency = 0,
	304	low_latency = 1,
	305	bulk_latency = 2,
	306	latency_invalid = 255
	307	};
	308
	309	extern char igbvf_driver_name[];
	310	extern const char igbvf_driver_version[];
	311
	312	extern void igbvf_check_options(struct igbvf_adapter *);
	313	extern void igbvf_set_ethtool_ops(struct net_device *);
	314
	315	extern int igbvf_up(struct igbvf_adapter *);
	316	extern void igbvf_down(struct igbvf_adapter *);
	317	extern void igbvf_reinit_locked(struct igbvf_adapter *);
d4e0fe01 AD	318	extern int igbvf_setup_rx_resources(struct igbvf_adapter , struct igbvf_ring );
	319	extern int igbvf_setup_tx_resources(struct igbvf_adapter , struct igbvf_ring );
	320	extern void igbvf_free_rx_resources(struct igbvf_ring *);
	321	extern void igbvf_free_tx_resources(struct igbvf_ring *);
	322	extern void igbvf_update_stats(struct igbvf_adapter *);
d4e0fe01 AD	323
	324	extern unsigned int copybreak;
	325
	326	#endif /* _IGBVF_H_ */