ixgbe.h 28.3 KB
Newer Older
1
2
3
/*******************************************************************************

  Intel 10 Gigabit PCI Express Linux driver
Don Skidmore's avatar
Don Skidmore committed
4
  Copyright(c) 1999 - 2013 Intel Corporation.
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

  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

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

#ifndef _IXGBE_H_
#define _IXGBE_H_

31
#include <linux/bitops.h>
32
33
34
#include <linux/types.h>
#include <linux/pci.h>
#include <linux/netdevice.h>
35
#include <linux/cpumask.h>
36
#include <linux/aer.h>
37
#include <linux/if_vlan.h>
38
#include <linux/jiffies.h>
39

40
41
42
43
#include <linux/clocksource.h>
#include <linux/net_tstamp.h>
#include <linux/ptp_clock_kernel.h>

44
45
#include "ixgbe_type.h"
#include "ixgbe_common.h"
46
#include "ixgbe_dcb.h"
47
48
49
50
#if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
#define IXGBE_FCOE
#include "ixgbe_fcoe.h"
#endif /* CONFIG_FCOE or CONFIG_FCOE_MODULE */
51
#ifdef CONFIG_IXGBE_DCA
52
53
#include <linux/dca.h>
#endif
54

55
#include <net/busy_poll.h>
56

57
58
59
#ifdef CONFIG_NET_LL_RX_POLL
#define LL_EXTENDED_STATS
#endif
60
61
62
/* common prefix used by pr_<> macros */
#undef pr_fmt
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
63
64

/* TX/RX descriptor defines */
65
#define IXGBE_DEFAULT_TXD		    512
66
#define IXGBE_DEFAULT_TX_WORK		    256
67
68
69
#define IXGBE_MAX_TXD			   4096
#define IXGBE_MIN_TXD			     64

70
#define IXGBE_DEFAULT_RXD		    512
71
72
73
74
#define IXGBE_MAX_RXD			   4096
#define IXGBE_MIN_RXD			     64

/* flow control */
75
#define IXGBE_MIN_FCRTL			   0x40
76
#define IXGBE_MAX_FCRTL			0x7FF80
77
#define IXGBE_MIN_FCRTH			  0x600
78
#define IXGBE_MAX_FCRTH			0x7FFF0
79
#define IXGBE_DEFAULT_FCPAUSE		 0xFFFF
80
81
82
83
#define IXGBE_MIN_FCPAUSE		      0
#define IXGBE_MAX_FCPAUSE		 0xFFFF

/* Supported Rx Buffer Sizes */
84
#define IXGBE_RXBUFFER_256    256  /* Used for skb receive header */
85
86
87
#define IXGBE_RXBUFFER_2K    2048
#define IXGBE_RXBUFFER_3K    3072
#define IXGBE_RXBUFFER_4K    4096
88
#define IXGBE_MAX_RXBUFFER  16384  /* largest size for a single descriptor */
89

90
/*
91
92
93
94
95
96
 * NOTE: netdev_alloc_skb reserves up to 64 bytes, NET_IP_ALIGN means we
 * reserve 64 more, and skb_shared_info adds an additional 320 bytes more,
 * this adds up to 448 bytes of extra data.
 *
 * Since netdev_alloc_skb now allocates a page fragment we can use a value
 * of 256 and the resultant skb will have a truesize of 960 or less.
97
 */
98
#define IXGBE_RX_HDR_SIZE IXGBE_RXBUFFER_256
99
100
101
102

/* How many Rx Buffers do we bundle into one write to the hardware ? */
#define IXGBE_RX_BUFFER_WRITE	16	/* Must be power of 2 */

103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
enum ixgbe_tx_flags {
	/* cmd_type flags */
	IXGBE_TX_FLAGS_HW_VLAN	= 0x01,
	IXGBE_TX_FLAGS_TSO	= 0x02,
	IXGBE_TX_FLAGS_TSTAMP	= 0x04,

	/* olinfo flags */
	IXGBE_TX_FLAGS_CC	= 0x08,
	IXGBE_TX_FLAGS_IPV4	= 0x10,
	IXGBE_TX_FLAGS_CSUM	= 0x20,

	/* software defined flags */
	IXGBE_TX_FLAGS_SW_VLAN	= 0x40,
	IXGBE_TX_FLAGS_FCOE	= 0x80,
};

/* VLAN info */
120
#define IXGBE_TX_FLAGS_VLAN_MASK	0xffff0000
121
122
#define IXGBE_TX_FLAGS_VLAN_PRIO_MASK	0xe0000000
#define IXGBE_TX_FLAGS_VLAN_PRIO_SHIFT  29
123
124
#define IXGBE_TX_FLAGS_VLAN_SHIFT	16

125
126
127
128
#define IXGBE_MAX_VF_MC_ENTRIES         30
#define IXGBE_MAX_VF_FUNCTIONS          64
#define IXGBE_MAX_VFTA_ENTRIES          128
#define MAX_EMULATION_MAC_ADDRS         16
Greg Rose's avatar
Greg Rose committed
129
#define IXGBE_MAX_PF_MACVLANS           15
130
#define VMDQ_P(p)   ((p) + adapter->ring_feature[RING_F_VMDQ].offset)
131
132
#define IXGBE_82599_VF_DEVICE_ID        0x10ED
#define IXGBE_X540_VF_DEVICE_ID         0x1515
133
134
135
136
137
138
139
140

struct vf_data_storage {
	unsigned char vf_mac_addresses[ETH_ALEN];
	u16 vf_mc_hashes[IXGBE_MAX_VF_MC_ENTRIES];
	u16 num_vf_mc_hashes;
	u16 default_vf_vlan_id;
	u16 vlans_enabled;
	bool clear_to_send;
141
142
143
	bool pf_set_mac;
	u16 pf_vlan; /* When set, guest VLAN config not allowed. */
	u16 pf_qos;
144
	u16 tx_rate;
145
146
	u16 vlan_count;
	u8 spoofchk_enabled;
147
	unsigned int vf_api;
148
149
};

Greg Rose's avatar
Greg Rose committed
150
151
152
153
154
155
156
157
158
struct vf_macvlans {
	struct list_head l;
	int vf;
	int rar_entry;
	bool free;
	bool is_macvlan;
	u8 vf_macvlan[ETH_ALEN];
};

159
160
161
162
163
#define IXGBE_MAX_TXD_PWR	14
#define IXGBE_MAX_DATA_PER_TXD	(1 << IXGBE_MAX_TXD_PWR)

/* Tx Descriptors needed, worst case */
#define TXD_USE_COUNT(S) DIV_ROUND_UP((S), IXGBE_MAX_DATA_PER_TXD)
164
#define DESC_NEEDED (MAX_SKB_FRAGS + 4)
165

166
167
168
/* wrapper around a pointer to a socket buffer,
 * so a DMA handle can be stored along with the buffer */
struct ixgbe_tx_buffer {
169
	union ixgbe_adv_tx_desc *next_to_watch;
170
	unsigned long time_stamp;
171
172
173
	struct sk_buff *skb;
	unsigned int bytecount;
	unsigned short gso_segs;
174
	__be16 protocol;
175
176
	DEFINE_DMA_UNMAP_ADDR(dma);
	DEFINE_DMA_UNMAP_LEN(len);
177
	u32 tx_flags;
178
179
180
181
182
183
};

struct ixgbe_rx_buffer {
	struct sk_buff *skb;
	dma_addr_t dma;
	struct page *page;
184
	unsigned int page_offset;
185
186
187
188
189
};

struct ixgbe_queue_stats {
	u64 packets;
	u64 bytes;
190
191
192
193
194
#ifdef LL_EXTENDED_STATS
	u64 yields;
	u64 misses;
	u64 cleaned;
#endif  /* LL_EXTENDED_STATS */
195
196
};

197
198
199
struct ixgbe_tx_queue_stats {
	u64 restart_queue;
	u64 tx_busy;
200
	u64 tx_done_old;
201
202
203
204
205
206
207
208
};

struct ixgbe_rx_queue_stats {
	u64 rsc_count;
	u64 rsc_flush;
	u64 non_eop_descs;
	u64 alloc_rx_page_failed;
	u64 alloc_rx_buff_failed;
209
	u64 csum_err;
210
211
};

212
enum ixgbe_ring_state_t {
213
	__IXGBE_TX_FDIR_INIT_DONE,
214
	__IXGBE_TX_XPS_INIT_DONE,
215
	__IXGBE_TX_DETECT_HANG,
216
	__IXGBE_HANG_CHECK_ARMED,
217
	__IXGBE_RX_RSC_ENABLED,
218
	__IXGBE_RX_CSUM_UDP_ZERO_ERR,
219
	__IXGBE_RX_FCOE,
220
221
222
223
224
225
226
227
228
229
230
231
232
233
};

#define check_for_tx_hang(ring) \
	test_bit(__IXGBE_TX_DETECT_HANG, &(ring)->state)
#define set_check_for_tx_hang(ring) \
	set_bit(__IXGBE_TX_DETECT_HANG, &(ring)->state)
#define clear_check_for_tx_hang(ring) \
	clear_bit(__IXGBE_TX_DETECT_HANG, &(ring)->state)
#define ring_is_rsc_enabled(ring) \
	test_bit(__IXGBE_RX_RSC_ENABLED, &(ring)->state)
#define set_ring_rsc_enabled(ring) \
	set_bit(__IXGBE_RX_RSC_ENABLED, &(ring)->state)
#define clear_ring_rsc_enabled(ring) \
	clear_bit(__IXGBE_RX_RSC_ENABLED, &(ring)->state)
234
struct ixgbe_ring {
235
	struct ixgbe_ring *next;	/* pointer to next ring in q_vector */
236
237
238
	struct ixgbe_q_vector *q_vector; /* backpointer to host q_vector */
	struct net_device *netdev;	/* netdev ring belongs to */
	struct device *dev;		/* device for DMA mapping */
239
240
241
242
243
	void *desc;			/* descriptor ring memory */
	union {
		struct ixgbe_tx_buffer *tx_buffer_info;
		struct ixgbe_rx_buffer *rx_buffer_info;
	};
244
	unsigned long last_rx_timestamp;
245
	unsigned long state;
246
	u8 __iomem *tail;
247
248
	dma_addr_t dma;			/* phys. address of descriptor ring */
	unsigned int size;		/* length in bytes */
249

250
251
252
	u16 count;			/* amount of descriptors */

	u8 queue_index; /* needed for multiqueue queue management */
253
254
255
256
257
	u8 reg_idx;			/* holds the special value that gets
					 * the hardware register offset
					 * associated with this ring, which is
					 * different for DCB and RSS modes
					 */
258
259
260
	u16 next_to_use;
	u16 next_to_clean;

261
	union {
262
		u16 next_to_alloc;
263
264
265
266
267
		struct {
			u8 atr_sample_rate;
			u8 atr_count;
		};
	};
268

269
	u8 dcb_tc;
270
	struct ixgbe_queue_stats stats;
Eric Dumazet's avatar
Eric Dumazet committed
271
	struct u64_stats_sync syncp;
272
273
274
275
	union {
		struct ixgbe_tx_queue_stats tx_stats;
		struct ixgbe_rx_queue_stats rx_stats;
	};
Jesse Brandeburg's avatar
Jesse Brandeburg committed
276
} ____cacheline_internodealigned_in_smp;
277

278
279
enum ixgbe_ring_f_enum {
	RING_F_NONE = 0,
280
	RING_F_VMDQ,  /* SR-IOV uses the same ring feature */
281
	RING_F_RSS,
282
	RING_F_FDIR,
283
284
285
#ifdef IXGBE_FCOE
	RING_F_FCOE,
#endif /* IXGBE_FCOE */
286
287
288
289

	RING_F_ARRAY_SIZE      /* must be last in enum set */
};

290
#define IXGBE_MAX_RSS_INDICES  16
291
#define IXGBE_MAX_VMDQ_INDICES 64
292
#define IXGBE_MAX_FDIR_INDICES 63	/* based on q_vector limit */
293
#define IXGBE_MAX_FCOE_INDICES  8
294
295
#define MAX_RX_QUEUES (IXGBE_MAX_FDIR_INDICES + 1)
#define MAX_TX_QUEUES (IXGBE_MAX_FDIR_INDICES + 1)
296
struct ixgbe_ring_feature {
297
298
	u16 limit;	/* upper limit on feature indices */
	u16 indices;	/* current value of indices */
299
300
	u16 mask;	/* Mask used for feature to ring mapping */
	u16 offset;	/* offset to start of feature */
Jesse Brandeburg's avatar
Jesse Brandeburg committed
301
} ____cacheline_internodealigned_in_smp;
302

303
304
305
306
#define IXGBE_82599_VMDQ_8Q_MASK 0x78
#define IXGBE_82599_VMDQ_4Q_MASK 0x7C
#define IXGBE_82599_VMDQ_2Q_MASK 0x7E

307
308
309
310
311
/*
 * FCoE requires that all Rx buffers be over 2200 bytes in length.  Since
 * this is twice the size of a half page we need to double the page order
 * for FCoE enabled Rx queues.
 */
312
static inline unsigned int ixgbe_rx_bufsz(struct ixgbe_ring *ring)
313
{
314
315
316
317
318
319
#ifdef IXGBE_FCOE
	if (test_bit(__IXGBE_RX_FCOE, &ring->state))
		return (PAGE_SIZE < 8192) ? IXGBE_RXBUFFER_4K :
					    IXGBE_RXBUFFER_3K;
#endif
	return IXGBE_RXBUFFER_2K;
320
}
321
322
323
324
325
326

static inline unsigned int ixgbe_rx_pg_order(struct ixgbe_ring *ring)
{
#ifdef IXGBE_FCOE
	if (test_bit(__IXGBE_RX_FCOE, &ring->state))
		return (PAGE_SIZE < 8192) ? 1 : 0;
327
#endif
328
329
	return 0;
}
330
331
#define ixgbe_rx_pg_size(_ring) (PAGE_SIZE << ixgbe_rx_pg_order(_ring))

332
struct ixgbe_ring_container {
333
	struct ixgbe_ring *ring;	/* pointer to linked list of rings */
334
335
336
	unsigned int total_bytes;	/* total bytes processed this int */
	unsigned int total_packets;	/* total packets processed this int */
	u16 work_limit;			/* total work allowed per interrupt */
337
338
339
	u8 count;			/* total number of rings in vector */
	u8 itr;				/* current ITR setting for ring */
};
340

341
342
343
344
/* iterator for handling rings in ring container */
#define ixgbe_for_each_ring(pos, head) \
	for (pos = (head).ring; pos != NULL; pos = pos->next)

345
346
347
348
#define MAX_RX_PACKET_BUFFERS ((adapter->flags & IXGBE_FLAG_DCB_ENABLED) \
                              ? 8 : 1)
#define MAX_TX_PACKET_BUFFERS MAX_RX_PACKET_BUFFERS

349
/* MAX_Q_VECTORS of these are allocated,
350
351
352
353
 * but we only use one per queue-specific vector.
 */
struct ixgbe_q_vector {
	struct ixgbe_adapter *adapter;
354
355
356
#ifdef CONFIG_IXGBE_DCA
	int cpu;	    /* CPU for DCA */
#endif
357
358
359
360
	u16 v_idx;		/* index of q_vector within array, also used for
				 * finding the bit in EICR and friends that
				 * represents the vector for this ring */
	u16 itr;		/* Interrupt throttle rate written to EITR */
361
	struct ixgbe_ring_container rx, tx;
362
363

	struct napi_struct napi;
364
365
366
	cpumask_t affinity_mask;
	int numa_node;
	struct rcu_head rcu;	/* to avoid race with update stats on free */
367
	char name[IFNAMSIZ + 9];
368

369
370
371
372
373
374
375
376
377
378
379
380
381
#ifdef CONFIG_NET_LL_RX_POLL
	unsigned int state;
#define IXGBE_QV_STATE_IDLE        0
#define IXGBE_QV_STATE_NAPI	   1    /* NAPI owns this QV */
#define IXGBE_QV_STATE_POLL	   2    /* poll owns this QV */
#define IXGBE_QV_LOCKED (IXGBE_QV_STATE_NAPI | IXGBE_QV_STATE_POLL)
#define IXGBE_QV_STATE_NAPI_YIELD  4    /* NAPI yielded this QV */
#define IXGBE_QV_STATE_POLL_YIELD  8    /* poll yielded this QV */
#define IXGBE_QV_YIELD (IXGBE_QV_STATE_NAPI_YIELD | IXGBE_QV_STATE_POLL_YIELD)
#define IXGBE_QV_USER_PEND (IXGBE_QV_STATE_POLL | IXGBE_QV_STATE_POLL_YIELD)
	spinlock_t lock;
#endif  /* CONFIG_NET_LL_RX_POLL */

382
383
	/* for dynamic allocation of rings associated with this q_vector */
	struct ixgbe_ring ring[0] ____cacheline_internodealigned_in_smp;
384
};
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
#ifdef CONFIG_NET_LL_RX_POLL
static inline void ixgbe_qv_init_lock(struct ixgbe_q_vector *q_vector)
{

	spin_lock_init(&q_vector->lock);
	q_vector->state = IXGBE_QV_STATE_IDLE;
}

/* called from the device poll routine to get ownership of a q_vector */
static inline bool ixgbe_qv_lock_napi(struct ixgbe_q_vector *q_vector)
{
	int rc = true;
	spin_lock(&q_vector->lock);
	if (q_vector->state & IXGBE_QV_LOCKED) {
		WARN_ON(q_vector->state & IXGBE_QV_STATE_NAPI);
		q_vector->state |= IXGBE_QV_STATE_NAPI_YIELD;
		rc = false;
402
403
404
#ifdef LL_EXTENDED_STATS
		q_vector->tx.ring->stats.yields++;
#endif
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
	} else
		/* we don't care if someone yielded */
		q_vector->state = IXGBE_QV_STATE_NAPI;
	spin_unlock(&q_vector->lock);
	return rc;
}

/* returns true is someone tried to get the qv while napi had it */
static inline bool ixgbe_qv_unlock_napi(struct ixgbe_q_vector *q_vector)
{
	int rc = false;
	spin_lock(&q_vector->lock);
	WARN_ON(q_vector->state & (IXGBE_QV_STATE_POLL |
			       IXGBE_QV_STATE_NAPI_YIELD));

	if (q_vector->state & IXGBE_QV_STATE_POLL_YIELD)
		rc = true;
	q_vector->state = IXGBE_QV_STATE_IDLE;
	spin_unlock(&q_vector->lock);
	return rc;
}

/* called from ixgbe_low_latency_poll() */
static inline bool ixgbe_qv_lock_poll(struct ixgbe_q_vector *q_vector)
{
	int rc = true;
	spin_lock_bh(&q_vector->lock);
	if ((q_vector->state & IXGBE_QV_LOCKED)) {
		q_vector->state |= IXGBE_QV_STATE_POLL_YIELD;
		rc = false;
435
436
437
#ifdef LL_EXTENDED_STATS
		q_vector->rx.ring->stats.yields++;
#endif
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
	} else
		/* preserve yield marks */
		q_vector->state |= IXGBE_QV_STATE_POLL;
	spin_unlock_bh(&q_vector->lock);
	return rc;
}

/* returns true if someone tried to get the qv while it was locked */
static inline bool ixgbe_qv_unlock_poll(struct ixgbe_q_vector *q_vector)
{
	int rc = false;
	spin_lock_bh(&q_vector->lock);
	WARN_ON(q_vector->state & (IXGBE_QV_STATE_NAPI));

	if (q_vector->state & IXGBE_QV_STATE_POLL_YIELD)
		rc = true;
	q_vector->state = IXGBE_QV_STATE_IDLE;
	spin_unlock_bh(&q_vector->lock);
	return rc;
}

/* true if a socket is polling, even if it did not get the lock */
static inline bool ixgbe_qv_ll_polling(struct ixgbe_q_vector *q_vector)
{
	WARN_ON(!(q_vector->state & IXGBE_QV_LOCKED));
	return q_vector->state & IXGBE_QV_USER_PEND;
}
#else /* CONFIG_NET_LL_RX_POLL */
static inline void ixgbe_qv_init_lock(struct ixgbe_q_vector *q_vector)
{
}

static inline bool ixgbe_qv_lock_napi(struct ixgbe_q_vector *q_vector)
{
	return true;
}

static inline bool ixgbe_qv_unlock_napi(struct ixgbe_q_vector *q_vector)
{
	return false;
}

static inline bool ixgbe_qv_lock_poll(struct ixgbe_q_vector *q_vector)
{
	return false;
}

static inline bool ixgbe_qv_unlock_poll(struct ixgbe_q_vector *q_vector)
{
	return false;
}

static inline bool ixgbe_qv_ll_polling(struct ixgbe_q_vector *q_vector)
{
	return false;
}
#endif /* CONFIG_NET_LL_RX_POLL */

496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
#ifdef CONFIG_IXGBE_HWMON

#define IXGBE_HWMON_TYPE_LOC		0
#define IXGBE_HWMON_TYPE_TEMP		1
#define IXGBE_HWMON_TYPE_CAUTION	2
#define IXGBE_HWMON_TYPE_MAX		3

struct hwmon_attr {
	struct device_attribute dev_attr;
	struct ixgbe_hw *hw;
	struct ixgbe_thermal_diode_data *sensor;
	char name[12];
};

struct hwmon_buff {
	struct device *device;
	struct hwmon_attr *hwmon_list;
	unsigned int n_hwmon;
};
#endif /* CONFIG_IXGBE_HWMON */
516

517
518
519
/*
 * microsecond values for various ITR rates shifted by 2 to fit itr register
 * with the first 3 bits reserved 0
520
 */
521
522
523
524
525
#define IXGBE_MIN_RSC_ITR	24
#define IXGBE_100K_ITR		40
#define IXGBE_20K_ITR		200
#define IXGBE_10K_ITR		400
#define IXGBE_8K_ITR		500
526

527
528
529
530
531
532
533
/* ixgbe_test_staterr - tests bits in Rx descriptor status and error fields */
static inline __le32 ixgbe_test_staterr(union ixgbe_adv_rx_desc *rx_desc,
					const u32 stat_err_bits)
{
	return rx_desc->wb.upper.status_error & cpu_to_le32(stat_err_bits);
}

534
535
536
537
538
539
540
static inline u16 ixgbe_desc_unused(struct ixgbe_ring *ring)
{
	u16 ntc = ring->next_to_clean;
	u16 ntu = ring->next_to_use;

	return ((ntc > ntu) ? 0 : ring->count) + ntc - ntu - 1;
}
541

542
#define IXGBE_RX_DESC(R, i)	    \
543
	(&(((union ixgbe_adv_rx_desc *)((R)->desc))[i]))
544
#define IXGBE_TX_DESC(R, i)	    \
545
	(&(((union ixgbe_adv_tx_desc *)((R)->desc))[i]))
546
#define IXGBE_TX_CTXTDESC(R, i)	    \
547
	(&(((struct ixgbe_adv_tx_context_desc *)((R)->desc))[i]))
548

549
#define IXGBE_MAX_JUMBO_FRAME_SIZE	9728 /* Maximum Supported Size 9.5KB */
550
551
552
553
#ifdef IXGBE_FCOE
/* Use 3K as the baby jumbo frame size for FCoE */
#define IXGBE_FCOE_JUMBO_FRAME_SIZE       3072
#endif /* IXGBE_FCOE */
554

555
556
557
#define OTHER_VECTOR 1
#define NON_Q_VECTORS (OTHER_VECTOR)

558
#define MAX_MSIX_VECTORS_82599 64
559
#define MAX_Q_VECTORS_82599 64
560
#define MAX_MSIX_VECTORS_82598 18
561
#define MAX_Q_VECTORS_82598 16
562

563
#define MAX_Q_VECTORS MAX_Q_VECTORS_82599
564
#define MAX_MSIX_COUNT MAX_MSIX_VECTORS_82599
565

566
#define MIN_MSIX_Q_VECTORS 1
567
568
#define MIN_MSIX_COUNT (MIN_MSIX_Q_VECTORS + NON_Q_VECTORS)

569
570
571
/* default to trying for four seconds */
#define IXGBE_TRY_LINK_TIMEOUT (4 * HZ)

572
573
/* board specific private data structure */
struct ixgbe_adapter {
574
575
576
577
578
	unsigned long active_vlans[BITS_TO_LONGS(VLAN_N_VID)];
	/* OS defined structs */
	struct net_device *netdev;
	struct pci_dev *pdev;

579
580
581
582
583
584
	unsigned long state;

	/* Some features need tri-state capability,
	 * thus the additional *_CAPABLE flags.
	 */
	u32 flags;
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
#define IXGBE_FLAG_MSI_CAPABLE                  (u32)(1 << 0)
#define IXGBE_FLAG_MSI_ENABLED                  (u32)(1 << 1)
#define IXGBE_FLAG_MSIX_CAPABLE                 (u32)(1 << 2)
#define IXGBE_FLAG_MSIX_ENABLED                 (u32)(1 << 3)
#define IXGBE_FLAG_RX_1BUF_CAPABLE              (u32)(1 << 4)
#define IXGBE_FLAG_RX_PS_CAPABLE                (u32)(1 << 5)
#define IXGBE_FLAG_RX_PS_ENABLED                (u32)(1 << 6)
#define IXGBE_FLAG_IN_NETPOLL                   (u32)(1 << 7)
#define IXGBE_FLAG_DCA_ENABLED                  (u32)(1 << 8)
#define IXGBE_FLAG_DCA_CAPABLE                  (u32)(1 << 9)
#define IXGBE_FLAG_IMIR_ENABLED                 (u32)(1 << 10)
#define IXGBE_FLAG_MQ_CAPABLE                   (u32)(1 << 11)
#define IXGBE_FLAG_DCB_ENABLED                  (u32)(1 << 12)
#define IXGBE_FLAG_VMDQ_CAPABLE                 (u32)(1 << 13)
#define IXGBE_FLAG_VMDQ_ENABLED                 (u32)(1 << 14)
#define IXGBE_FLAG_FAN_FAIL_CAPABLE             (u32)(1 << 15)
#define IXGBE_FLAG_NEED_LINK_UPDATE             (u32)(1 << 16)
#define IXGBE_FLAG_NEED_LINK_CONFIG             (u32)(1 << 17)
#define IXGBE_FLAG_FDIR_HASH_CAPABLE            (u32)(1 << 18)
#define IXGBE_FLAG_FDIR_PERFECT_CAPABLE         (u32)(1 << 19)
#define IXGBE_FLAG_FCOE_CAPABLE                 (u32)(1 << 20)
#define IXGBE_FLAG_FCOE_ENABLED                 (u32)(1 << 21)
#define IXGBE_FLAG_SRIOV_CAPABLE                (u32)(1 << 22)
#define IXGBE_FLAG_SRIOV_ENABLED                (u32)(1 << 23)
609
610

	u32 flags2;
611
#define IXGBE_FLAG2_RSC_CAPABLE                 (u32)(1 << 0)
612
613
#define IXGBE_FLAG2_RSC_ENABLED                 (u32)(1 << 1)
#define IXGBE_FLAG2_TEMP_SENSOR_CAPABLE         (u32)(1 << 2)
614
#define IXGBE_FLAG2_TEMP_SENSOR_EVENT           (u32)(1 << 3)
615
616
#define IXGBE_FLAG2_SEARCH_FOR_SFP              (u32)(1 << 4)
#define IXGBE_FLAG2_SFP_NEEDS_RESET             (u32)(1 << 5)
617
#define IXGBE_FLAG2_RESET_REQUESTED             (u32)(1 << 6)
618
#define IXGBE_FLAG2_FDIR_REQUIRES_REINIT        (u32)(1 << 7)
619
620
#define IXGBE_FLAG2_RSS_FIELD_IPV4_UDP		(u32)(1 << 8)
#define IXGBE_FLAG2_RSS_FIELD_IPV6_UDP		(u32)(1 << 9)
621
#define IXGBE_FLAG2_PTP_ENABLED			(u32)(1 << 10)
622
#define IXGBE_FLAG2_PTP_PPS_ENABLED		(u32)(1 << 11)
623
#define IXGBE_FLAG2_BRIDGE_MODE_VEB		(u32)(1 << 12)
624

625
626
627
	/* Tx fast path data */
	int num_tx_queues;
	u16 tx_itr_setting;
628
629
	u16 tx_work_limit;

630
631
632
633
	/* Rx fast path data */
	int num_rx_queues;
	u16 rx_itr_setting;

634
	/* TX */
635
	struct ixgbe_ring *tx_ring[MAX_TX_QUEUES] ____cacheline_aligned_in_smp;
636

Jesse Brandeburg's avatar
Jesse Brandeburg committed
637
638
	u64 restart_queue;
	u64 lsc_int;
639
	u32 tx_timeout_count;
Jesse Brandeburg's avatar
Jesse Brandeburg committed
640

641
	/* RX */
642
	struct ixgbe_ring *rx_ring[MAX_RX_QUEUES];
643
644
	int num_rx_pools;		/* == num_rx_queues in 82598 */
	int num_rx_queues_per_pool;	/* 1 if 82598, can be many if 82599 */
645
	u64 hw_csum_rx_error;
646
	u64 hw_rx_no_dma_resources;
647
648
	u64 rsc_total_count;
	u64 rsc_total_flush;
649
650
651
652
	u64 non_eop_descs;
	u32 alloc_rx_page_failed;
	u32 alloc_rx_buff_failed;

653
	struct ixgbe_q_vector *q_vector[MAX_Q_VECTORS];
654

655
656
657
658
659
660
661
662
663
	/* DCB parameters */
	struct ieee_pfc *ixgbe_ieee_pfc;
	struct ieee_ets *ixgbe_ieee_ets;
	struct ixgbe_dcb_config dcb_cfg;
	struct ixgbe_dcb_config temp_dcb_cfg;
	u8 dcb_set_bitmap;
	u8 dcbx_cap;
	enum ixgbe_fc_mode last_lfc_mode;

664
665
	int num_q_vectors;	/* current number of q_vectors for device */
	int max_q_vectors;	/* true count of q_vectors for device */
666
667
	struct ixgbe_ring_feature ring_feature[RING_F_ARRAY_SIZE];
	struct msix_entry *msix_entries;
668

669
670
671
672
	u32 test_icr;
	struct ixgbe_ring test_tx_ring;
	struct ixgbe_ring test_rx_ring;

673
674
675
676
	/* structs defined in ixgbe_hw.h */
	struct ixgbe_hw hw;
	u16 msg_enable;
	struct ixgbe_hw_stats stats;
677

678
	u64 tx_busy;
679
680
	unsigned int tx_ring_count;
	unsigned int rx_ring_count;
681
682
683
684
685

	u32 link_speed;
	bool link_up;
	unsigned long link_check_timeout;

686
	struct timer_list service_timer;
687
688
689
690
691
692
	struct work_struct service_task;

	struct hlist_head fdir_filter_list;
	unsigned long fdir_overflow; /* number of times ATR was backed off */
	union ixgbe_atr_input fdir_mask;
	int fdir_filter_count;
693
694
695
	u32 fdir_pballoc;
	u32 atr_sample_rate;
	spinlock_t fdir_perfect_lock;
696

697
698
699
#ifdef IXGBE_FCOE
	struct ixgbe_fcoe fcoe;
#endif /* IXGBE_FCOE */
700
	u32 wol;
701
702
703

	u16 bd_number;

704
705
	u16 eeprom_verh;
	u16 eeprom_verl;
706
	u16 eeprom_cap;
707

708
	u32 interrupt_event;
709
	u32 led_reg;
710

711
712
	struct ptp_clock *ptp_clock;
	struct ptp_clock_info ptp_caps;
713
714
715
	struct work_struct ptp_tx_work;
	struct sk_buff *ptp_tx_skb;
	unsigned long ptp_tx_start;
716
	unsigned long last_overflow_check;
717
	unsigned long last_rx_ptp_check;
718
719
720
721
722
	spinlock_t tmreg_lock;
	struct cyclecounter cc;
	struct timecounter tc;
	u32 base_incval;

723
724
725
726
	/* SR-IOV */
	DECLARE_BITMAP(active_vfs, IXGBE_MAX_VF_FUNCTIONS);
	unsigned int num_vfs;
	struct vf_data_storage *vfinfo;
727
	int vf_rate_link_speed;
Greg Rose's avatar
Greg Rose committed
728
729
	struct vf_macvlans vf_mvs;
	struct vf_macvlans *mv_list;
730

731
732
	u32 timer_event_accumulator;
	u32 vferr_refcount;
733
734
735
736
	struct kobject *info_kobj;
#ifdef CONFIG_IXGBE_HWMON
	struct hwmon_buff ixgbe_hwmon_buff;
#endif /* CONFIG_IXGBE_HWMON */
737
738
739
#ifdef CONFIG_DEBUG_FS
	struct dentry *ixgbe_dbg_adapter;
#endif /*CONFIG_DEBUG_FS*/
740
741

	u8 default_up;
742
743
744
745
746
747
748
};

struct ixgbe_fdir_filter {
	struct hlist_node fdir_node;
	union ixgbe_atr_input filter;
	u16 sw_idx;
	u16 action;
749
750
};

751
enum ixgbe_state_t {
752
753
	__IXGBE_TESTING,
	__IXGBE_RESETTING,
754
	__IXGBE_DOWN,
755
756
	__IXGBE_SERVICE_SCHED,
	__IXGBE_IN_SFP_INIT,
757
	__IXGBE_READ_I2C,
758
759
};

Alexander Duyck's avatar
Alexander Duyck committed
760
761
762
763
764
struct ixgbe_cb {
	union {				/* Union defining head/tail partner */
		struct sk_buff *head;
		struct sk_buff *tail;
	};
765
	dma_addr_t dma;
Alexander Duyck's avatar
Alexander Duyck committed
766
	u16 append_cnt;
767
	bool page_released;
768
};
Alexander Duyck's avatar
Alexander Duyck committed
769
#define IXGBE_CB(skb) ((struct ixgbe_cb *)(skb)->cb)
770

771
enum ixgbe_boards {
772
	board_82598,
773
	board_82599,
774
	board_X540,
775
776
};

777
extern struct ixgbe_info ixgbe_82598_info;
778
extern struct ixgbe_info ixgbe_82599_info;
779
extern struct ixgbe_info ixgbe_X540_info;
Jeff Kirsher's avatar
Jeff Kirsher committed
780
#ifdef CONFIG_IXGBE_DCB
781
extern const struct dcbnl_rtnl_ops dcbnl_ops;
782
#endif
783
784

extern char ixgbe_driver_name[];
Stephen Hemminger's avatar
Stephen Hemminger committed
785
extern const char ixgbe_driver_version[];
786
#ifdef IXGBE_FCOE
787
extern char ixgbe_default_device_descr[];
788
#endif /* IXGBE_FCOE */
789

790
extern void ixgbe_up(struct ixgbe_adapter *adapter);
791
extern void ixgbe_down(struct ixgbe_adapter *adapter);
792
extern void ixgbe_reinit_locked(struct ixgbe_adapter *adapter);
793
794
extern void ixgbe_reset(struct ixgbe_adapter *adapter);
extern void ixgbe_set_ethtool_ops(struct net_device *netdev);
795
796
797
798
extern int ixgbe_setup_rx_resources(struct ixgbe_ring *);
extern int ixgbe_setup_tx_resources(struct ixgbe_ring *);
extern void ixgbe_free_rx_resources(struct ixgbe_ring *);
extern void ixgbe_free_tx_resources(struct ixgbe_ring *);
799
800
extern void ixgbe_configure_rx_ring(struct ixgbe_adapter *,struct ixgbe_ring *);
extern void ixgbe_configure_tx_ring(struct ixgbe_adapter *,struct ixgbe_ring *);
801
802
extern void ixgbe_disable_rx_queue(struct ixgbe_adapter *adapter,
				   struct ixgbe_ring *);
803
extern void ixgbe_update_stats(struct ixgbe_adapter *adapter);
804
extern int ixgbe_init_interrupt_scheme(struct ixgbe_adapter *adapter);
805
806
extern int ixgbe_wol_supported(struct ixgbe_adapter *adapter, u16 device_id,
			       u16 subdevice_id);
807
extern void ixgbe_clear_interrupt_scheme(struct ixgbe_adapter *adapter);
808
809
810
extern netdev_tx_t ixgbe_xmit_frame_ring(struct sk_buff *,
					 struct ixgbe_adapter *,
					 struct ixgbe_ring *);
811
extern void ixgbe_unmap_and_free_tx_resource(struct ixgbe_ring *,
812
                                             struct ixgbe_tx_buffer *);
813
extern void ixgbe_alloc_rx_buffers(struct ixgbe_ring *, u16);
814
extern void ixgbe_write_eitr(struct ixgbe_q_vector *);
815
extern int ixgbe_poll(struct napi_struct *napi, int budget);
816
extern int ethtool_ioctl(struct ifreq *ifr);
817
extern s32 ixgbe_reinit_fdir_tables_82599(struct ixgbe_hw *hw);
818
819
extern s32 ixgbe_init_fdir_signature_82599(struct ixgbe_hw *hw, u32 fdirctrl);
extern s32 ixgbe_init_fdir_perfect_82599(struct ixgbe_hw *hw, u32 fdirctrl);
820
extern s32 ixgbe_fdir_add_signature_filter_82599(struct ixgbe_hw *hw,
821
822
						 union ixgbe_atr_hash_dword input,
						 union ixgbe_atr_hash_dword common,
823
                                                 u8 queue);
824
825
826
827
828
829
830
831
832
833
extern s32 ixgbe_fdir_set_input_mask_82599(struct ixgbe_hw *hw,
					   union ixgbe_atr_input *input_mask);
extern s32 ixgbe_fdir_write_perfect_filter_82599(struct ixgbe_hw *hw,
						 union ixgbe_atr_input *input,
						 u16 soft_id, u8 queue);
extern s32 ixgbe_fdir_erase_perfect_filter_82599(struct ixgbe_hw *hw,
						 union ixgbe_atr_input *input,
						 u16 soft_id);
extern void ixgbe_atr_compute_perfect_hash_82599(union ixgbe_atr_input *input,
						 union ixgbe_atr_input *mask);
834
extern bool ixgbe_verify_lesm_fw_enabled_82599(struct ixgbe_hw *hw);
835
extern void ixgbe_set_rx_mode(struct net_device *netdev);
836
#ifdef CONFIG_IXGBE_DCB
837
extern void ixgbe_set_rx_drop_en(struct ixgbe_adapter *adapter);
838
#endif
839
extern int ixgbe_setup_tc(struct net_device *dev, u8 tc);
840
extern void ixgbe_tx_ctxtdesc(struct ixgbe_ring *, u32, u32, u32, u32);
841
extern void ixgbe_do_reset(struct net_device *netdev);
842
#ifdef CONFIG_IXGBE_HWMON
843
844
extern void ixgbe_sysfs_exit(struct ixgbe_adapter *adapter);
extern int ixgbe_sysfs_init(struct ixgbe_adapter *adapter);
845
#endif /* CONFIG_IXGBE_HWMON */
846
847
#ifdef IXGBE_FCOE
extern void ixgbe_configure_fcoe(struct ixgbe_adapter *adapter);
848
849
extern int ixgbe_fso(struct ixgbe_ring *tx_ring,
		     struct ixgbe_tx_buffer *first,
850
		     u8 *hdr_len);
851
extern int ixgbe_fcoe_ddp(struct ixgbe_adapter *adapter,
852
			  union ixgbe_adv_rx_desc *rx_desc,
853
			  struct sk_buff *skb);
854
855
extern int ixgbe_fcoe_ddp_get(struct net_device *netdev, u16 xid,
                              struct scatterlist *sgl, unsigned int sgc);
856
857
extern int ixgbe_fcoe_ddp_target(struct net_device *netdev, u16 xid,
				 struct scatterlist *sgl, unsigned int sgc);
858
extern int ixgbe_fcoe_ddp_put(struct net_device *netdev, u16 xid);
859
860
extern int ixgbe_setup_fcoe_ddp_resources(struct ixgbe_adapter *adapter);
extern void ixgbe_free_fcoe_ddp_resources(struct ixgbe_adapter *adapter);
861
862
extern int ixgbe_fcoe_enable(struct net_device *netdev);
extern int ixgbe_fcoe_disable(struct net_device *netdev);
863
864
865
866
#ifdef CONFIG_IXGBE_DCB
extern u8 ixgbe_fcoe_getapp(struct ixgbe_adapter *adapter);
extern u8 ixgbe_fcoe_setapp(struct ixgbe_adapter *adapter, u8 up);
#endif /* CONFIG_IXGBE_DCB */
867
extern int ixgbe_fcoe_get_wwn(struct net_device *netdev, u64 *wwn, int type);
868
869
extern int ixgbe_fcoe_get_hbainfo(struct net_device *netdev,
				  struct netdev_fcoe_hbainfo *info);
870
extern u8 ixgbe_fcoe_get_tc(struct ixgbe_adapter *adapter);
871
#endif /* IXGBE_FCOE */
872
873
874
875
876
#ifdef CONFIG_DEBUG_FS
extern void ixgbe_dbg_adapter_init(struct ixgbe_adapter *adapter);
extern void ixgbe_dbg_adapter_exit(struct ixgbe_adapter *adapter);
extern void ixgbe_dbg_init(void);
extern void ixgbe_dbg_exit(void);
877
878
879
880
881
#else
static inline void ixgbe_dbg_adapter_init(struct ixgbe_adapter *adapter) {}
static inline void ixgbe_dbg_adapter_exit(struct ixgbe_adapter *adapter) {}
static inline void ixgbe_dbg_init(void) {}
static inline void ixgbe_dbg_exit(void) {}
882
#endif /* CONFIG_DEBUG_FS */
883
884
885
886
887
static inline struct netdev_queue *txring_txq(const struct ixgbe_ring *ring)
{
	return netdev_get_tx_queue(ring->netdev, ring->queue_index);
}

888
889
890
extern void ixgbe_ptp_init(struct ixgbe_adapter *adapter);
extern void ixgbe_ptp_stop(struct ixgbe_adapter *adapter);
extern void ixgbe_ptp_overflow_check(struct ixgbe_adapter *adapter);
891
extern void ixgbe_ptp_rx_hang(struct ixgbe_adapter *adapter);
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
extern void __ixgbe_ptp_rx_hwtstamp(struct ixgbe_q_vector *q_vector,
				    struct sk_buff *skb);
static inline void ixgbe_ptp_rx_hwtstamp(struct ixgbe_ring *rx_ring,
					 union ixgbe_adv_rx_desc *rx_desc,
					 struct sk_buff *skb)
{
	if (unlikely(!ixgbe_test_staterr(rx_desc, IXGBE_RXDADV_STAT_TS)))
		return;

	__ixgbe_ptp_rx_hwtstamp(rx_ring->q_vector, skb);

	/*
	 * Update the last_rx_timestamp timer in order to enable watchdog check
	 * for error case of latched timestamp on a dropped packet.
	 */
	rx_ring->last_rx_timestamp = jiffies;
}

910
911
912
extern int ixgbe_ptp_hwtstamp_ioctl(struct ixgbe_adapter *adapter,
				    struct ifreq *ifr, int cmd);
extern void ixgbe_ptp_start_cyclecounter(struct ixgbe_adapter *adapter);
913
extern void ixgbe_ptp_reset(struct ixgbe_adapter *adapter);
914
extern void ixgbe_ptp_check_pps_event(struct ixgbe_adapter *adapter, u32 eicr);
915
916
917
#ifdef CONFIG_PCI_IOV
void ixgbe_sriov_reinit(struct ixgbe_adapter *adapter);
#endif
918

919
#endif /* _IXGBE_H_ */