1 /*******************************************************************************
2 
3   Intel 82599 Virtual Function driver
4   Copyright(c) 1999 - 2015 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
13   more details.
14 
15   You should have received a copy of the GNU General Public License along with
16   this program; if not, see <http://www.gnu.org/licenses/>.
17 
18   The full GNU General Public License is included in this distribution in
19   the file called "COPYING".
20 
21   Contact Information:
22   e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
23   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
24 
25 *******************************************************************************/
26 
27 /******************************************************************************
28  Copyright (c)2006 - 2007 Myricom, Inc. for some LRO specific code
29 ******************************************************************************/
30 
31 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
32 
33 #include <linux/types.h>
34 #include <linux/bitops.h>
35 #include <linux/module.h>
36 #include <linux/pci.h>
37 #include <linux/netdevice.h>
38 #include <linux/vmalloc.h>
39 #include <linux/string.h>
40 #include <linux/in.h>
41 #include <linux/ip.h>
42 #include <linux/tcp.h>
43 #include <linux/sctp.h>
44 #include <linux/ipv6.h>
45 #include <linux/slab.h>
46 #include <net/checksum.h>
47 #include <net/ip6_checksum.h>
48 #include <linux/ethtool.h>
49 #include <linux/if.h>
50 #include <linux/if_vlan.h>
51 #include <linux/prefetch.h>
52 
53 #include "ixgbevf.h"
54 
55 const char ixgbevf_driver_name[] = "ixgbevf";
56 static const char ixgbevf_driver_string[] =
57 	"Intel(R) 10 Gigabit PCI Express Virtual Function Network Driver";
58 
59 #define DRV_VERSION "3.2.2-k"
60 const char ixgbevf_driver_version[] = DRV_VERSION;
61 static char ixgbevf_copyright[] =
62 	"Copyright (c) 2009 - 2015 Intel Corporation.";
63 
64 static const struct ixgbevf_info *ixgbevf_info_tbl[] = {
65 	[board_82599_vf]	= &ixgbevf_82599_vf_info,
66 	[board_82599_vf_hv]	= &ixgbevf_82599_vf_hv_info,
67 	[board_X540_vf]		= &ixgbevf_X540_vf_info,
68 	[board_X540_vf_hv]	= &ixgbevf_X540_vf_hv_info,
69 	[board_X550_vf]		= &ixgbevf_X550_vf_info,
70 	[board_X550_vf_hv]	= &ixgbevf_X550_vf_hv_info,
71 	[board_X550EM_x_vf]	= &ixgbevf_X550EM_x_vf_info,
72 	[board_X550EM_x_vf_hv]	= &ixgbevf_X550EM_x_vf_hv_info,
73 	[board_x550em_a_vf]	= &ixgbevf_x550em_a_vf_info,
74 };
75 
76 /* ixgbevf_pci_tbl - PCI Device ID Table
77  *
78  * Wildcard entries (PCI_ANY_ID) should come last
79  * Last entry must be all 0s
80  *
81  * { Vendor ID, Device ID, SubVendor ID, SubDevice ID,
82  *   Class, Class Mask, private data (not used) }
83  */
84 static const struct pci_device_id ixgbevf_pci_tbl[] = {
85 	{PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_VF), board_82599_vf },
86 	{PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_VF_HV), board_82599_vf_hv },
87 	{PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X540_VF), board_X540_vf },
88 	{PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X540_VF_HV), board_X540_vf_hv },
89 	{PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550_VF), board_X550_vf },
90 	{PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550_VF_HV), board_X550_vf_hv },
91 	{PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_X_VF), board_X550EM_x_vf },
92 	{PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_X_VF_HV), board_X550EM_x_vf_hv},
93 	{PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_A_VF), board_x550em_a_vf },
94 	/* required last entry */
95 	{0, }
96 };
97 MODULE_DEVICE_TABLE(pci, ixgbevf_pci_tbl);
98 
99 MODULE_AUTHOR("Intel Corporation, <linux.nics@intel.com>");
100 MODULE_DESCRIPTION("Intel(R) 10 Gigabit Virtual Function Network Driver");
101 MODULE_LICENSE("GPL");
102 MODULE_VERSION(DRV_VERSION);
103 
104 #define DEFAULT_MSG_ENABLE (NETIF_MSG_DRV|NETIF_MSG_PROBE|NETIF_MSG_LINK)
105 static int debug = -1;
106 module_param(debug, int, 0);
107 MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
108 
109 static struct workqueue_struct *ixgbevf_wq;
110 
111 static void ixgbevf_service_event_schedule(struct ixgbevf_adapter *adapter)
112 {
113 	if (!test_bit(__IXGBEVF_DOWN, &adapter->state) &&
114 	    !test_bit(__IXGBEVF_REMOVING, &adapter->state) &&
115 	    !test_and_set_bit(__IXGBEVF_SERVICE_SCHED, &adapter->state))
116 		queue_work(ixgbevf_wq, &adapter->service_task);
117 }
118 
119 static void ixgbevf_service_event_complete(struct ixgbevf_adapter *adapter)
120 {
121 	BUG_ON(!test_bit(__IXGBEVF_SERVICE_SCHED, &adapter->state));
122 
123 	/* flush memory to make sure state is correct before next watchdog */
124 	smp_mb__before_atomic();
125 	clear_bit(__IXGBEVF_SERVICE_SCHED, &adapter->state);
126 }
127 
128 /* forward decls */
129 static void ixgbevf_queue_reset_subtask(struct ixgbevf_adapter *adapter);
130 static void ixgbevf_set_itr(struct ixgbevf_q_vector *q_vector);
131 static void ixgbevf_free_all_rx_resources(struct ixgbevf_adapter *adapter);
132 
133 static void ixgbevf_remove_adapter(struct ixgbe_hw *hw)
134 {
135 	struct ixgbevf_adapter *adapter = hw->back;
136 
137 	if (!hw->hw_addr)
138 		return;
139 	hw->hw_addr = NULL;
140 	dev_err(&adapter->pdev->dev, "Adapter removed\n");
141 	if (test_bit(__IXGBEVF_SERVICE_INITED, &adapter->state))
142 		ixgbevf_service_event_schedule(adapter);
143 }
144 
145 static void ixgbevf_check_remove(struct ixgbe_hw *hw, u32 reg)
146 {
147 	u32 value;
148 
149 	/* The following check not only optimizes a bit by not
150 	 * performing a read on the status register when the
151 	 * register just read was a status register read that
152 	 * returned IXGBE_FAILED_READ_REG. It also blocks any
153 	 * potential recursion.
154 	 */
155 	if (reg == IXGBE_VFSTATUS) {
156 		ixgbevf_remove_adapter(hw);
157 		return;
158 	}
159 	value = ixgbevf_read_reg(hw, IXGBE_VFSTATUS);
160 	if (value == IXGBE_FAILED_READ_REG)
161 		ixgbevf_remove_adapter(hw);
162 }
163 
164 u32 ixgbevf_read_reg(struct ixgbe_hw *hw, u32 reg)
165 {
166 	u8 __iomem *reg_addr = ACCESS_ONCE(hw->hw_addr);
167 	u32 value;
168 
169 	if (IXGBE_REMOVED(reg_addr))
170 		return IXGBE_FAILED_READ_REG;
171 	value = readl(reg_addr + reg);
172 	if (unlikely(value == IXGBE_FAILED_READ_REG))
173 		ixgbevf_check_remove(hw, reg);
174 	return value;
175 }
176 
177 /**
178  * ixgbevf_set_ivar - set IVAR registers - maps interrupt causes to vectors
179  * @adapter: pointer to adapter struct
180  * @direction: 0 for Rx, 1 for Tx, -1 for other causes
181  * @queue: queue to map the corresponding interrupt to
182  * @msix_vector: the vector to map to the corresponding queue
183  **/
184 static void ixgbevf_set_ivar(struct ixgbevf_adapter *adapter, s8 direction,
185 			     u8 queue, u8 msix_vector)
186 {
187 	u32 ivar, index;
188 	struct ixgbe_hw *hw = &adapter->hw;
189 
190 	if (direction == -1) {
191 		/* other causes */
192 		msix_vector |= IXGBE_IVAR_ALLOC_VAL;
193 		ivar = IXGBE_READ_REG(hw, IXGBE_VTIVAR_MISC);
194 		ivar &= ~0xFF;
195 		ivar |= msix_vector;
196 		IXGBE_WRITE_REG(hw, IXGBE_VTIVAR_MISC, ivar);
197 	} else {
198 		/* Tx or Rx causes */
199 		msix_vector |= IXGBE_IVAR_ALLOC_VAL;
200 		index = ((16 * (queue & 1)) + (8 * direction));
201 		ivar = IXGBE_READ_REG(hw, IXGBE_VTIVAR(queue >> 1));
202 		ivar &= ~(0xFF << index);
203 		ivar |= (msix_vector << index);
204 		IXGBE_WRITE_REG(hw, IXGBE_VTIVAR(queue >> 1), ivar);
205 	}
206 }
207 
208 static void ixgbevf_unmap_and_free_tx_resource(struct ixgbevf_ring *tx_ring,
209 					struct ixgbevf_tx_buffer *tx_buffer)
210 {
211 	if (tx_buffer->skb) {
212 		dev_kfree_skb_any(tx_buffer->skb);
213 		if (dma_unmap_len(tx_buffer, len))
214 			dma_unmap_single(tx_ring->dev,
215 					 dma_unmap_addr(tx_buffer, dma),
216 					 dma_unmap_len(tx_buffer, len),
217 					 DMA_TO_DEVICE);
218 	} else if (dma_unmap_len(tx_buffer, len)) {
219 		dma_unmap_page(tx_ring->dev,
220 			       dma_unmap_addr(tx_buffer, dma),
221 			       dma_unmap_len(tx_buffer, len),
222 			       DMA_TO_DEVICE);
223 	}
224 	tx_buffer->next_to_watch = NULL;
225 	tx_buffer->skb = NULL;
226 	dma_unmap_len_set(tx_buffer, len, 0);
227 	/* tx_buffer must be completely set up in the transmit path */
228 }
229 
230 static u64 ixgbevf_get_tx_completed(struct ixgbevf_ring *ring)
231 {
232 	return ring->stats.packets;
233 }
234 
235 static u32 ixgbevf_get_tx_pending(struct ixgbevf_ring *ring)
236 {
237 	struct ixgbevf_adapter *adapter = netdev_priv(ring->netdev);
238 	struct ixgbe_hw *hw = &adapter->hw;
239 
240 	u32 head = IXGBE_READ_REG(hw, IXGBE_VFTDH(ring->reg_idx));
241 	u32 tail = IXGBE_READ_REG(hw, IXGBE_VFTDT(ring->reg_idx));
242 
243 	if (head != tail)
244 		return (head < tail) ?
245 			tail - head : (tail + ring->count - head);
246 
247 	return 0;
248 }
249 
250 static inline bool ixgbevf_check_tx_hang(struct ixgbevf_ring *tx_ring)
251 {
252 	u32 tx_done = ixgbevf_get_tx_completed(tx_ring);
253 	u32 tx_done_old = tx_ring->tx_stats.tx_done_old;
254 	u32 tx_pending = ixgbevf_get_tx_pending(tx_ring);
255 
256 	clear_check_for_tx_hang(tx_ring);
257 
258 	/* Check for a hung queue, but be thorough. This verifies
259 	 * that a transmit has been completed since the previous
260 	 * check AND there is at least one packet pending. The
261 	 * ARMED bit is set to indicate a potential hang.
262 	 */
263 	if ((tx_done_old == tx_done) && tx_pending) {
264 		/* make sure it is true for two checks in a row */
265 		return test_and_set_bit(__IXGBEVF_HANG_CHECK_ARMED,
266 					&tx_ring->state);
267 	}
268 	/* reset the countdown */
269 	clear_bit(__IXGBEVF_HANG_CHECK_ARMED, &tx_ring->state);
270 
271 	/* update completed stats and continue */
272 	tx_ring->tx_stats.tx_done_old = tx_done;
273 
274 	return false;
275 }
276 
277 static void ixgbevf_tx_timeout_reset(struct ixgbevf_adapter *adapter)
278 {
279 	/* Do the reset outside of interrupt context */
280 	if (!test_bit(__IXGBEVF_DOWN, &adapter->state)) {
281 		set_bit(__IXGBEVF_RESET_REQUESTED, &adapter->state);
282 		ixgbevf_service_event_schedule(adapter);
283 	}
284 }
285 
286 /**
287  * ixgbevf_tx_timeout - Respond to a Tx Hang
288  * @netdev: network interface device structure
289  **/
290 static void ixgbevf_tx_timeout(struct net_device *netdev)
291 {
292 	struct ixgbevf_adapter *adapter = netdev_priv(netdev);
293 
294 	ixgbevf_tx_timeout_reset(adapter);
295 }
296 
297 /**
298  * ixgbevf_clean_tx_irq - Reclaim resources after transmit completes
299  * @q_vector: board private structure
300  * @tx_ring: tx ring to clean
301  * @napi_budget: Used to determine if we are in netpoll
302  **/
303 static bool ixgbevf_clean_tx_irq(struct ixgbevf_q_vector *q_vector,
304 				 struct ixgbevf_ring *tx_ring, int napi_budget)
305 {
306 	struct ixgbevf_adapter *adapter = q_vector->adapter;
307 	struct ixgbevf_tx_buffer *tx_buffer;
308 	union ixgbe_adv_tx_desc *tx_desc;
309 	unsigned int total_bytes = 0, total_packets = 0;
310 	unsigned int budget = tx_ring->count / 2;
311 	unsigned int i = tx_ring->next_to_clean;
312 
313 	if (test_bit(__IXGBEVF_DOWN, &adapter->state))
314 		return true;
315 
316 	tx_buffer = &tx_ring->tx_buffer_info[i];
317 	tx_desc = IXGBEVF_TX_DESC(tx_ring, i);
318 	i -= tx_ring->count;
319 
320 	do {
321 		union ixgbe_adv_tx_desc *eop_desc = tx_buffer->next_to_watch;
322 
323 		/* if next_to_watch is not set then there is no work pending */
324 		if (!eop_desc)
325 			break;
326 
327 		/* prevent any other reads prior to eop_desc */
328 		read_barrier_depends();
329 
330 		/* if DD is not set pending work has not been completed */
331 		if (!(eop_desc->wb.status & cpu_to_le32(IXGBE_TXD_STAT_DD)))
332 			break;
333 
334 		/* clear next_to_watch to prevent false hangs */
335 		tx_buffer->next_to_watch = NULL;
336 
337 		/* update the statistics for this packet */
338 		total_bytes += tx_buffer->bytecount;
339 		total_packets += tx_buffer->gso_segs;
340 
341 		/* free the skb */
342 		napi_consume_skb(tx_buffer->skb, napi_budget);
343 
344 		/* unmap skb header data */
345 		dma_unmap_single(tx_ring->dev,
346 				 dma_unmap_addr(tx_buffer, dma),
347 				 dma_unmap_len(tx_buffer, len),
348 				 DMA_TO_DEVICE);
349 
350 		/* clear tx_buffer data */
351 		tx_buffer->skb = NULL;
352 		dma_unmap_len_set(tx_buffer, len, 0);
353 
354 		/* unmap remaining buffers */
355 		while (tx_desc != eop_desc) {
356 			tx_buffer++;
357 			tx_desc++;
358 			i++;
359 			if (unlikely(!i)) {
360 				i -= tx_ring->count;
361 				tx_buffer = tx_ring->tx_buffer_info;
362 				tx_desc = IXGBEVF_TX_DESC(tx_ring, 0);
363 			}
364 
365 			/* unmap any remaining paged data */
366 			if (dma_unmap_len(tx_buffer, len)) {
367 				dma_unmap_page(tx_ring->dev,
368 					       dma_unmap_addr(tx_buffer, dma),
369 					       dma_unmap_len(tx_buffer, len),
370 					       DMA_TO_DEVICE);
371 				dma_unmap_len_set(tx_buffer, len, 0);
372 			}
373 		}
374 
375 		/* move us one more past the eop_desc for start of next pkt */
376 		tx_buffer++;
377 		tx_desc++;
378 		i++;
379 		if (unlikely(!i)) {
380 			i -= tx_ring->count;
381 			tx_buffer = tx_ring->tx_buffer_info;
382 			tx_desc = IXGBEVF_TX_DESC(tx_ring, 0);
383 		}
384 
385 		/* issue prefetch for next Tx descriptor */
386 		prefetch(tx_desc);
387 
388 		/* update budget accounting */
389 		budget--;
390 	} while (likely(budget));
391 
392 	i += tx_ring->count;
393 	tx_ring->next_to_clean = i;
394 	u64_stats_update_begin(&tx_ring->syncp);
395 	tx_ring->stats.bytes += total_bytes;
396 	tx_ring->stats.packets += total_packets;
397 	u64_stats_update_end(&tx_ring->syncp);
398 	q_vector->tx.total_bytes += total_bytes;
399 	q_vector->tx.total_packets += total_packets;
400 
401 	if (check_for_tx_hang(tx_ring) && ixgbevf_check_tx_hang(tx_ring)) {
402 		struct ixgbe_hw *hw = &adapter->hw;
403 		union ixgbe_adv_tx_desc *eop_desc;
404 
405 		eop_desc = tx_ring->tx_buffer_info[i].next_to_watch;
406 
407 		pr_err("Detected Tx Unit Hang\n"
408 		       "  Tx Queue             <%d>\n"
409 		       "  TDH, TDT             <%x>, <%x>\n"
410 		       "  next_to_use          <%x>\n"
411 		       "  next_to_clean        <%x>\n"
412 		       "tx_buffer_info[next_to_clean]\n"
413 		       "  next_to_watch        <%p>\n"
414 		       "  eop_desc->wb.status  <%x>\n"
415 		       "  time_stamp           <%lx>\n"
416 		       "  jiffies              <%lx>\n",
417 		       tx_ring->queue_index,
418 		       IXGBE_READ_REG(hw, IXGBE_VFTDH(tx_ring->reg_idx)),
419 		       IXGBE_READ_REG(hw, IXGBE_VFTDT(tx_ring->reg_idx)),
420 		       tx_ring->next_to_use, i,
421 		       eop_desc, (eop_desc ? eop_desc->wb.status : 0),
422 		       tx_ring->tx_buffer_info[i].time_stamp, jiffies);
423 
424 		netif_stop_subqueue(tx_ring->netdev, tx_ring->queue_index);
425 
426 		/* schedule immediate reset if we believe we hung */
427 		ixgbevf_tx_timeout_reset(adapter);
428 
429 		return true;
430 	}
431 
432 #define TX_WAKE_THRESHOLD (DESC_NEEDED * 2)
433 	if (unlikely(total_packets && netif_carrier_ok(tx_ring->netdev) &&
434 		     (ixgbevf_desc_unused(tx_ring) >= TX_WAKE_THRESHOLD))) {
435 		/* Make sure that anybody stopping the queue after this
436 		 * sees the new next_to_clean.
437 		 */
438 		smp_mb();
439 
440 		if (__netif_subqueue_stopped(tx_ring->netdev,
441 					     tx_ring->queue_index) &&
442 		    !test_bit(__IXGBEVF_DOWN, &adapter->state)) {
443 			netif_wake_subqueue(tx_ring->netdev,
444 					    tx_ring->queue_index);
445 			++tx_ring->tx_stats.restart_queue;
446 		}
447 	}
448 
449 	return !!budget;
450 }
451 
452 /**
453  * ixgbevf_rx_skb - Helper function to determine proper Rx method
454  * @q_vector: structure containing interrupt and ring information
455  * @skb: packet to send up
456  **/
457 static void ixgbevf_rx_skb(struct ixgbevf_q_vector *q_vector,
458 			   struct sk_buff *skb)
459 {
460 	napi_gro_receive(&q_vector->napi, skb);
461 }
462 
463 #define IXGBE_RSS_L4_TYPES_MASK \
464 	((1ul << IXGBE_RXDADV_RSSTYPE_IPV4_TCP) | \
465 	 (1ul << IXGBE_RXDADV_RSSTYPE_IPV4_UDP) | \
466 	 (1ul << IXGBE_RXDADV_RSSTYPE_IPV6_TCP) | \
467 	 (1ul << IXGBE_RXDADV_RSSTYPE_IPV6_UDP))
468 
469 static inline void ixgbevf_rx_hash(struct ixgbevf_ring *ring,
470 				   union ixgbe_adv_rx_desc *rx_desc,
471 				   struct sk_buff *skb)
472 {
473 	u16 rss_type;
474 
475 	if (!(ring->netdev->features & NETIF_F_RXHASH))
476 		return;
477 
478 	rss_type = le16_to_cpu(rx_desc->wb.lower.lo_dword.hs_rss.pkt_info) &
479 		   IXGBE_RXDADV_RSSTYPE_MASK;
480 
481 	if (!rss_type)
482 		return;
483 
484 	skb_set_hash(skb, le32_to_cpu(rx_desc->wb.lower.hi_dword.rss),
485 		     (IXGBE_RSS_L4_TYPES_MASK & (1ul << rss_type)) ?
486 		     PKT_HASH_TYPE_L4 : PKT_HASH_TYPE_L3);
487 }
488 
489 /**
490  * ixgbevf_rx_checksum - indicate in skb if hw indicated a good cksum
491  * @ring: structure containig ring specific data
492  * @rx_desc: current Rx descriptor being processed
493  * @skb: skb currently being received and modified
494  **/
495 static inline void ixgbevf_rx_checksum(struct ixgbevf_ring *ring,
496 				       union ixgbe_adv_rx_desc *rx_desc,
497 				       struct sk_buff *skb)
498 {
499 	skb_checksum_none_assert(skb);
500 
501 	/* Rx csum disabled */
502 	if (!(ring->netdev->features & NETIF_F_RXCSUM))
503 		return;
504 
505 	/* if IP and error */
506 	if (ixgbevf_test_staterr(rx_desc, IXGBE_RXD_STAT_IPCS) &&
507 	    ixgbevf_test_staterr(rx_desc, IXGBE_RXDADV_ERR_IPE)) {
508 		ring->rx_stats.csum_err++;
509 		return;
510 	}
511 
512 	if (!ixgbevf_test_staterr(rx_desc, IXGBE_RXD_STAT_L4CS))
513 		return;
514 
515 	if (ixgbevf_test_staterr(rx_desc, IXGBE_RXDADV_ERR_TCPE)) {
516 		ring->rx_stats.csum_err++;
517 		return;
518 	}
519 
520 	/* It must be a TCP or UDP packet with a valid checksum */
521 	skb->ip_summed = CHECKSUM_UNNECESSARY;
522 }
523 
524 /**
525  * ixgbevf_process_skb_fields - Populate skb header fields from Rx descriptor
526  * @rx_ring: rx descriptor ring packet is being transacted on
527  * @rx_desc: pointer to the EOP Rx descriptor
528  * @skb: pointer to current skb being populated
529  *
530  * This function checks the ring, descriptor, and packet information in
531  * order to populate the checksum, VLAN, protocol, and other fields within
532  * the skb.
533  **/
534 static void ixgbevf_process_skb_fields(struct ixgbevf_ring *rx_ring,
535 				       union ixgbe_adv_rx_desc *rx_desc,
536 				       struct sk_buff *skb)
537 {
538 	ixgbevf_rx_hash(rx_ring, rx_desc, skb);
539 	ixgbevf_rx_checksum(rx_ring, rx_desc, skb);
540 
541 	if (ixgbevf_test_staterr(rx_desc, IXGBE_RXD_STAT_VP)) {
542 		u16 vid = le16_to_cpu(rx_desc->wb.upper.vlan);
543 		unsigned long *active_vlans = netdev_priv(rx_ring->netdev);
544 
545 		if (test_bit(vid & VLAN_VID_MASK, active_vlans))
546 			__vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vid);
547 	}
548 
549 	skb->protocol = eth_type_trans(skb, rx_ring->netdev);
550 }
551 
552 /**
553  * ixgbevf_is_non_eop - process handling of non-EOP buffers
554  * @rx_ring: Rx ring being processed
555  * @rx_desc: Rx descriptor for current buffer
556  * @skb: current socket buffer containing buffer in progress
557  *
558  * This function updates next to clean.  If the buffer is an EOP buffer
559  * this function exits returning false, otherwise it will place the
560  * sk_buff in the next buffer to be chained and return true indicating
561  * that this is in fact a non-EOP buffer.
562  **/
563 static bool ixgbevf_is_non_eop(struct ixgbevf_ring *rx_ring,
564 			       union ixgbe_adv_rx_desc *rx_desc)
565 {
566 	u32 ntc = rx_ring->next_to_clean + 1;
567 
568 	/* fetch, update, and store next to clean */
569 	ntc = (ntc < rx_ring->count) ? ntc : 0;
570 	rx_ring->next_to_clean = ntc;
571 
572 	prefetch(IXGBEVF_RX_DESC(rx_ring, ntc));
573 
574 	if (likely(ixgbevf_test_staterr(rx_desc, IXGBE_RXD_STAT_EOP)))
575 		return false;
576 
577 	return true;
578 }
579 
580 static bool ixgbevf_alloc_mapped_page(struct ixgbevf_ring *rx_ring,
581 				      struct ixgbevf_rx_buffer *bi)
582 {
583 	struct page *page = bi->page;
584 	dma_addr_t dma = bi->dma;
585 
586 	/* since we are recycling buffers we should seldom need to alloc */
587 	if (likely(page))
588 		return true;
589 
590 	/* alloc new page for storage */
591 	page = dev_alloc_page();
592 	if (unlikely(!page)) {
593 		rx_ring->rx_stats.alloc_rx_page_failed++;
594 		return false;
595 	}
596 
597 	/* map page for use */
598 	dma = dma_map_page(rx_ring->dev, page, 0,
599 			   PAGE_SIZE, DMA_FROM_DEVICE);
600 
601 	/* if mapping failed free memory back to system since
602 	 * there isn't much point in holding memory we can't use
603 	 */
604 	if (dma_mapping_error(rx_ring->dev, dma)) {
605 		__free_page(page);
606 
607 		rx_ring->rx_stats.alloc_rx_buff_failed++;
608 		return false;
609 	}
610 
611 	bi->dma = dma;
612 	bi->page = page;
613 	bi->page_offset = 0;
614 
615 	return true;
616 }
617 
618 /**
619  * ixgbevf_alloc_rx_buffers - Replace used receive buffers; packet split
620  * @rx_ring: rx descriptor ring (for a specific queue) to setup buffers on
621  * @cleaned_count: number of buffers to replace
622  **/
623 static void ixgbevf_alloc_rx_buffers(struct ixgbevf_ring *rx_ring,
624 				     u16 cleaned_count)
625 {
626 	union ixgbe_adv_rx_desc *rx_desc;
627 	struct ixgbevf_rx_buffer *bi;
628 	unsigned int i = rx_ring->next_to_use;
629 
630 	/* nothing to do or no valid netdev defined */
631 	if (!cleaned_count || !rx_ring->netdev)
632 		return;
633 
634 	rx_desc = IXGBEVF_RX_DESC(rx_ring, i);
635 	bi = &rx_ring->rx_buffer_info[i];
636 	i -= rx_ring->count;
637 
638 	do {
639 		if (!ixgbevf_alloc_mapped_page(rx_ring, bi))
640 			break;
641 
642 		/* Refresh the desc even if pkt_addr didn't change
643 		 * because each write-back erases this info.
644 		 */
645 		rx_desc->read.pkt_addr = cpu_to_le64(bi->dma + bi->page_offset);
646 
647 		rx_desc++;
648 		bi++;
649 		i++;
650 		if (unlikely(!i)) {
651 			rx_desc = IXGBEVF_RX_DESC(rx_ring, 0);
652 			bi = rx_ring->rx_buffer_info;
653 			i -= rx_ring->count;
654 		}
655 
656 		/* clear the hdr_addr for the next_to_use descriptor */
657 		rx_desc->read.hdr_addr = 0;
658 
659 		cleaned_count--;
660 	} while (cleaned_count);
661 
662 	i += rx_ring->count;
663 
664 	if (rx_ring->next_to_use != i) {
665 		/* record the next descriptor to use */
666 		rx_ring->next_to_use = i;
667 
668 		/* update next to alloc since we have filled the ring */
669 		rx_ring->next_to_alloc = i;
670 
671 		/* Force memory writes to complete before letting h/w
672 		 * know there are new descriptors to fetch.  (Only
673 		 * applicable for weak-ordered memory model archs,
674 		 * such as IA-64).
675 		 */
676 		wmb();
677 		ixgbevf_write_tail(rx_ring, i);
678 	}
679 }
680 
681 /**
682  * ixgbevf_cleanup_headers - Correct corrupted or empty headers
683  * @rx_ring: rx descriptor ring packet is being transacted on
684  * @rx_desc: pointer to the EOP Rx descriptor
685  * @skb: pointer to current skb being fixed
686  *
687  * Check for corrupted packet headers caused by senders on the local L2
688  * embedded NIC switch not setting up their Tx Descriptors right.  These
689  * should be very rare.
690  *
691  * Also address the case where we are pulling data in on pages only
692  * and as such no data is present in the skb header.
693  *
694  * In addition if skb is not at least 60 bytes we need to pad it so that
695  * it is large enough to qualify as a valid Ethernet frame.
696  *
697  * Returns true if an error was encountered and skb was freed.
698  **/
699 static bool ixgbevf_cleanup_headers(struct ixgbevf_ring *rx_ring,
700 				    union ixgbe_adv_rx_desc *rx_desc,
701 				    struct sk_buff *skb)
702 {
703 	/* verify that the packet does not have any known errors */
704 	if (unlikely(ixgbevf_test_staterr(rx_desc,
705 					  IXGBE_RXDADV_ERR_FRAME_ERR_MASK))) {
706 		struct net_device *netdev = rx_ring->netdev;
707 
708 		if (!(netdev->features & NETIF_F_RXALL)) {
709 			dev_kfree_skb_any(skb);
710 			return true;
711 		}
712 	}
713 
714 	/* if eth_skb_pad returns an error the skb was freed */
715 	if (eth_skb_pad(skb))
716 		return true;
717 
718 	return false;
719 }
720 
721 /**
722  * ixgbevf_reuse_rx_page - page flip buffer and store it back on the ring
723  * @rx_ring: rx descriptor ring to store buffers on
724  * @old_buff: donor buffer to have page reused
725  *
726  * Synchronizes page for reuse by the adapter
727  **/
728 static void ixgbevf_reuse_rx_page(struct ixgbevf_ring *rx_ring,
729 				  struct ixgbevf_rx_buffer *old_buff)
730 {
731 	struct ixgbevf_rx_buffer *new_buff;
732 	u16 nta = rx_ring->next_to_alloc;
733 
734 	new_buff = &rx_ring->rx_buffer_info[nta];
735 
736 	/* update, and store next to alloc */
737 	nta++;
738 	rx_ring->next_to_alloc = (nta < rx_ring->count) ? nta : 0;
739 
740 	/* transfer page from old buffer to new buffer */
741 	new_buff->page = old_buff->page;
742 	new_buff->dma = old_buff->dma;
743 	new_buff->page_offset = old_buff->page_offset;
744 
745 	/* sync the buffer for use by the device */
746 	dma_sync_single_range_for_device(rx_ring->dev, new_buff->dma,
747 					 new_buff->page_offset,
748 					 IXGBEVF_RX_BUFSZ,
749 					 DMA_FROM_DEVICE);
750 }
751 
752 static inline bool ixgbevf_page_is_reserved(struct page *page)
753 {
754 	return (page_to_nid(page) != numa_mem_id()) || page_is_pfmemalloc(page);
755 }
756 
757 /**
758  * ixgbevf_add_rx_frag - Add contents of Rx buffer to sk_buff
759  * @rx_ring: rx descriptor ring to transact packets on
760  * @rx_buffer: buffer containing page to add
761  * @rx_desc: descriptor containing length of buffer written by hardware
762  * @skb: sk_buff to place the data into
763  *
764  * This function will add the data contained in rx_buffer->page to the skb.
765  * This is done either through a direct copy if the data in the buffer is
766  * less than the skb header size, otherwise it will just attach the page as
767  * a frag to the skb.
768  *
769  * The function will then update the page offset if necessary and return
770  * true if the buffer can be reused by the adapter.
771  **/
772 static bool ixgbevf_add_rx_frag(struct ixgbevf_ring *rx_ring,
773 				struct ixgbevf_rx_buffer *rx_buffer,
774 				union ixgbe_adv_rx_desc *rx_desc,
775 				struct sk_buff *skb)
776 {
777 	struct page *page = rx_buffer->page;
778 	unsigned char *va = page_address(page) + rx_buffer->page_offset;
779 	unsigned int size = le16_to_cpu(rx_desc->wb.upper.length);
780 #if (PAGE_SIZE < 8192)
781 	unsigned int truesize = IXGBEVF_RX_BUFSZ;
782 #else
783 	unsigned int truesize = ALIGN(size, L1_CACHE_BYTES);
784 #endif
785 	unsigned int pull_len;
786 
787 	if (unlikely(skb_is_nonlinear(skb)))
788 		goto add_tail_frag;
789 
790 	if (likely(size <= IXGBEVF_RX_HDR_SIZE)) {
791 		memcpy(__skb_put(skb, size), va, ALIGN(size, sizeof(long)));
792 
793 		/* page is not reserved, we can reuse buffer as is */
794 		if (likely(!ixgbevf_page_is_reserved(page)))
795 			return true;
796 
797 		/* this page cannot be reused so discard it */
798 		put_page(page);
799 		return false;
800 	}
801 
802 	/* we need the header to contain the greater of either ETH_HLEN or
803 	 * 60 bytes if the skb->len is less than 60 for skb_pad.
804 	 */
805 	pull_len = eth_get_headlen(va, IXGBEVF_RX_HDR_SIZE);
806 
807 	/* align pull length to size of long to optimize memcpy performance */
808 	memcpy(__skb_put(skb, pull_len), va, ALIGN(pull_len, sizeof(long)));
809 
810 	/* update all of the pointers */
811 	va += pull_len;
812 	size -= pull_len;
813 
814 add_tail_frag:
815 	skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags, page,
816 			(unsigned long)va & ~PAGE_MASK, size, truesize);
817 
818 	/* avoid re-using remote pages */
819 	if (unlikely(ixgbevf_page_is_reserved(page)))
820 		return false;
821 
822 #if (PAGE_SIZE < 8192)
823 	/* if we are only owner of page we can reuse it */
824 	if (unlikely(page_count(page) != 1))
825 		return false;
826 
827 	/* flip page offset to other buffer */
828 	rx_buffer->page_offset ^= IXGBEVF_RX_BUFSZ;
829 
830 #else
831 	/* move offset up to the next cache line */
832 	rx_buffer->page_offset += truesize;
833 
834 	if (rx_buffer->page_offset > (PAGE_SIZE - IXGBEVF_RX_BUFSZ))
835 		return false;
836 
837 #endif
838 	/* Even if we own the page, we are not allowed to use atomic_set()
839 	 * This would break get_page_unless_zero() users.
840 	 */
841 	page_ref_inc(page);
842 
843 	return true;
844 }
845 
846 static struct sk_buff *ixgbevf_fetch_rx_buffer(struct ixgbevf_ring *rx_ring,
847 					       union ixgbe_adv_rx_desc *rx_desc,
848 					       struct sk_buff *skb)
849 {
850 	struct ixgbevf_rx_buffer *rx_buffer;
851 	struct page *page;
852 
853 	rx_buffer = &rx_ring->rx_buffer_info[rx_ring->next_to_clean];
854 	page = rx_buffer->page;
855 	prefetchw(page);
856 
857 	if (likely(!skb)) {
858 		void *page_addr = page_address(page) +
859 				  rx_buffer->page_offset;
860 
861 		/* prefetch first cache line of first page */
862 		prefetch(page_addr);
863 #if L1_CACHE_BYTES < 128
864 		prefetch(page_addr + L1_CACHE_BYTES);
865 #endif
866 
867 		/* allocate a skb to store the frags */
868 		skb = netdev_alloc_skb_ip_align(rx_ring->netdev,
869 						IXGBEVF_RX_HDR_SIZE);
870 		if (unlikely(!skb)) {
871 			rx_ring->rx_stats.alloc_rx_buff_failed++;
872 			return NULL;
873 		}
874 
875 		/* we will be copying header into skb->data in
876 		 * pskb_may_pull so it is in our interest to prefetch
877 		 * it now to avoid a possible cache miss
878 		 */
879 		prefetchw(skb->data);
880 	}
881 
882 	/* we are reusing so sync this buffer for CPU use */
883 	dma_sync_single_range_for_cpu(rx_ring->dev,
884 				      rx_buffer->dma,
885 				      rx_buffer->page_offset,
886 				      IXGBEVF_RX_BUFSZ,
887 				      DMA_FROM_DEVICE);
888 
889 	/* pull page into skb */
890 	if (ixgbevf_add_rx_frag(rx_ring, rx_buffer, rx_desc, skb)) {
891 		/* hand second half of page back to the ring */
892 		ixgbevf_reuse_rx_page(rx_ring, rx_buffer);
893 	} else {
894 		/* we are not reusing the buffer so unmap it */
895 		dma_unmap_page(rx_ring->dev, rx_buffer->dma,
896 			       PAGE_SIZE, DMA_FROM_DEVICE);
897 	}
898 
899 	/* clear contents of buffer_info */
900 	rx_buffer->dma = 0;
901 	rx_buffer->page = NULL;
902 
903 	return skb;
904 }
905 
906 static inline void ixgbevf_irq_enable_queues(struct ixgbevf_adapter *adapter,
907 					     u32 qmask)
908 {
909 	struct ixgbe_hw *hw = &adapter->hw;
910 
911 	IXGBE_WRITE_REG(hw, IXGBE_VTEIMS, qmask);
912 }
913 
914 static int ixgbevf_clean_rx_irq(struct ixgbevf_q_vector *q_vector,
915 				struct ixgbevf_ring *rx_ring,
916 				int budget)
917 {
918 	unsigned int total_rx_bytes = 0, total_rx_packets = 0;
919 	u16 cleaned_count = ixgbevf_desc_unused(rx_ring);
920 	struct sk_buff *skb = rx_ring->skb;
921 
922 	while (likely(total_rx_packets < budget)) {
923 		union ixgbe_adv_rx_desc *rx_desc;
924 
925 		/* return some buffers to hardware, one at a time is too slow */
926 		if (cleaned_count >= IXGBEVF_RX_BUFFER_WRITE) {
927 			ixgbevf_alloc_rx_buffers(rx_ring, cleaned_count);
928 			cleaned_count = 0;
929 		}
930 
931 		rx_desc = IXGBEVF_RX_DESC(rx_ring, rx_ring->next_to_clean);
932 
933 		if (!ixgbevf_test_staterr(rx_desc, IXGBE_RXD_STAT_DD))
934 			break;
935 
936 		/* This memory barrier is needed to keep us from reading
937 		 * any other fields out of the rx_desc until we know the
938 		 * RXD_STAT_DD bit is set
939 		 */
940 		rmb();
941 
942 		/* retrieve a buffer from the ring */
943 		skb = ixgbevf_fetch_rx_buffer(rx_ring, rx_desc, skb);
944 
945 		/* exit if we failed to retrieve a buffer */
946 		if (!skb)
947 			break;
948 
949 		cleaned_count++;
950 
951 		/* fetch next buffer in frame if non-eop */
952 		if (ixgbevf_is_non_eop(rx_ring, rx_desc))
953 			continue;
954 
955 		/* verify the packet layout is correct */
956 		if (ixgbevf_cleanup_headers(rx_ring, rx_desc, skb)) {
957 			skb = NULL;
958 			continue;
959 		}
960 
961 		/* probably a little skewed due to removing CRC */
962 		total_rx_bytes += skb->len;
963 
964 		/* Workaround hardware that can't do proper VEPA multicast
965 		 * source pruning.
966 		 */
967 		if ((skb->pkt_type == PACKET_BROADCAST ||
968 		     skb->pkt_type == PACKET_MULTICAST) &&
969 		    ether_addr_equal(rx_ring->netdev->dev_addr,
970 				     eth_hdr(skb)->h_source)) {
971 			dev_kfree_skb_irq(skb);
972 			continue;
973 		}
974 
975 		/* populate checksum, VLAN, and protocol */
976 		ixgbevf_process_skb_fields(rx_ring, rx_desc, skb);
977 
978 		ixgbevf_rx_skb(q_vector, skb);
979 
980 		/* reset skb pointer */
981 		skb = NULL;
982 
983 		/* update budget accounting */
984 		total_rx_packets++;
985 	}
986 
987 	/* place incomplete frames back on ring for completion */
988 	rx_ring->skb = skb;
989 
990 	u64_stats_update_begin(&rx_ring->syncp);
991 	rx_ring->stats.packets += total_rx_packets;
992 	rx_ring->stats.bytes += total_rx_bytes;
993 	u64_stats_update_end(&rx_ring->syncp);
994 	q_vector->rx.total_packets += total_rx_packets;
995 	q_vector->rx.total_bytes += total_rx_bytes;
996 
997 	return total_rx_packets;
998 }
999 
1000 /**
1001  * ixgbevf_poll - NAPI polling calback
1002  * @napi: napi struct with our devices info in it
1003  * @budget: amount of work driver is allowed to do this pass, in packets
1004  *
1005  * This function will clean more than one or more rings associated with a
1006  * q_vector.
1007  **/
1008 static int ixgbevf_poll(struct napi_struct *napi, int budget)
1009 {
1010 	struct ixgbevf_q_vector *q_vector =
1011 		container_of(napi, struct ixgbevf_q_vector, napi);
1012 	struct ixgbevf_adapter *adapter = q_vector->adapter;
1013 	struct ixgbevf_ring *ring;
1014 	int per_ring_budget, work_done = 0;
1015 	bool clean_complete = true;
1016 
1017 	ixgbevf_for_each_ring(ring, q_vector->tx) {
1018 		if (!ixgbevf_clean_tx_irq(q_vector, ring, budget))
1019 			clean_complete = false;
1020 	}
1021 
1022 	if (budget <= 0)
1023 		return budget;
1024 
1025 	/* attempt to distribute budget to each queue fairly, but don't allow
1026 	 * the budget to go below 1 because we'll exit polling
1027 	 */
1028 	if (q_vector->rx.count > 1)
1029 		per_ring_budget = max(budget/q_vector->rx.count, 1);
1030 	else
1031 		per_ring_budget = budget;
1032 
1033 	ixgbevf_for_each_ring(ring, q_vector->rx) {
1034 		int cleaned = ixgbevf_clean_rx_irq(q_vector, ring,
1035 						   per_ring_budget);
1036 		work_done += cleaned;
1037 		if (cleaned >= per_ring_budget)
1038 			clean_complete = false;
1039 	}
1040 
1041 	/* If all work not completed, return budget and keep polling */
1042 	if (!clean_complete)
1043 		return budget;
1044 	/* all work done, exit the polling mode */
1045 	napi_complete_done(napi, work_done);
1046 	if (adapter->rx_itr_setting == 1)
1047 		ixgbevf_set_itr(q_vector);
1048 	if (!test_bit(__IXGBEVF_DOWN, &adapter->state) &&
1049 	    !test_bit(__IXGBEVF_REMOVING, &adapter->state))
1050 		ixgbevf_irq_enable_queues(adapter,
1051 					  BIT(q_vector->v_idx));
1052 
1053 	return 0;
1054 }
1055 
1056 /**
1057  * ixgbevf_write_eitr - write VTEITR register in hardware specific way
1058  * @q_vector: structure containing interrupt and ring information
1059  **/
1060 void ixgbevf_write_eitr(struct ixgbevf_q_vector *q_vector)
1061 {
1062 	struct ixgbevf_adapter *adapter = q_vector->adapter;
1063 	struct ixgbe_hw *hw = &adapter->hw;
1064 	int v_idx = q_vector->v_idx;
1065 	u32 itr_reg = q_vector->itr & IXGBE_MAX_EITR;
1066 
1067 	/* set the WDIS bit to not clear the timer bits and cause an
1068 	 * immediate assertion of the interrupt
1069 	 */
1070 	itr_reg |= IXGBE_EITR_CNT_WDIS;
1071 
1072 	IXGBE_WRITE_REG(hw, IXGBE_VTEITR(v_idx), itr_reg);
1073 }
1074 
1075 /**
1076  * ixgbevf_configure_msix - Configure MSI-X hardware
1077  * @adapter: board private structure
1078  *
1079  * ixgbevf_configure_msix sets up the hardware to properly generate MSI-X
1080  * interrupts.
1081  **/
1082 static void ixgbevf_configure_msix(struct ixgbevf_adapter *adapter)
1083 {
1084 	struct ixgbevf_q_vector *q_vector;
1085 	int q_vectors, v_idx;
1086 
1087 	q_vectors = adapter->num_msix_vectors - NON_Q_VECTORS;
1088 	adapter->eims_enable_mask = 0;
1089 
1090 	/* Populate the IVAR table and set the ITR values to the
1091 	 * corresponding register.
1092 	 */
1093 	for (v_idx = 0; v_idx < q_vectors; v_idx++) {
1094 		struct ixgbevf_ring *ring;
1095 
1096 		q_vector = adapter->q_vector[v_idx];
1097 
1098 		ixgbevf_for_each_ring(ring, q_vector->rx)
1099 			ixgbevf_set_ivar(adapter, 0, ring->reg_idx, v_idx);
1100 
1101 		ixgbevf_for_each_ring(ring, q_vector->tx)
1102 			ixgbevf_set_ivar(adapter, 1, ring->reg_idx, v_idx);
1103 
1104 		if (q_vector->tx.ring && !q_vector->rx.ring) {
1105 			/* Tx only vector */
1106 			if (adapter->tx_itr_setting == 1)
1107 				q_vector->itr = IXGBE_12K_ITR;
1108 			else
1109 				q_vector->itr = adapter->tx_itr_setting;
1110 		} else {
1111 			/* Rx or Rx/Tx vector */
1112 			if (adapter->rx_itr_setting == 1)
1113 				q_vector->itr = IXGBE_20K_ITR;
1114 			else
1115 				q_vector->itr = adapter->rx_itr_setting;
1116 		}
1117 
1118 		/* add q_vector eims value to global eims_enable_mask */
1119 		adapter->eims_enable_mask |= BIT(v_idx);
1120 
1121 		ixgbevf_write_eitr(q_vector);
1122 	}
1123 
1124 	ixgbevf_set_ivar(adapter, -1, 1, v_idx);
1125 	/* setup eims_other and add value to global eims_enable_mask */
1126 	adapter->eims_other = BIT(v_idx);
1127 	adapter->eims_enable_mask |= adapter->eims_other;
1128 }
1129 
1130 enum latency_range {
1131 	lowest_latency = 0,
1132 	low_latency = 1,
1133 	bulk_latency = 2,
1134 	latency_invalid = 255
1135 };
1136 
1137 /**
1138  * ixgbevf_update_itr - update the dynamic ITR value based on statistics
1139  * @q_vector: structure containing interrupt and ring information
1140  * @ring_container: structure containing ring performance data
1141  *
1142  * Stores a new ITR value based on packets and byte
1143  * counts during the last interrupt.  The advantage of per interrupt
1144  * computation is faster updates and more accurate ITR for the current
1145  * traffic pattern.  Constants in this function were computed
1146  * based on theoretical maximum wire speed and thresholds were set based
1147  * on testing data as well as attempting to minimize response time
1148  * while increasing bulk throughput.
1149  **/
1150 static void ixgbevf_update_itr(struct ixgbevf_q_vector *q_vector,
1151 			       struct ixgbevf_ring_container *ring_container)
1152 {
1153 	int bytes = ring_container->total_bytes;
1154 	int packets = ring_container->total_packets;
1155 	u32 timepassed_us;
1156 	u64 bytes_perint;
1157 	u8 itr_setting = ring_container->itr;
1158 
1159 	if (packets == 0)
1160 		return;
1161 
1162 	/* simple throttle rate management
1163 	 *    0-20MB/s lowest (100000 ints/s)
1164 	 *   20-100MB/s low   (20000 ints/s)
1165 	 *  100-1249MB/s bulk (12000 ints/s)
1166 	 */
1167 	/* what was last interrupt timeslice? */
1168 	timepassed_us = q_vector->itr >> 2;
1169 	bytes_perint = bytes / timepassed_us; /* bytes/usec */
1170 
1171 	switch (itr_setting) {
1172 	case lowest_latency:
1173 		if (bytes_perint > 10)
1174 			itr_setting = low_latency;
1175 		break;
1176 	case low_latency:
1177 		if (bytes_perint > 20)
1178 			itr_setting = bulk_latency;
1179 		else if (bytes_perint <= 10)
1180 			itr_setting = lowest_latency;
1181 		break;
1182 	case bulk_latency:
1183 		if (bytes_perint <= 20)
1184 			itr_setting = low_latency;
1185 		break;
1186 	}
1187 
1188 	/* clear work counters since we have the values we need */
1189 	ring_container->total_bytes = 0;
1190 	ring_container->total_packets = 0;
1191 
1192 	/* write updated itr to ring container */
1193 	ring_container->itr = itr_setting;
1194 }
1195 
1196 static void ixgbevf_set_itr(struct ixgbevf_q_vector *q_vector)
1197 {
1198 	u32 new_itr = q_vector->itr;
1199 	u8 current_itr;
1200 
1201 	ixgbevf_update_itr(q_vector, &q_vector->tx);
1202 	ixgbevf_update_itr(q_vector, &q_vector->rx);
1203 
1204 	current_itr = max(q_vector->rx.itr, q_vector->tx.itr);
1205 
1206 	switch (current_itr) {
1207 	/* counts and packets in update_itr are dependent on these numbers */
1208 	case lowest_latency:
1209 		new_itr = IXGBE_100K_ITR;
1210 		break;
1211 	case low_latency:
1212 		new_itr = IXGBE_20K_ITR;
1213 		break;
1214 	case bulk_latency:
1215 		new_itr = IXGBE_12K_ITR;
1216 		break;
1217 	default:
1218 		break;
1219 	}
1220 
1221 	if (new_itr != q_vector->itr) {
1222 		/* do an exponential smoothing */
1223 		new_itr = (10 * new_itr * q_vector->itr) /
1224 			  ((9 * new_itr) + q_vector->itr);
1225 
1226 		/* save the algorithm value here */
1227 		q_vector->itr = new_itr;
1228 
1229 		ixgbevf_write_eitr(q_vector);
1230 	}
1231 }
1232 
1233 static irqreturn_t ixgbevf_msix_other(int irq, void *data)
1234 {
1235 	struct ixgbevf_adapter *adapter = data;
1236 	struct ixgbe_hw *hw = &adapter->hw;
1237 
1238 	hw->mac.get_link_status = 1;
1239 
1240 	ixgbevf_service_event_schedule(adapter);
1241 
1242 	IXGBE_WRITE_REG(hw, IXGBE_VTEIMS, adapter->eims_other);
1243 
1244 	return IRQ_HANDLED;
1245 }
1246 
1247 /**
1248  * ixgbevf_msix_clean_rings - single unshared vector rx clean (all queues)
1249  * @irq: unused
1250  * @data: pointer to our q_vector struct for this interrupt vector
1251  **/
1252 static irqreturn_t ixgbevf_msix_clean_rings(int irq, void *data)
1253 {
1254 	struct ixgbevf_q_vector *q_vector = data;
1255 
1256 	/* EIAM disabled interrupts (on this vector) for us */
1257 	if (q_vector->rx.ring || q_vector->tx.ring)
1258 		napi_schedule_irqoff(&q_vector->napi);
1259 
1260 	return IRQ_HANDLED;
1261 }
1262 
1263 static inline void map_vector_to_rxq(struct ixgbevf_adapter *a, int v_idx,
1264 				     int r_idx)
1265 {
1266 	struct ixgbevf_q_vector *q_vector = a->q_vector[v_idx];
1267 
1268 	a->rx_ring[r_idx]->next = q_vector->rx.ring;
1269 	q_vector->rx.ring = a->rx_ring[r_idx];
1270 	q_vector->rx.count++;
1271 }
1272 
1273 static inline void map_vector_to_txq(struct ixgbevf_adapter *a, int v_idx,
1274 				     int t_idx)
1275 {
1276 	struct ixgbevf_q_vector *q_vector = a->q_vector[v_idx];
1277 
1278 	a->tx_ring[t_idx]->next = q_vector->tx.ring;
1279 	q_vector->tx.ring = a->tx_ring[t_idx];
1280 	q_vector->tx.count++;
1281 }
1282 
1283 /**
1284  * ixgbevf_map_rings_to_vectors - Maps descriptor rings to vectors
1285  * @adapter: board private structure to initialize
1286  *
1287  * This function maps descriptor rings to the queue-specific vectors
1288  * we were allotted through the MSI-X enabling code.  Ideally, we'd have
1289  * one vector per ring/queue, but on a constrained vector budget, we
1290  * group the rings as "efficiently" as possible.  You would add new
1291  * mapping configurations in here.
1292  **/
1293 static int ixgbevf_map_rings_to_vectors(struct ixgbevf_adapter *adapter)
1294 {
1295 	int q_vectors;
1296 	int v_start = 0;
1297 	int rxr_idx = 0, txr_idx = 0;
1298 	int rxr_remaining = adapter->num_rx_queues;
1299 	int txr_remaining = adapter->num_tx_queues;
1300 	int i, j;
1301 	int rqpv, tqpv;
1302 
1303 	q_vectors = adapter->num_msix_vectors - NON_Q_VECTORS;
1304 
1305 	/* The ideal configuration...
1306 	 * We have enough vectors to map one per queue.
1307 	 */
1308 	if (q_vectors == adapter->num_rx_queues + adapter->num_tx_queues) {
1309 		for (; rxr_idx < rxr_remaining; v_start++, rxr_idx++)
1310 			map_vector_to_rxq(adapter, v_start, rxr_idx);
1311 
1312 		for (; txr_idx < txr_remaining; v_start++, txr_idx++)
1313 			map_vector_to_txq(adapter, v_start, txr_idx);
1314 		return 0;
1315 	}
1316 
1317 	/* If we don't have enough vectors for a 1-to-1
1318 	 * mapping, we'll have to group them so there are
1319 	 * multiple queues per vector.
1320 	 */
1321 	/* Re-adjusting *qpv takes care of the remainder. */
1322 	for (i = v_start; i < q_vectors; i++) {
1323 		rqpv = DIV_ROUND_UP(rxr_remaining, q_vectors - i);
1324 		for (j = 0; j < rqpv; j++) {
1325 			map_vector_to_rxq(adapter, i, rxr_idx);
1326 			rxr_idx++;
1327 			rxr_remaining--;
1328 		}
1329 	}
1330 	for (i = v_start; i < q_vectors; i++) {
1331 		tqpv = DIV_ROUND_UP(txr_remaining, q_vectors - i);
1332 		for (j = 0; j < tqpv; j++) {
1333 			map_vector_to_txq(adapter, i, txr_idx);
1334 			txr_idx++;
1335 			txr_remaining--;
1336 		}
1337 	}
1338 
1339 	return 0;
1340 }
1341 
1342 /**
1343  * ixgbevf_request_msix_irqs - Initialize MSI-X interrupts
1344  * @adapter: board private structure
1345  *
1346  * ixgbevf_request_msix_irqs allocates MSI-X vectors and requests
1347  * interrupts from the kernel.
1348  **/
1349 static int ixgbevf_request_msix_irqs(struct ixgbevf_adapter *adapter)
1350 {
1351 	struct net_device *netdev = adapter->netdev;
1352 	int q_vectors = adapter->num_msix_vectors - NON_Q_VECTORS;
1353 	int vector, err;
1354 	int ri = 0, ti = 0;
1355 
1356 	for (vector = 0; vector < q_vectors; vector++) {
1357 		struct ixgbevf_q_vector *q_vector = adapter->q_vector[vector];
1358 		struct msix_entry *entry = &adapter->msix_entries[vector];
1359 
1360 		if (q_vector->tx.ring && q_vector->rx.ring) {
1361 			snprintf(q_vector->name, sizeof(q_vector->name) - 1,
1362 				 "%s-%s-%d", netdev->name, "TxRx", ri++);
1363 			ti++;
1364 		} else if (q_vector->rx.ring) {
1365 			snprintf(q_vector->name, sizeof(q_vector->name) - 1,
1366 				 "%s-%s-%d", netdev->name, "rx", ri++);
1367 		} else if (q_vector->tx.ring) {
1368 			snprintf(q_vector->name, sizeof(q_vector->name) - 1,
1369 				 "%s-%s-%d", netdev->name, "tx", ti++);
1370 		} else {
1371 			/* skip this unused q_vector */
1372 			continue;
1373 		}
1374 		err = request_irq(entry->vector, &ixgbevf_msix_clean_rings, 0,
1375 				  q_vector->name, q_vector);
1376 		if (err) {
1377 			hw_dbg(&adapter->hw,
1378 			       "request_irq failed for MSIX interrupt Error: %d\n",
1379 			       err);
1380 			goto free_queue_irqs;
1381 		}
1382 	}
1383 
1384 	err = request_irq(adapter->msix_entries[vector].vector,
1385 			  &ixgbevf_msix_other, 0, netdev->name, adapter);
1386 	if (err) {
1387 		hw_dbg(&adapter->hw, "request_irq for msix_other failed: %d\n",
1388 		       err);
1389 		goto free_queue_irqs;
1390 	}
1391 
1392 	return 0;
1393 
1394 free_queue_irqs:
1395 	while (vector) {
1396 		vector--;
1397 		free_irq(adapter->msix_entries[vector].vector,
1398 			 adapter->q_vector[vector]);
1399 	}
1400 	/* This failure is non-recoverable - it indicates the system is
1401 	 * out of MSIX vector resources and the VF driver cannot run
1402 	 * without them.  Set the number of msix vectors to zero
1403 	 * indicating that not enough can be allocated.  The error
1404 	 * will be returned to the user indicating device open failed.
1405 	 * Any further attempts to force the driver to open will also
1406 	 * fail.  The only way to recover is to unload the driver and
1407 	 * reload it again.  If the system has recovered some MSIX
1408 	 * vectors then it may succeed.
1409 	 */
1410 	adapter->num_msix_vectors = 0;
1411 	return err;
1412 }
1413 
1414 static inline void ixgbevf_reset_q_vectors(struct ixgbevf_adapter *adapter)
1415 {
1416 	int i, q_vectors = adapter->num_msix_vectors - NON_Q_VECTORS;
1417 
1418 	for (i = 0; i < q_vectors; i++) {
1419 		struct ixgbevf_q_vector *q_vector = adapter->q_vector[i];
1420 
1421 		q_vector->rx.ring = NULL;
1422 		q_vector->tx.ring = NULL;
1423 		q_vector->rx.count = 0;
1424 		q_vector->tx.count = 0;
1425 	}
1426 }
1427 
1428 /**
1429  * ixgbevf_request_irq - initialize interrupts
1430  * @adapter: board private structure
1431  *
1432  * Attempts to configure interrupts using the best available
1433  * capabilities of the hardware and kernel.
1434  **/
1435 static int ixgbevf_request_irq(struct ixgbevf_adapter *adapter)
1436 {
1437 	int err = ixgbevf_request_msix_irqs(adapter);
1438 
1439 	if (err)
1440 		hw_dbg(&adapter->hw, "request_irq failed, Error %d\n", err);
1441 
1442 	return err;
1443 }
1444 
1445 static void ixgbevf_free_irq(struct ixgbevf_adapter *adapter)
1446 {
1447 	int i, q_vectors;
1448 
1449 	if (!adapter->msix_entries)
1450 		return;
1451 
1452 	q_vectors = adapter->num_msix_vectors;
1453 	i = q_vectors - 1;
1454 
1455 	free_irq(adapter->msix_entries[i].vector, adapter);
1456 	i--;
1457 
1458 	for (; i >= 0; i--) {
1459 		/* free only the irqs that were actually requested */
1460 		if (!adapter->q_vector[i]->rx.ring &&
1461 		    !adapter->q_vector[i]->tx.ring)
1462 			continue;
1463 
1464 		free_irq(adapter->msix_entries[i].vector,
1465 			 adapter->q_vector[i]);
1466 	}
1467 
1468 	ixgbevf_reset_q_vectors(adapter);
1469 }
1470 
1471 /**
1472  * ixgbevf_irq_disable - Mask off interrupt generation on the NIC
1473  * @adapter: board private structure
1474  **/
1475 static inline void ixgbevf_irq_disable(struct ixgbevf_adapter *adapter)
1476 {
1477 	struct ixgbe_hw *hw = &adapter->hw;
1478 	int i;
1479 
1480 	IXGBE_WRITE_REG(hw, IXGBE_VTEIAM, 0);
1481 	IXGBE_WRITE_REG(hw, IXGBE_VTEIMC, ~0);
1482 	IXGBE_WRITE_REG(hw, IXGBE_VTEIAC, 0);
1483 
1484 	IXGBE_WRITE_FLUSH(hw);
1485 
1486 	for (i = 0; i < adapter->num_msix_vectors; i++)
1487 		synchronize_irq(adapter->msix_entries[i].vector);
1488 }
1489 
1490 /**
1491  * ixgbevf_irq_enable - Enable default interrupt generation settings
1492  * @adapter: board private structure
1493  **/
1494 static inline void ixgbevf_irq_enable(struct ixgbevf_adapter *adapter)
1495 {
1496 	struct ixgbe_hw *hw = &adapter->hw;
1497 
1498 	IXGBE_WRITE_REG(hw, IXGBE_VTEIAM, adapter->eims_enable_mask);
1499 	IXGBE_WRITE_REG(hw, IXGBE_VTEIAC, adapter->eims_enable_mask);
1500 	IXGBE_WRITE_REG(hw, IXGBE_VTEIMS, adapter->eims_enable_mask);
1501 }
1502 
1503 /**
1504  * ixgbevf_configure_tx_ring - Configure 82599 VF Tx ring after Reset
1505  * @adapter: board private structure
1506  * @ring: structure containing ring specific data
1507  *
1508  * Configure the Tx descriptor ring after a reset.
1509  **/
1510 static void ixgbevf_configure_tx_ring(struct ixgbevf_adapter *adapter,
1511 				      struct ixgbevf_ring *ring)
1512 {
1513 	struct ixgbe_hw *hw = &adapter->hw;
1514 	u64 tdba = ring->dma;
1515 	int wait_loop = 10;
1516 	u32 txdctl = IXGBE_TXDCTL_ENABLE;
1517 	u8 reg_idx = ring->reg_idx;
1518 
1519 	/* disable queue to avoid issues while updating state */
1520 	IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(reg_idx), IXGBE_TXDCTL_SWFLSH);
1521 	IXGBE_WRITE_FLUSH(hw);
1522 
1523 	IXGBE_WRITE_REG(hw, IXGBE_VFTDBAL(reg_idx), tdba & DMA_BIT_MASK(32));
1524 	IXGBE_WRITE_REG(hw, IXGBE_VFTDBAH(reg_idx), tdba >> 32);
1525 	IXGBE_WRITE_REG(hw, IXGBE_VFTDLEN(reg_idx),
1526 			ring->count * sizeof(union ixgbe_adv_tx_desc));
1527 
1528 	/* disable head writeback */
1529 	IXGBE_WRITE_REG(hw, IXGBE_VFTDWBAH(reg_idx), 0);
1530 	IXGBE_WRITE_REG(hw, IXGBE_VFTDWBAL(reg_idx), 0);
1531 
1532 	/* enable relaxed ordering */
1533 	IXGBE_WRITE_REG(hw, IXGBE_VFDCA_TXCTRL(reg_idx),
1534 			(IXGBE_DCA_TXCTRL_DESC_RRO_EN |
1535 			 IXGBE_DCA_TXCTRL_DATA_RRO_EN));
1536 
1537 	/* reset head and tail pointers */
1538 	IXGBE_WRITE_REG(hw, IXGBE_VFTDH(reg_idx), 0);
1539 	IXGBE_WRITE_REG(hw, IXGBE_VFTDT(reg_idx), 0);
1540 	ring->tail = adapter->io_addr + IXGBE_VFTDT(reg_idx);
1541 
1542 	/* reset ntu and ntc to place SW in sync with hardwdare */
1543 	ring->next_to_clean = 0;
1544 	ring->next_to_use = 0;
1545 
1546 	/* In order to avoid issues WTHRESH + PTHRESH should always be equal
1547 	 * to or less than the number of on chip descriptors, which is
1548 	 * currently 40.
1549 	 */
1550 	txdctl |= (8 << 16);    /* WTHRESH = 8 */
1551 
1552 	/* Setting PTHRESH to 32 both improves performance */
1553 	txdctl |= (1u << 8) |    /* HTHRESH = 1 */
1554 		   32;           /* PTHRESH = 32 */
1555 
1556 	clear_bit(__IXGBEVF_HANG_CHECK_ARMED, &ring->state);
1557 
1558 	IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(reg_idx), txdctl);
1559 
1560 	/* poll to verify queue is enabled */
1561 	do {
1562 		usleep_range(1000, 2000);
1563 		txdctl = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(reg_idx));
1564 	}  while (--wait_loop && !(txdctl & IXGBE_TXDCTL_ENABLE));
1565 	if (!wait_loop)
1566 		hw_dbg(hw, "Could not enable Tx Queue %d\n", reg_idx);
1567 }
1568 
1569 /**
1570  * ixgbevf_configure_tx - Configure 82599 VF Transmit Unit after Reset
1571  * @adapter: board private structure
1572  *
1573  * Configure the Tx unit of the MAC after a reset.
1574  **/
1575 static void ixgbevf_configure_tx(struct ixgbevf_adapter *adapter)
1576 {
1577 	u32 i;
1578 
1579 	/* Setup the HW Tx Head and Tail descriptor pointers */
1580 	for (i = 0; i < adapter->num_tx_queues; i++)
1581 		ixgbevf_configure_tx_ring(adapter, adapter->tx_ring[i]);
1582 }
1583 
1584 #define IXGBE_SRRCTL_BSIZEHDRSIZE_SHIFT	2
1585 
1586 static void ixgbevf_configure_srrctl(struct ixgbevf_adapter *adapter, int index)
1587 {
1588 	struct ixgbe_hw *hw = &adapter->hw;
1589 	u32 srrctl;
1590 
1591 	srrctl = IXGBE_SRRCTL_DROP_EN;
1592 
1593 	srrctl |= IXGBEVF_RX_HDR_SIZE << IXGBE_SRRCTL_BSIZEHDRSIZE_SHIFT;
1594 	srrctl |= IXGBEVF_RX_BUFSZ >> IXGBE_SRRCTL_BSIZEPKT_SHIFT;
1595 	srrctl |= IXGBE_SRRCTL_DESCTYPE_ADV_ONEBUF;
1596 
1597 	IXGBE_WRITE_REG(hw, IXGBE_VFSRRCTL(index), srrctl);
1598 }
1599 
1600 static void ixgbevf_setup_psrtype(struct ixgbevf_adapter *adapter)
1601 {
1602 	struct ixgbe_hw *hw = &adapter->hw;
1603 
1604 	/* PSRTYPE must be initialized in 82599 */
1605 	u32 psrtype = IXGBE_PSRTYPE_TCPHDR | IXGBE_PSRTYPE_UDPHDR |
1606 		      IXGBE_PSRTYPE_IPV4HDR | IXGBE_PSRTYPE_IPV6HDR |
1607 		      IXGBE_PSRTYPE_L2HDR;
1608 
1609 	if (adapter->num_rx_queues > 1)
1610 		psrtype |= BIT(29);
1611 
1612 	IXGBE_WRITE_REG(hw, IXGBE_VFPSRTYPE, psrtype);
1613 }
1614 
1615 #define IXGBEVF_MAX_RX_DESC_POLL 10
1616 static void ixgbevf_disable_rx_queue(struct ixgbevf_adapter *adapter,
1617 				     struct ixgbevf_ring *ring)
1618 {
1619 	struct ixgbe_hw *hw = &adapter->hw;
1620 	int wait_loop = IXGBEVF_MAX_RX_DESC_POLL;
1621 	u32 rxdctl;
1622 	u8 reg_idx = ring->reg_idx;
1623 
1624 	if (IXGBE_REMOVED(hw->hw_addr))
1625 		return;
1626 	rxdctl = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(reg_idx));
1627 	rxdctl &= ~IXGBE_RXDCTL_ENABLE;
1628 
1629 	/* write value back with RXDCTL.ENABLE bit cleared */
1630 	IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(reg_idx), rxdctl);
1631 
1632 	/* the hardware may take up to 100us to really disable the Rx queue */
1633 	do {
1634 		udelay(10);
1635 		rxdctl = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(reg_idx));
1636 	} while (--wait_loop && (rxdctl & IXGBE_RXDCTL_ENABLE));
1637 
1638 	if (!wait_loop)
1639 		pr_err("RXDCTL.ENABLE queue %d not cleared while polling\n",
1640 		       reg_idx);
1641 }
1642 
1643 static void ixgbevf_rx_desc_queue_enable(struct ixgbevf_adapter *adapter,
1644 					 struct ixgbevf_ring *ring)
1645 {
1646 	struct ixgbe_hw *hw = &adapter->hw;
1647 	int wait_loop = IXGBEVF_MAX_RX_DESC_POLL;
1648 	u32 rxdctl;
1649 	u8 reg_idx = ring->reg_idx;
1650 
1651 	if (IXGBE_REMOVED(hw->hw_addr))
1652 		return;
1653 	do {
1654 		usleep_range(1000, 2000);
1655 		rxdctl = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(reg_idx));
1656 	} while (--wait_loop && !(rxdctl & IXGBE_RXDCTL_ENABLE));
1657 
1658 	if (!wait_loop)
1659 		pr_err("RXDCTL.ENABLE queue %d not set while polling\n",
1660 		       reg_idx);
1661 }
1662 
1663 /**
1664  * ixgbevf_init_rss_key - Initialize adapter RSS key
1665  * @adapter: device handle
1666  *
1667  * Allocates and initializes the RSS key if it is not allocated.
1668  **/
1669 static inline int ixgbevf_init_rss_key(struct ixgbevf_adapter *adapter)
1670 {
1671 	u32 *rss_key;
1672 
1673 	if (!adapter->rss_key) {
1674 		rss_key = kzalloc(IXGBEVF_RSS_HASH_KEY_SIZE, GFP_KERNEL);
1675 		if (unlikely(!rss_key))
1676 			return -ENOMEM;
1677 
1678 		netdev_rss_key_fill(rss_key, IXGBEVF_RSS_HASH_KEY_SIZE);
1679 		adapter->rss_key = rss_key;
1680 	}
1681 
1682 	return 0;
1683 }
1684 
1685 static void ixgbevf_setup_vfmrqc(struct ixgbevf_adapter *adapter)
1686 {
1687 	struct ixgbe_hw *hw = &adapter->hw;
1688 	u32 vfmrqc = 0, vfreta = 0;
1689 	u16 rss_i = adapter->num_rx_queues;
1690 	u8 i, j;
1691 
1692 	/* Fill out hash function seeds */
1693 	for (i = 0; i < IXGBEVF_VFRSSRK_REGS; i++)
1694 		IXGBE_WRITE_REG(hw, IXGBE_VFRSSRK(i), *(adapter->rss_key + i));
1695 
1696 	for (i = 0, j = 0; i < IXGBEVF_X550_VFRETA_SIZE; i++, j++) {
1697 		if (j == rss_i)
1698 			j = 0;
1699 
1700 		adapter->rss_indir_tbl[i] = j;
1701 
1702 		vfreta |= j << (i & 0x3) * 8;
1703 		if ((i & 3) == 3) {
1704 			IXGBE_WRITE_REG(hw, IXGBE_VFRETA(i >> 2), vfreta);
1705 			vfreta = 0;
1706 		}
1707 	}
1708 
1709 	/* Perform hash on these packet types */
1710 	vfmrqc |= IXGBE_VFMRQC_RSS_FIELD_IPV4 |
1711 		IXGBE_VFMRQC_RSS_FIELD_IPV4_TCP |
1712 		IXGBE_VFMRQC_RSS_FIELD_IPV6 |
1713 		IXGBE_VFMRQC_RSS_FIELD_IPV6_TCP;
1714 
1715 	vfmrqc |= IXGBE_VFMRQC_RSSEN;
1716 
1717 	IXGBE_WRITE_REG(hw, IXGBE_VFMRQC, vfmrqc);
1718 }
1719 
1720 static void ixgbevf_configure_rx_ring(struct ixgbevf_adapter *adapter,
1721 				      struct ixgbevf_ring *ring)
1722 {
1723 	struct ixgbe_hw *hw = &adapter->hw;
1724 	u64 rdba = ring->dma;
1725 	u32 rxdctl;
1726 	u8 reg_idx = ring->reg_idx;
1727 
1728 	/* disable queue to avoid issues while updating state */
1729 	rxdctl = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(reg_idx));
1730 	ixgbevf_disable_rx_queue(adapter, ring);
1731 
1732 	IXGBE_WRITE_REG(hw, IXGBE_VFRDBAL(reg_idx), rdba & DMA_BIT_MASK(32));
1733 	IXGBE_WRITE_REG(hw, IXGBE_VFRDBAH(reg_idx), rdba >> 32);
1734 	IXGBE_WRITE_REG(hw, IXGBE_VFRDLEN(reg_idx),
1735 			ring->count * sizeof(union ixgbe_adv_rx_desc));
1736 
1737 #ifndef CONFIG_SPARC
1738 	/* enable relaxed ordering */
1739 	IXGBE_WRITE_REG(hw, IXGBE_VFDCA_RXCTRL(reg_idx),
1740 			IXGBE_DCA_RXCTRL_DESC_RRO_EN);
1741 #else
1742 	IXGBE_WRITE_REG(hw, IXGBE_VFDCA_RXCTRL(reg_idx),
1743 			IXGBE_DCA_RXCTRL_DESC_RRO_EN |
1744 			IXGBE_DCA_RXCTRL_DATA_WRO_EN);
1745 #endif
1746 
1747 	/* reset head and tail pointers */
1748 	IXGBE_WRITE_REG(hw, IXGBE_VFRDH(reg_idx), 0);
1749 	IXGBE_WRITE_REG(hw, IXGBE_VFRDT(reg_idx), 0);
1750 	ring->tail = adapter->io_addr + IXGBE_VFRDT(reg_idx);
1751 
1752 	/* reset ntu and ntc to place SW in sync with hardwdare */
1753 	ring->next_to_clean = 0;
1754 	ring->next_to_use = 0;
1755 	ring->next_to_alloc = 0;
1756 
1757 	ixgbevf_configure_srrctl(adapter, reg_idx);
1758 
1759 	/* allow any size packet since we can handle overflow */
1760 	rxdctl &= ~IXGBE_RXDCTL_RLPML_EN;
1761 
1762 	rxdctl |= IXGBE_RXDCTL_ENABLE | IXGBE_RXDCTL_VME;
1763 	IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(reg_idx), rxdctl);
1764 
1765 	ixgbevf_rx_desc_queue_enable(adapter, ring);
1766 	ixgbevf_alloc_rx_buffers(ring, ixgbevf_desc_unused(ring));
1767 }
1768 
1769 /**
1770  * ixgbevf_configure_rx - Configure 82599 VF Receive Unit after Reset
1771  * @adapter: board private structure
1772  *
1773  * Configure the Rx unit of the MAC after a reset.
1774  **/
1775 static void ixgbevf_configure_rx(struct ixgbevf_adapter *adapter)
1776 {
1777 	struct ixgbe_hw *hw = &adapter->hw;
1778 	struct net_device *netdev = adapter->netdev;
1779 	int i, ret;
1780 
1781 	ixgbevf_setup_psrtype(adapter);
1782 	if (hw->mac.type >= ixgbe_mac_X550_vf)
1783 		ixgbevf_setup_vfmrqc(adapter);
1784 
1785 	spin_lock_bh(&adapter->mbx_lock);
1786 	/* notify the PF of our intent to use this size of frame */
1787 	ret = hw->mac.ops.set_rlpml(hw, netdev->mtu + ETH_HLEN + ETH_FCS_LEN);
1788 	spin_unlock_bh(&adapter->mbx_lock);
1789 	if (ret)
1790 		dev_err(&adapter->pdev->dev,
1791 			"Failed to set MTU at %d\n", netdev->mtu);
1792 
1793 	/* Setup the HW Rx Head and Tail Descriptor Pointers and
1794 	 * the Base and Length of the Rx Descriptor Ring
1795 	 */
1796 	for (i = 0; i < adapter->num_rx_queues; i++)
1797 		ixgbevf_configure_rx_ring(adapter, adapter->rx_ring[i]);
1798 }
1799 
1800 static int ixgbevf_vlan_rx_add_vid(struct net_device *netdev,
1801 				   __be16 proto, u16 vid)
1802 {
1803 	struct ixgbevf_adapter *adapter = netdev_priv(netdev);
1804 	struct ixgbe_hw *hw = &adapter->hw;
1805 	int err;
1806 
1807 	spin_lock_bh(&adapter->mbx_lock);
1808 
1809 	/* add VID to filter table */
1810 	err = hw->mac.ops.set_vfta(hw, vid, 0, true);
1811 
1812 	spin_unlock_bh(&adapter->mbx_lock);
1813 
1814 	/* translate error return types so error makes sense */
1815 	if (err == IXGBE_ERR_MBX)
1816 		return -EIO;
1817 
1818 	if (err == IXGBE_ERR_INVALID_ARGUMENT)
1819 		return -EACCES;
1820 
1821 	set_bit(vid, adapter->active_vlans);
1822 
1823 	return err;
1824 }
1825 
1826 static int ixgbevf_vlan_rx_kill_vid(struct net_device *netdev,
1827 				    __be16 proto, u16 vid)
1828 {
1829 	struct ixgbevf_adapter *adapter = netdev_priv(netdev);
1830 	struct ixgbe_hw *hw = &adapter->hw;
1831 	int err;
1832 
1833 	spin_lock_bh(&adapter->mbx_lock);
1834 
1835 	/* remove VID from filter table */
1836 	err = hw->mac.ops.set_vfta(hw, vid, 0, false);
1837 
1838 	spin_unlock_bh(&adapter->mbx_lock);
1839 
1840 	clear_bit(vid, adapter->active_vlans);
1841 
1842 	return err;
1843 }
1844 
1845 static void ixgbevf_restore_vlan(struct ixgbevf_adapter *adapter)
1846 {
1847 	u16 vid;
1848 
1849 	for_each_set_bit(vid, adapter->active_vlans, VLAN_N_VID)
1850 		ixgbevf_vlan_rx_add_vid(adapter->netdev,
1851 					htons(ETH_P_8021Q), vid);
1852 }
1853 
1854 static int ixgbevf_write_uc_addr_list(struct net_device *netdev)
1855 {
1856 	struct ixgbevf_adapter *adapter = netdev_priv(netdev);
1857 	struct ixgbe_hw *hw = &adapter->hw;
1858 	int count = 0;
1859 
1860 	if ((netdev_uc_count(netdev)) > 10) {
1861 		pr_err("Too many unicast filters - No Space\n");
1862 		return -ENOSPC;
1863 	}
1864 
1865 	if (!netdev_uc_empty(netdev)) {
1866 		struct netdev_hw_addr *ha;
1867 
1868 		netdev_for_each_uc_addr(ha, netdev) {
1869 			hw->mac.ops.set_uc_addr(hw, ++count, ha->addr);
1870 			udelay(200);
1871 		}
1872 	} else {
1873 		/* If the list is empty then send message to PF driver to
1874 		 * clear all MAC VLANs on this VF.
1875 		 */
1876 		hw->mac.ops.set_uc_addr(hw, 0, NULL);
1877 	}
1878 
1879 	return count;
1880 }
1881 
1882 /**
1883  * ixgbevf_set_rx_mode - Multicast and unicast set
1884  * @netdev: network interface device structure
1885  *
1886  * The set_rx_method entry point is called whenever the multicast address
1887  * list, unicast address list or the network interface flags are updated.
1888  * This routine is responsible for configuring the hardware for proper
1889  * multicast mode and configuring requested unicast filters.
1890  **/
1891 static void ixgbevf_set_rx_mode(struct net_device *netdev)
1892 {
1893 	struct ixgbevf_adapter *adapter = netdev_priv(netdev);
1894 	struct ixgbe_hw *hw = &adapter->hw;
1895 	unsigned int flags = netdev->flags;
1896 	int xcast_mode;
1897 
1898 	xcast_mode = (flags & IFF_ALLMULTI) ? IXGBEVF_XCAST_MODE_ALLMULTI :
1899 		     (flags & (IFF_BROADCAST | IFF_MULTICAST)) ?
1900 		     IXGBEVF_XCAST_MODE_MULTI : IXGBEVF_XCAST_MODE_NONE;
1901 
1902 	/* request the most inclusive mode we need */
1903 	if (flags & IFF_PROMISC)
1904 		xcast_mode = IXGBEVF_XCAST_MODE_PROMISC;
1905 	else if (flags & IFF_ALLMULTI)
1906 		xcast_mode = IXGBEVF_XCAST_MODE_ALLMULTI;
1907 	else if (flags & (IFF_BROADCAST | IFF_MULTICAST))
1908 		xcast_mode = IXGBEVF_XCAST_MODE_MULTI;
1909 	else
1910 		xcast_mode = IXGBEVF_XCAST_MODE_NONE;
1911 
1912 	spin_lock_bh(&adapter->mbx_lock);
1913 
1914 	hw->mac.ops.update_xcast_mode(hw, xcast_mode);
1915 
1916 	/* reprogram multicast list */
1917 	hw->mac.ops.update_mc_addr_list(hw, netdev);
1918 
1919 	ixgbevf_write_uc_addr_list(netdev);
1920 
1921 	spin_unlock_bh(&adapter->mbx_lock);
1922 }
1923 
1924 static void ixgbevf_napi_enable_all(struct ixgbevf_adapter *adapter)
1925 {
1926 	int q_idx;
1927 	struct ixgbevf_q_vector *q_vector;
1928 	int q_vectors = adapter->num_msix_vectors - NON_Q_VECTORS;
1929 
1930 	for (q_idx = 0; q_idx < q_vectors; q_idx++) {
1931 		q_vector = adapter->q_vector[q_idx];
1932 		napi_enable(&q_vector->napi);
1933 	}
1934 }
1935 
1936 static void ixgbevf_napi_disable_all(struct ixgbevf_adapter *adapter)
1937 {
1938 	int q_idx;
1939 	struct ixgbevf_q_vector *q_vector;
1940 	int q_vectors = adapter->num_msix_vectors - NON_Q_VECTORS;
1941 
1942 	for (q_idx = 0; q_idx < q_vectors; q_idx++) {
1943 		q_vector = adapter->q_vector[q_idx];
1944 		napi_disable(&q_vector->napi);
1945 	}
1946 }
1947 
1948 static int ixgbevf_configure_dcb(struct ixgbevf_adapter *adapter)
1949 {
1950 	struct ixgbe_hw *hw = &adapter->hw;
1951 	unsigned int def_q = 0;
1952 	unsigned int num_tcs = 0;
1953 	unsigned int num_rx_queues = adapter->num_rx_queues;
1954 	unsigned int num_tx_queues = adapter->num_tx_queues;
1955 	int err;
1956 
1957 	spin_lock_bh(&adapter->mbx_lock);
1958 
1959 	/* fetch queue configuration from the PF */
1960 	err = ixgbevf_get_queues(hw, &num_tcs, &def_q);
1961 
1962 	spin_unlock_bh(&adapter->mbx_lock);
1963 
1964 	if (err)
1965 		return err;
1966 
1967 	if (num_tcs > 1) {
1968 		/* we need only one Tx queue */
1969 		num_tx_queues = 1;
1970 
1971 		/* update default Tx ring register index */
1972 		adapter->tx_ring[0]->reg_idx = def_q;
1973 
1974 		/* we need as many queues as traffic classes */
1975 		num_rx_queues = num_tcs;
1976 	}
1977 
1978 	/* if we have a bad config abort request queue reset */
1979 	if ((adapter->num_rx_queues != num_rx_queues) ||
1980 	    (adapter->num_tx_queues != num_tx_queues)) {
1981 		/* force mailbox timeout to prevent further messages */
1982 		hw->mbx.timeout = 0;
1983 
1984 		/* wait for watchdog to come around and bail us out */
1985 		set_bit(__IXGBEVF_QUEUE_RESET_REQUESTED, &adapter->state);
1986 	}
1987 
1988 	return 0;
1989 }
1990 
1991 static void ixgbevf_configure(struct ixgbevf_adapter *adapter)
1992 {
1993 	ixgbevf_configure_dcb(adapter);
1994 
1995 	ixgbevf_set_rx_mode(adapter->netdev);
1996 
1997 	ixgbevf_restore_vlan(adapter);
1998 
1999 	ixgbevf_configure_tx(adapter);
2000 	ixgbevf_configure_rx(adapter);
2001 }
2002 
2003 static void ixgbevf_save_reset_stats(struct ixgbevf_adapter *adapter)
2004 {
2005 	/* Only save pre-reset stats if there are some */
2006 	if (adapter->stats.vfgprc || adapter->stats.vfgptc) {
2007 		adapter->stats.saved_reset_vfgprc += adapter->stats.vfgprc -
2008 			adapter->stats.base_vfgprc;
2009 		adapter->stats.saved_reset_vfgptc += adapter->stats.vfgptc -
2010 			adapter->stats.base_vfgptc;
2011 		adapter->stats.saved_reset_vfgorc += adapter->stats.vfgorc -
2012 			adapter->stats.base_vfgorc;
2013 		adapter->stats.saved_reset_vfgotc += adapter->stats.vfgotc -
2014 			adapter->stats.base_vfgotc;
2015 		adapter->stats.saved_reset_vfmprc += adapter->stats.vfmprc -
2016 			adapter->stats.base_vfmprc;
2017 	}
2018 }
2019 
2020 static void ixgbevf_init_last_counter_stats(struct ixgbevf_adapter *adapter)
2021 {
2022 	struct ixgbe_hw *hw = &adapter->hw;
2023 
2024 	adapter->stats.last_vfgprc = IXGBE_READ_REG(hw, IXGBE_VFGPRC);
2025 	adapter->stats.last_vfgorc = IXGBE_READ_REG(hw, IXGBE_VFGORC_LSB);
2026 	adapter->stats.last_vfgorc |=
2027 		(((u64)(IXGBE_READ_REG(hw, IXGBE_VFGORC_MSB))) << 32);
2028 	adapter->stats.last_vfgptc = IXGBE_READ_REG(hw, IXGBE_VFGPTC);
2029 	adapter->stats.last_vfgotc = IXGBE_READ_REG(hw, IXGBE_VFGOTC_LSB);
2030 	adapter->stats.last_vfgotc |=
2031 		(((u64)(IXGBE_READ_REG(hw, IXGBE_VFGOTC_MSB))) << 32);
2032 	adapter->stats.last_vfmprc = IXGBE_READ_REG(hw, IXGBE_VFMPRC);
2033 
2034 	adapter->stats.base_vfgprc = adapter->stats.last_vfgprc;
2035 	adapter->stats.base_vfgorc = adapter->stats.last_vfgorc;
2036 	adapter->stats.base_vfgptc = adapter->stats.last_vfgptc;
2037 	adapter->stats.base_vfgotc = adapter->stats.last_vfgotc;
2038 	adapter->stats.base_vfmprc = adapter->stats.last_vfmprc;
2039 }
2040 
2041 static void ixgbevf_negotiate_api(struct ixgbevf_adapter *adapter)
2042 {
2043 	struct ixgbe_hw *hw = &adapter->hw;
2044 	int api[] = { ixgbe_mbox_api_13,
2045 		      ixgbe_mbox_api_12,
2046 		      ixgbe_mbox_api_11,
2047 		      ixgbe_mbox_api_10,
2048 		      ixgbe_mbox_api_unknown };
2049 	int err, idx = 0;
2050 
2051 	spin_lock_bh(&adapter->mbx_lock);
2052 
2053 	while (api[idx] != ixgbe_mbox_api_unknown) {
2054 		err = hw->mac.ops.negotiate_api_version(hw, api[idx]);
2055 		if (!err)
2056 			break;
2057 		idx++;
2058 	}
2059 
2060 	spin_unlock_bh(&adapter->mbx_lock);
2061 }
2062 
2063 static void ixgbevf_up_complete(struct ixgbevf_adapter *adapter)
2064 {
2065 	struct net_device *netdev = adapter->netdev;
2066 	struct ixgbe_hw *hw = &adapter->hw;
2067 
2068 	ixgbevf_configure_msix(adapter);
2069 
2070 	spin_lock_bh(&adapter->mbx_lock);
2071 
2072 	if (is_valid_ether_addr(hw->mac.addr))
2073 		hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0);
2074 	else
2075 		hw->mac.ops.set_rar(hw, 0, hw->mac.perm_addr, 0);
2076 
2077 	spin_unlock_bh(&adapter->mbx_lock);
2078 
2079 	smp_mb__before_atomic();
2080 	clear_bit(__IXGBEVF_DOWN, &adapter->state);
2081 	ixgbevf_napi_enable_all(adapter);
2082 
2083 	/* clear any pending interrupts, may auto mask */
2084 	IXGBE_READ_REG(hw, IXGBE_VTEICR);
2085 	ixgbevf_irq_enable(adapter);
2086 
2087 	/* enable transmits */
2088 	netif_tx_start_all_queues(netdev);
2089 
2090 	ixgbevf_save_reset_stats(adapter);
2091 	ixgbevf_init_last_counter_stats(adapter);
2092 
2093 	hw->mac.get_link_status = 1;
2094 	mod_timer(&adapter->service_timer, jiffies);
2095 }
2096 
2097 void ixgbevf_up(struct ixgbevf_adapter *adapter)
2098 {
2099 	ixgbevf_configure(adapter);
2100 
2101 	ixgbevf_up_complete(adapter);
2102 }
2103 
2104 /**
2105  * ixgbevf_clean_rx_ring - Free Rx Buffers per Queue
2106  * @rx_ring: ring to free buffers from
2107  **/
2108 static void ixgbevf_clean_rx_ring(struct ixgbevf_ring *rx_ring)
2109 {
2110 	struct device *dev = rx_ring->dev;
2111 	unsigned long size;
2112 	unsigned int i;
2113 
2114 	/* Free Rx ring sk_buff */
2115 	if (rx_ring->skb) {
2116 		dev_kfree_skb(rx_ring->skb);
2117 		rx_ring->skb = NULL;
2118 	}
2119 
2120 	/* ring already cleared, nothing to do */
2121 	if (!rx_ring->rx_buffer_info)
2122 		return;
2123 
2124 	/* Free all the Rx ring pages */
2125 	for (i = 0; i < rx_ring->count; i++) {
2126 		struct ixgbevf_rx_buffer *rx_buffer;
2127 
2128 		rx_buffer = &rx_ring->rx_buffer_info[i];
2129 		if (rx_buffer->dma)
2130 			dma_unmap_page(dev, rx_buffer->dma,
2131 				       PAGE_SIZE, DMA_FROM_DEVICE);
2132 		rx_buffer->dma = 0;
2133 		if (rx_buffer->page)
2134 			__free_page(rx_buffer->page);
2135 		rx_buffer->page = NULL;
2136 	}
2137 
2138 	size = sizeof(struct ixgbevf_rx_buffer) * rx_ring->count;
2139 	memset(rx_ring->rx_buffer_info, 0, size);
2140 
2141 	/* Zero out the descriptor ring */
2142 	memset(rx_ring->desc, 0, rx_ring->size);
2143 }
2144 
2145 /**
2146  * ixgbevf_clean_tx_ring - Free Tx Buffers
2147  * @tx_ring: ring to be cleaned
2148  **/
2149 static void ixgbevf_clean_tx_ring(struct ixgbevf_ring *tx_ring)
2150 {
2151 	struct ixgbevf_tx_buffer *tx_buffer_info;
2152 	unsigned long size;
2153 	unsigned int i;
2154 
2155 	if (!tx_ring->tx_buffer_info)
2156 		return;
2157 
2158 	/* Free all the Tx ring sk_buffs */
2159 	for (i = 0; i < tx_ring->count; i++) {
2160 		tx_buffer_info = &tx_ring->tx_buffer_info[i];
2161 		ixgbevf_unmap_and_free_tx_resource(tx_ring, tx_buffer_info);
2162 	}
2163 
2164 	size = sizeof(struct ixgbevf_tx_buffer) * tx_ring->count;
2165 	memset(tx_ring->tx_buffer_info, 0, size);
2166 
2167 	memset(tx_ring->desc, 0, tx_ring->size);
2168 }
2169 
2170 /**
2171  * ixgbevf_clean_all_rx_rings - Free Rx Buffers for all queues
2172  * @adapter: board private structure
2173  **/
2174 static void ixgbevf_clean_all_rx_rings(struct ixgbevf_adapter *adapter)
2175 {
2176 	int i;
2177 
2178 	for (i = 0; i < adapter->num_rx_queues; i++)
2179 		ixgbevf_clean_rx_ring(adapter->rx_ring[i]);
2180 }
2181 
2182 /**
2183  * ixgbevf_clean_all_tx_rings - Free Tx Buffers for all queues
2184  * @adapter: board private structure
2185  **/
2186 static void ixgbevf_clean_all_tx_rings(struct ixgbevf_adapter *adapter)
2187 {
2188 	int i;
2189 
2190 	for (i = 0; i < adapter->num_tx_queues; i++)
2191 		ixgbevf_clean_tx_ring(adapter->tx_ring[i]);
2192 }
2193 
2194 void ixgbevf_down(struct ixgbevf_adapter *adapter)
2195 {
2196 	struct net_device *netdev = adapter->netdev;
2197 	struct ixgbe_hw *hw = &adapter->hw;
2198 	int i;
2199 
2200 	/* signal that we are down to the interrupt handler */
2201 	if (test_and_set_bit(__IXGBEVF_DOWN, &adapter->state))
2202 		return; /* do nothing if already down */
2203 
2204 	/* disable all enabled Rx queues */
2205 	for (i = 0; i < adapter->num_rx_queues; i++)
2206 		ixgbevf_disable_rx_queue(adapter, adapter->rx_ring[i]);
2207 
2208 	usleep_range(10000, 20000);
2209 
2210 	netif_tx_stop_all_queues(netdev);
2211 
2212 	/* call carrier off first to avoid false dev_watchdog timeouts */
2213 	netif_carrier_off(netdev);
2214 	netif_tx_disable(netdev);
2215 
2216 	ixgbevf_irq_disable(adapter);
2217 
2218 	ixgbevf_napi_disable_all(adapter);
2219 
2220 	del_timer_sync(&adapter->service_timer);
2221 
2222 	/* disable transmits in the hardware now that interrupts are off */
2223 	for (i = 0; i < adapter->num_tx_queues; i++) {
2224 		u8 reg_idx = adapter->tx_ring[i]->reg_idx;
2225 
2226 		IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(reg_idx),
2227 				IXGBE_TXDCTL_SWFLSH);
2228 	}
2229 
2230 	if (!pci_channel_offline(adapter->pdev))
2231 		ixgbevf_reset(adapter);
2232 
2233 	ixgbevf_clean_all_tx_rings(adapter);
2234 	ixgbevf_clean_all_rx_rings(adapter);
2235 }
2236 
2237 void ixgbevf_reinit_locked(struct ixgbevf_adapter *adapter)
2238 {
2239 	WARN_ON(in_interrupt());
2240 
2241 	while (test_and_set_bit(__IXGBEVF_RESETTING, &adapter->state))
2242 		msleep(1);
2243 
2244 	ixgbevf_down(adapter);
2245 	ixgbevf_up(adapter);
2246 
2247 	clear_bit(__IXGBEVF_RESETTING, &adapter->state);
2248 }
2249 
2250 void ixgbevf_reset(struct ixgbevf_adapter *adapter)
2251 {
2252 	struct ixgbe_hw *hw = &adapter->hw;
2253 	struct net_device *netdev = adapter->netdev;
2254 
2255 	if (hw->mac.ops.reset_hw(hw)) {
2256 		hw_dbg(hw, "PF still resetting\n");
2257 	} else {
2258 		hw->mac.ops.init_hw(hw);
2259 		ixgbevf_negotiate_api(adapter);
2260 	}
2261 
2262 	if (is_valid_ether_addr(adapter->hw.mac.addr)) {
2263 		ether_addr_copy(netdev->dev_addr, adapter->hw.mac.addr);
2264 		ether_addr_copy(netdev->perm_addr, adapter->hw.mac.addr);
2265 	}
2266 
2267 	adapter->last_reset = jiffies;
2268 }
2269 
2270 static int ixgbevf_acquire_msix_vectors(struct ixgbevf_adapter *adapter,
2271 					int vectors)
2272 {
2273 	int vector_threshold;
2274 
2275 	/* We'll want at least 2 (vector_threshold):
2276 	 * 1) TxQ[0] + RxQ[0] handler
2277 	 * 2) Other (Link Status Change, etc.)
2278 	 */
2279 	vector_threshold = MIN_MSIX_COUNT;
2280 
2281 	/* The more we get, the more we will assign to Tx/Rx Cleanup
2282 	 * for the separate queues...where Rx Cleanup >= Tx Cleanup.
2283 	 * Right now, we simply care about how many we'll get; we'll
2284 	 * set them up later while requesting irq's.
2285 	 */
2286 	vectors = pci_enable_msix_range(adapter->pdev, adapter->msix_entries,
2287 					vector_threshold, vectors);
2288 
2289 	if (vectors < 0) {
2290 		dev_err(&adapter->pdev->dev,
2291 			"Unable to allocate MSI-X interrupts\n");
2292 		kfree(adapter->msix_entries);
2293 		adapter->msix_entries = NULL;
2294 		return vectors;
2295 	}
2296 
2297 	/* Adjust for only the vectors we'll use, which is minimum
2298 	 * of max_msix_q_vectors + NON_Q_VECTORS, or the number of
2299 	 * vectors we were allocated.
2300 	 */
2301 	adapter->num_msix_vectors = vectors;
2302 
2303 	return 0;
2304 }
2305 
2306 /**
2307  * ixgbevf_set_num_queues - Allocate queues for device, feature dependent
2308  * @adapter: board private structure to initialize
2309  *
2310  * This is the top level queue allocation routine.  The order here is very
2311  * important, starting with the "most" number of features turned on at once,
2312  * and ending with the smallest set of features.  This way large combinations
2313  * can be allocated if they're turned on, and smaller combinations are the
2314  * fallthrough conditions.
2315  *
2316  **/
2317 static void ixgbevf_set_num_queues(struct ixgbevf_adapter *adapter)
2318 {
2319 	struct ixgbe_hw *hw = &adapter->hw;
2320 	unsigned int def_q = 0;
2321 	unsigned int num_tcs = 0;
2322 	int err;
2323 
2324 	/* Start with base case */
2325 	adapter->num_rx_queues = 1;
2326 	adapter->num_tx_queues = 1;
2327 
2328 	spin_lock_bh(&adapter->mbx_lock);
2329 
2330 	/* fetch queue configuration from the PF */
2331 	err = ixgbevf_get_queues(hw, &num_tcs, &def_q);
2332 
2333 	spin_unlock_bh(&adapter->mbx_lock);
2334 
2335 	if (err)
2336 		return;
2337 
2338 	/* we need as many queues as traffic classes */
2339 	if (num_tcs > 1) {
2340 		adapter->num_rx_queues = num_tcs;
2341 	} else {
2342 		u16 rss = min_t(u16, num_online_cpus(), IXGBEVF_MAX_RSS_QUEUES);
2343 
2344 		switch (hw->api_version) {
2345 		case ixgbe_mbox_api_11:
2346 		case ixgbe_mbox_api_12:
2347 		case ixgbe_mbox_api_13:
2348 			adapter->num_rx_queues = rss;
2349 			adapter->num_tx_queues = rss;
2350 		default:
2351 			break;
2352 		}
2353 	}
2354 }
2355 
2356 /**
2357  * ixgbevf_alloc_queues - Allocate memory for all rings
2358  * @adapter: board private structure to initialize
2359  *
2360  * We allocate one ring per queue at run-time since we don't know the
2361  * number of queues at compile-time.  The polling_netdev array is
2362  * intended for Multiqueue, but should work fine with a single queue.
2363  **/
2364 static int ixgbevf_alloc_queues(struct ixgbevf_adapter *adapter)
2365 {
2366 	struct ixgbevf_ring *ring;
2367 	int rx = 0, tx = 0;
2368 
2369 	for (; tx < adapter->num_tx_queues; tx++) {
2370 		ring = kzalloc(sizeof(*ring), GFP_KERNEL);
2371 		if (!ring)
2372 			goto err_allocation;
2373 
2374 		ring->dev = &adapter->pdev->dev;
2375 		ring->netdev = adapter->netdev;
2376 		ring->count = adapter->tx_ring_count;
2377 		ring->queue_index = tx;
2378 		ring->reg_idx = tx;
2379 
2380 		adapter->tx_ring[tx] = ring;
2381 	}
2382 
2383 	for (; rx < adapter->num_rx_queues; rx++) {
2384 		ring = kzalloc(sizeof(*ring), GFP_KERNEL);
2385 		if (!ring)
2386 			goto err_allocation;
2387 
2388 		ring->dev = &adapter->pdev->dev;
2389 		ring->netdev = adapter->netdev;
2390 
2391 		ring->count = adapter->rx_ring_count;
2392 		ring->queue_index = rx;
2393 		ring->reg_idx = rx;
2394 
2395 		adapter->rx_ring[rx] = ring;
2396 	}
2397 
2398 	return 0;
2399 
2400 err_allocation:
2401 	while (tx) {
2402 		kfree(adapter->tx_ring[--tx]);
2403 		adapter->tx_ring[tx] = NULL;
2404 	}
2405 
2406 	while (rx) {
2407 		kfree(adapter->rx_ring[--rx]);
2408 		adapter->rx_ring[rx] = NULL;
2409 	}
2410 	return -ENOMEM;
2411 }
2412 
2413 /**
2414  * ixgbevf_set_interrupt_capability - set MSI-X or FAIL if not supported
2415  * @adapter: board private structure to initialize
2416  *
2417  * Attempt to configure the interrupts using the best available
2418  * capabilities of the hardware and the kernel.
2419  **/
2420 static int ixgbevf_set_interrupt_capability(struct ixgbevf_adapter *adapter)
2421 {
2422 	struct net_device *netdev = adapter->netdev;
2423 	int err;
2424 	int vector, v_budget;
2425 
2426 	/* It's easy to be greedy for MSI-X vectors, but it really
2427 	 * doesn't do us much good if we have a lot more vectors
2428 	 * than CPU's.  So let's be conservative and only ask for
2429 	 * (roughly) the same number of vectors as there are CPU's.
2430 	 * The default is to use pairs of vectors.
2431 	 */
2432 	v_budget = max(adapter->num_rx_queues, adapter->num_tx_queues);
2433 	v_budget = min_t(int, v_budget, num_online_cpus());
2434 	v_budget += NON_Q_VECTORS;
2435 
2436 	/* A failure in MSI-X entry allocation isn't fatal, but it does
2437 	 * mean we disable MSI-X capabilities of the adapter.
2438 	 */
2439 	adapter->msix_entries = kcalloc(v_budget,
2440 					sizeof(struct msix_entry), GFP_KERNEL);
2441 	if (!adapter->msix_entries)
2442 		return -ENOMEM;
2443 
2444 	for (vector = 0; vector < v_budget; vector++)
2445 		adapter->msix_entries[vector].entry = vector;
2446 
2447 	err = ixgbevf_acquire_msix_vectors(adapter, v_budget);
2448 	if (err)
2449 		return err;
2450 
2451 	err = netif_set_real_num_tx_queues(netdev, adapter->num_tx_queues);
2452 	if (err)
2453 		return err;
2454 
2455 	return netif_set_real_num_rx_queues(netdev, adapter->num_rx_queues);
2456 }
2457 
2458 /**
2459  * ixgbevf_alloc_q_vectors - Allocate memory for interrupt vectors
2460  * @adapter: board private structure to initialize
2461  *
2462  * We allocate one q_vector per queue interrupt.  If allocation fails we
2463  * return -ENOMEM.
2464  **/
2465 static int ixgbevf_alloc_q_vectors(struct ixgbevf_adapter *adapter)
2466 {
2467 	int q_idx, num_q_vectors;
2468 	struct ixgbevf_q_vector *q_vector;
2469 
2470 	num_q_vectors = adapter->num_msix_vectors - NON_Q_VECTORS;
2471 
2472 	for (q_idx = 0; q_idx < num_q_vectors; q_idx++) {
2473 		q_vector = kzalloc(sizeof(struct ixgbevf_q_vector), GFP_KERNEL);
2474 		if (!q_vector)
2475 			goto err_out;
2476 		q_vector->adapter = adapter;
2477 		q_vector->v_idx = q_idx;
2478 		netif_napi_add(adapter->netdev, &q_vector->napi,
2479 			       ixgbevf_poll, 64);
2480 		adapter->q_vector[q_idx] = q_vector;
2481 	}
2482 
2483 	return 0;
2484 
2485 err_out:
2486 	while (q_idx) {
2487 		q_idx--;
2488 		q_vector = adapter->q_vector[q_idx];
2489 #ifdef CONFIG_NET_RX_BUSY_POLL
2490 		napi_hash_del(&q_vector->napi);
2491 #endif
2492 		netif_napi_del(&q_vector->napi);
2493 		kfree(q_vector);
2494 		adapter->q_vector[q_idx] = NULL;
2495 	}
2496 	return -ENOMEM;
2497 }
2498 
2499 /**
2500  * ixgbevf_free_q_vectors - Free memory allocated for interrupt vectors
2501  * @adapter: board private structure to initialize
2502  *
2503  * This function frees the memory allocated to the q_vectors.  In addition if
2504  * NAPI is enabled it will delete any references to the NAPI struct prior
2505  * to freeing the q_vector.
2506  **/
2507 static void ixgbevf_free_q_vectors(struct ixgbevf_adapter *adapter)
2508 {
2509 	int q_idx, num_q_vectors = adapter->num_msix_vectors - NON_Q_VECTORS;
2510 
2511 	for (q_idx = 0; q_idx < num_q_vectors; q_idx++) {
2512 		struct ixgbevf_q_vector *q_vector = adapter->q_vector[q_idx];
2513 
2514 		adapter->q_vector[q_idx] = NULL;
2515 #ifdef CONFIG_NET_RX_BUSY_POLL
2516 		napi_hash_del(&q_vector->napi);
2517 #endif
2518 		netif_napi_del(&q_vector->napi);
2519 		kfree(q_vector);
2520 	}
2521 }
2522 
2523 /**
2524  * ixgbevf_reset_interrupt_capability - Reset MSIX setup
2525  * @adapter: board private structure
2526  *
2527  **/
2528 static void ixgbevf_reset_interrupt_capability(struct ixgbevf_adapter *adapter)
2529 {
2530 	if (!adapter->msix_entries)
2531 		return;
2532 
2533 	pci_disable_msix(adapter->pdev);
2534 	kfree(adapter->msix_entries);
2535 	adapter->msix_entries = NULL;
2536 }
2537 
2538 /**
2539  * ixgbevf_init_interrupt_scheme - Determine if MSIX is supported and init
2540  * @adapter: board private structure to initialize
2541  *
2542  **/
2543 static int ixgbevf_init_interrupt_scheme(struct ixgbevf_adapter *adapter)
2544 {
2545 	int err;
2546 
2547 	/* Number of supported queues */
2548 	ixgbevf_set_num_queues(adapter);
2549 
2550 	err = ixgbevf_set_interrupt_capability(adapter);
2551 	if (err) {
2552 		hw_dbg(&adapter->hw,
2553 		       "Unable to setup interrupt capabilities\n");
2554 		goto err_set_interrupt;
2555 	}
2556 
2557 	err = ixgbevf_alloc_q_vectors(adapter);
2558 	if (err) {
2559 		hw_dbg(&adapter->hw, "Unable to allocate memory for queue vectors\n");
2560 		goto err_alloc_q_vectors;
2561 	}
2562 
2563 	err = ixgbevf_alloc_queues(adapter);
2564 	if (err) {
2565 		pr_err("Unable to allocate memory for queues\n");
2566 		goto err_alloc_queues;
2567 	}
2568 
2569 	hw_dbg(&adapter->hw, "Multiqueue %s: Rx Queue count = %u, Tx Queue count = %u\n",
2570 	       (adapter->num_rx_queues > 1) ? "Enabled" :
2571 	       "Disabled", adapter->num_rx_queues, adapter->num_tx_queues);
2572 
2573 	set_bit(__IXGBEVF_DOWN, &adapter->state);
2574 
2575 	return 0;
2576 err_alloc_queues:
2577 	ixgbevf_free_q_vectors(adapter);
2578 err_alloc_q_vectors:
2579 	ixgbevf_reset_interrupt_capability(adapter);
2580 err_set_interrupt:
2581 	return err;
2582 }
2583 
2584 /**
2585  * ixgbevf_clear_interrupt_scheme - Clear the current interrupt scheme settings
2586  * @adapter: board private structure to clear interrupt scheme on
2587  *
2588  * We go through and clear interrupt specific resources and reset the structure
2589  * to pre-load conditions
2590  **/
2591 static void ixgbevf_clear_interrupt_scheme(struct ixgbevf_adapter *adapter)
2592 {
2593 	int i;
2594 
2595 	for (i = 0; i < adapter->num_tx_queues; i++) {
2596 		kfree(adapter->tx_ring[i]);
2597 		adapter->tx_ring[i] = NULL;
2598 	}
2599 	for (i = 0; i < adapter->num_rx_queues; i++) {
2600 		kfree(adapter->rx_ring[i]);
2601 		adapter->rx_ring[i] = NULL;
2602 	}
2603 
2604 	adapter->num_tx_queues = 0;
2605 	adapter->num_rx_queues = 0;
2606 
2607 	ixgbevf_free_q_vectors(adapter);
2608 	ixgbevf_reset_interrupt_capability(adapter);
2609 }
2610 
2611 /**
2612  * ixgbevf_sw_init - Initialize general software structures
2613  * @adapter: board private structure to initialize
2614  *
2615  * ixgbevf_sw_init initializes the Adapter private data structure.
2616  * Fields are initialized based on PCI device information and
2617  * OS network device settings (MTU size).
2618  **/
2619 static int ixgbevf_sw_init(struct ixgbevf_adapter *adapter)
2620 {
2621 	struct ixgbe_hw *hw = &adapter->hw;
2622 	struct pci_dev *pdev = adapter->pdev;
2623 	struct net_device *netdev = adapter->netdev;
2624 	int err;
2625 
2626 	/* PCI config space info */
2627 	hw->vendor_id = pdev->vendor;
2628 	hw->device_id = pdev->device;
2629 	hw->revision_id = pdev->revision;
2630 	hw->subsystem_vendor_id = pdev->subsystem_vendor;
2631 	hw->subsystem_device_id = pdev->subsystem_device;
2632 
2633 	hw->mbx.ops.init_params(hw);
2634 
2635 	if (hw->mac.type >= ixgbe_mac_X550_vf) {
2636 		err = ixgbevf_init_rss_key(adapter);
2637 		if (err)
2638 			goto out;
2639 	}
2640 
2641 	/* assume legacy case in which PF would only give VF 2 queues */
2642 	hw->mac.max_tx_queues = 2;
2643 	hw->mac.max_rx_queues = 2;
2644 
2645 	/* lock to protect mailbox accesses */
2646 	spin_lock_init(&adapter->mbx_lock);
2647 
2648 	err = hw->mac.ops.reset_hw(hw);
2649 	if (err) {
2650 		dev_info(&pdev->dev,
2651 			 "PF still in reset state.  Is the PF interface up?\n");
2652 	} else {
2653 		err = hw->mac.ops.init_hw(hw);
2654 		if (err) {
2655 			pr_err("init_shared_code failed: %d\n", err);
2656 			goto out;
2657 		}
2658 		ixgbevf_negotiate_api(adapter);
2659 		err = hw->mac.ops.get_mac_addr(hw, hw->mac.addr);
2660 		if (err)
2661 			dev_info(&pdev->dev, "Error reading MAC address\n");
2662 		else if (is_zero_ether_addr(adapter->hw.mac.addr))
2663 			dev_info(&pdev->dev,
2664 				 "MAC address not assigned by administrator.\n");
2665 		ether_addr_copy(netdev->dev_addr, hw->mac.addr);
2666 	}
2667 
2668 	if (!is_valid_ether_addr(netdev->dev_addr)) {
2669 		dev_info(&pdev->dev, "Assigning random MAC address\n");
2670 		eth_hw_addr_random(netdev);
2671 		ether_addr_copy(hw->mac.addr, netdev->dev_addr);
2672 		ether_addr_copy(hw->mac.perm_addr, netdev->dev_addr);
2673 	}
2674 
2675 	/* Enable dynamic interrupt throttling rates */
2676 	adapter->rx_itr_setting = 1;
2677 	adapter->tx_itr_setting = 1;
2678 
2679 	/* set default ring sizes */
2680 	adapter->tx_ring_count = IXGBEVF_DEFAULT_TXD;
2681 	adapter->rx_ring_count = IXGBEVF_DEFAULT_RXD;
2682 
2683 	set_bit(__IXGBEVF_DOWN, &adapter->state);
2684 	return 0;
2685 
2686 out:
2687 	return err;
2688 }
2689 
2690 #define UPDATE_VF_COUNTER_32bit(reg, last_counter, counter)	\
2691 	{							\
2692 		u32 current_counter = IXGBE_READ_REG(hw, reg);	\
2693 		if (current_counter < last_counter)		\
2694 			counter += 0x100000000LL;		\
2695 		last_counter = current_counter;			\
2696 		counter &= 0xFFFFFFFF00000000LL;		\
2697 		counter |= current_counter;			\
2698 	}
2699 
2700 #define UPDATE_VF_COUNTER_36bit(reg_lsb, reg_msb, last_counter, counter) \
2701 	{								 \
2702 		u64 current_counter_lsb = IXGBE_READ_REG(hw, reg_lsb);	 \
2703 		u64 current_counter_msb = IXGBE_READ_REG(hw, reg_msb);	 \
2704 		u64 current_counter = (current_counter_msb << 32) |	 \
2705 			current_counter_lsb;				 \
2706 		if (current_counter < last_counter)			 \
2707 			counter += 0x1000000000LL;			 \
2708 		last_counter = current_counter;				 \
2709 		counter &= 0xFFFFFFF000000000LL;			 \
2710 		counter |= current_counter;				 \
2711 	}
2712 /**
2713  * ixgbevf_update_stats - Update the board statistics counters.
2714  * @adapter: board private structure
2715  **/
2716 void ixgbevf_update_stats(struct ixgbevf_adapter *adapter)
2717 {
2718 	struct ixgbe_hw *hw = &adapter->hw;
2719 	int i;
2720 
2721 	if (test_bit(__IXGBEVF_DOWN, &adapter->state) ||
2722 	    test_bit(__IXGBEVF_RESETTING, &adapter->state))
2723 		return;
2724 
2725 	UPDATE_VF_COUNTER_32bit(IXGBE_VFGPRC, adapter->stats.last_vfgprc,
2726 				adapter->stats.vfgprc);
2727 	UPDATE_VF_COUNTER_32bit(IXGBE_VFGPTC, adapter->stats.last_vfgptc,
2728 				adapter->stats.vfgptc);
2729 	UPDATE_VF_COUNTER_36bit(IXGBE_VFGORC_LSB, IXGBE_VFGORC_MSB,
2730 				adapter->stats.last_vfgorc,
2731 				adapter->stats.vfgorc);
2732 	UPDATE_VF_COUNTER_36bit(IXGBE_VFGOTC_LSB, IXGBE_VFGOTC_MSB,
2733 				adapter->stats.last_vfgotc,
2734 				adapter->stats.vfgotc);
2735 	UPDATE_VF_COUNTER_32bit(IXGBE_VFMPRC, adapter->stats.last_vfmprc,
2736 				adapter->stats.vfmprc);
2737 
2738 	for (i = 0;  i  < adapter->num_rx_queues;  i++) {
2739 		adapter->hw_csum_rx_error +=
2740 			adapter->rx_ring[i]->hw_csum_rx_error;
2741 		adapter->rx_ring[i]->hw_csum_rx_error = 0;
2742 	}
2743 }
2744 
2745 /**
2746  * ixgbevf_service_timer - Timer Call-back
2747  * @data: pointer to adapter cast into an unsigned long
2748  **/
2749 static void ixgbevf_service_timer(unsigned long data)
2750 {
2751 	struct ixgbevf_adapter *adapter = (struct ixgbevf_adapter *)data;
2752 
2753 	/* Reset the timer */
2754 	mod_timer(&adapter->service_timer, (HZ * 2) + jiffies);
2755 
2756 	ixgbevf_service_event_schedule(adapter);
2757 }
2758 
2759 static void ixgbevf_reset_subtask(struct ixgbevf_adapter *adapter)
2760 {
2761 	if (!test_and_clear_bit(__IXGBEVF_RESET_REQUESTED, &adapter->state))
2762 		return;
2763 
2764 	/* If we're already down or resetting, just bail */
2765 	if (test_bit(__IXGBEVF_DOWN, &adapter->state) ||
2766 	    test_bit(__IXGBEVF_REMOVING, &adapter->state) ||
2767 	    test_bit(__IXGBEVF_RESETTING, &adapter->state))
2768 		return;
2769 
2770 	adapter->tx_timeout_count++;
2771 
2772 	rtnl_lock();
2773 	ixgbevf_reinit_locked(adapter);
2774 	rtnl_unlock();
2775 }
2776 
2777 /**
2778  * ixgbevf_check_hang_subtask - check for hung queues and dropped interrupts
2779  * @adapter: pointer to the device adapter structure
2780  *
2781  * This function serves two purposes.  First it strobes the interrupt lines
2782  * in order to make certain interrupts are occurring.  Secondly it sets the
2783  * bits needed to check for TX hangs.  As a result we should immediately
2784  * determine if a hang has occurred.
2785  **/
2786 static void ixgbevf_check_hang_subtask(struct ixgbevf_adapter *adapter)
2787 {
2788 	struct ixgbe_hw *hw = &adapter->hw;
2789 	u32 eics = 0;
2790 	int i;
2791 
2792 	/* If we're down or resetting, just bail */
2793 	if (test_bit(__IXGBEVF_DOWN, &adapter->state) ||
2794 	    test_bit(__IXGBEVF_RESETTING, &adapter->state))
2795 		return;
2796 
2797 	/* Force detection of hung controller */
2798 	if (netif_carrier_ok(adapter->netdev)) {
2799 		for (i = 0; i < adapter->num_tx_queues; i++)
2800 			set_check_for_tx_hang(adapter->tx_ring[i]);
2801 	}
2802 
2803 	/* get one bit for every active Tx/Rx interrupt vector */
2804 	for (i = 0; i < adapter->num_msix_vectors - NON_Q_VECTORS; i++) {
2805 		struct ixgbevf_q_vector *qv = adapter->q_vector[i];
2806 
2807 		if (qv->rx.ring || qv->tx.ring)
2808 			eics |= BIT(i);
2809 	}
2810 
2811 	/* Cause software interrupt to ensure rings are cleaned */
2812 	IXGBE_WRITE_REG(hw, IXGBE_VTEICS, eics);
2813 }
2814 
2815 /**
2816  * ixgbevf_watchdog_update_link - update the link status
2817  * @adapter: pointer to the device adapter structure
2818  **/
2819 static void ixgbevf_watchdog_update_link(struct ixgbevf_adapter *adapter)
2820 {
2821 	struct ixgbe_hw *hw = &adapter->hw;
2822 	u32 link_speed = adapter->link_speed;
2823 	bool link_up = adapter->link_up;
2824 	s32 err;
2825 
2826 	spin_lock_bh(&adapter->mbx_lock);
2827 
2828 	err = hw->mac.ops.check_link(hw, &link_speed, &link_up, false);
2829 
2830 	spin_unlock_bh(&adapter->mbx_lock);
2831 
2832 	/* if check for link returns error we will need to reset */
2833 	if (err && time_after(jiffies, adapter->last_reset + (10 * HZ))) {
2834 		set_bit(__IXGBEVF_RESET_REQUESTED, &adapter->state);
2835 		link_up = false;
2836 	}
2837 
2838 	adapter->link_up = link_up;
2839 	adapter->link_speed = link_speed;
2840 }
2841 
2842 /**
2843  * ixgbevf_watchdog_link_is_up - update netif_carrier status and
2844  *				 print link up message
2845  * @adapter: pointer to the device adapter structure
2846  **/
2847 static void ixgbevf_watchdog_link_is_up(struct ixgbevf_adapter *adapter)
2848 {
2849 	struct net_device *netdev = adapter->netdev;
2850 
2851 	/* only continue if link was previously down */
2852 	if (netif_carrier_ok(netdev))
2853 		return;
2854 
2855 	dev_info(&adapter->pdev->dev, "NIC Link is Up %s\n",
2856 		 (adapter->link_speed == IXGBE_LINK_SPEED_10GB_FULL) ?
2857 		 "10 Gbps" :
2858 		 (adapter->link_speed == IXGBE_LINK_SPEED_1GB_FULL) ?
2859 		 "1 Gbps" :
2860 		 (adapter->link_speed == IXGBE_LINK_SPEED_100_FULL) ?
2861 		 "100 Mbps" :
2862 		 "unknown speed");
2863 
2864 	netif_carrier_on(netdev);
2865 }
2866 
2867 /**
2868  * ixgbevf_watchdog_link_is_down - update netif_carrier status and
2869  *				   print link down message
2870  * @adapter: pointer to the adapter structure
2871  **/
2872 static void ixgbevf_watchdog_link_is_down(struct ixgbevf_adapter *adapter)
2873 {
2874 	struct net_device *netdev = adapter->netdev;
2875 
2876 	adapter->link_speed = 0;
2877 
2878 	/* only continue if link was up previously */
2879 	if (!netif_carrier_ok(netdev))
2880 		return;
2881 
2882 	dev_info(&adapter->pdev->dev, "NIC Link is Down\n");
2883 
2884 	netif_carrier_off(netdev);
2885 }
2886 
2887 /**
2888  * ixgbevf_watchdog_subtask - worker thread to bring link up
2889  * @work: pointer to work_struct containing our data
2890  **/
2891 static void ixgbevf_watchdog_subtask(struct ixgbevf_adapter *adapter)
2892 {
2893 	/* if interface is down do nothing */
2894 	if (test_bit(__IXGBEVF_DOWN, &adapter->state) ||
2895 	    test_bit(__IXGBEVF_RESETTING, &adapter->state))
2896 		return;
2897 
2898 	ixgbevf_watchdog_update_link(adapter);
2899 
2900 	if (adapter->link_up)
2901 		ixgbevf_watchdog_link_is_up(adapter);
2902 	else
2903 		ixgbevf_watchdog_link_is_down(adapter);
2904 
2905 	ixgbevf_update_stats(adapter);
2906 }
2907 
2908 /**
2909  * ixgbevf_service_task - manages and runs subtasks
2910  * @work: pointer to work_struct containing our data
2911  **/
2912 static void ixgbevf_service_task(struct work_struct *work)
2913 {
2914 	struct ixgbevf_adapter *adapter = container_of(work,
2915 						       struct ixgbevf_adapter,
2916 						       service_task);
2917 	struct ixgbe_hw *hw = &adapter->hw;
2918 
2919 	if (IXGBE_REMOVED(hw->hw_addr)) {
2920 		if (!test_bit(__IXGBEVF_DOWN, &adapter->state)) {
2921 			rtnl_lock();
2922 			ixgbevf_down(adapter);
2923 			rtnl_unlock();
2924 		}
2925 		return;
2926 	}
2927 
2928 	ixgbevf_queue_reset_subtask(adapter);
2929 	ixgbevf_reset_subtask(adapter);
2930 	ixgbevf_watchdog_subtask(adapter);
2931 	ixgbevf_check_hang_subtask(adapter);
2932 
2933 	ixgbevf_service_event_complete(adapter);
2934 }
2935 
2936 /**
2937  * ixgbevf_free_tx_resources - Free Tx Resources per Queue
2938  * @tx_ring: Tx descriptor ring for a specific queue
2939  *
2940  * Free all transmit software resources
2941  **/
2942 void ixgbevf_free_tx_resources(struct ixgbevf_ring *tx_ring)
2943 {
2944 	ixgbevf_clean_tx_ring(tx_ring);
2945 
2946 	vfree(tx_ring->tx_buffer_info);
2947 	tx_ring->tx_buffer_info = NULL;
2948 
2949 	/* if not set, then don't free */
2950 	if (!tx_ring->desc)
2951 		return;
2952 
2953 	dma_free_coherent(tx_ring->dev, tx_ring->size, tx_ring->desc,
2954 			  tx_ring->dma);
2955 
2956 	tx_ring->desc = NULL;
2957 }
2958 
2959 /**
2960  * ixgbevf_free_all_tx_resources - Free Tx Resources for All Queues
2961  * @adapter: board private structure
2962  *
2963  * Free all transmit software resources
2964  **/
2965 static void ixgbevf_free_all_tx_resources(struct ixgbevf_adapter *adapter)
2966 {
2967 	int i;
2968 
2969 	for (i = 0; i < adapter->num_tx_queues; i++)
2970 		if (adapter->tx_ring[i]->desc)
2971 			ixgbevf_free_tx_resources(adapter->tx_ring[i]);
2972 }
2973 
2974 /**
2975  * ixgbevf_setup_tx_resources - allocate Tx resources (Descriptors)
2976  * @tx_ring: Tx descriptor ring (for a specific queue) to setup
2977  *
2978  * Return 0 on success, negative on failure
2979  **/
2980 int ixgbevf_setup_tx_resources(struct ixgbevf_ring *tx_ring)
2981 {
2982 	struct ixgbevf_adapter *adapter = netdev_priv(tx_ring->netdev);
2983 	int size;
2984 
2985 	size = sizeof(struct ixgbevf_tx_buffer) * tx_ring->count;
2986 	tx_ring->tx_buffer_info = vzalloc(size);
2987 	if (!tx_ring->tx_buffer_info)
2988 		goto err;
2989 
2990 	/* round up to nearest 4K */
2991 	tx_ring->size = tx_ring->count * sizeof(union ixgbe_adv_tx_desc);
2992 	tx_ring->size = ALIGN(tx_ring->size, 4096);
2993 
2994 	tx_ring->desc = dma_alloc_coherent(tx_ring->dev, tx_ring->size,
2995 					   &tx_ring->dma, GFP_KERNEL);
2996 	if (!tx_ring->desc)
2997 		goto err;
2998 
2999 	return 0;
3000 
3001 err:
3002 	vfree(tx_ring->tx_buffer_info);
3003 	tx_ring->tx_buffer_info = NULL;
3004 	hw_dbg(&adapter->hw, "Unable to allocate memory for the transmit descriptor ring\n");
3005 	return -ENOMEM;
3006 }
3007 
3008 /**
3009  * ixgbevf_setup_all_tx_resources - allocate all queues Tx resources
3010  * @adapter: board private structure
3011  *
3012  * If this function returns with an error, then it's possible one or
3013  * more of the rings is populated (while the rest are not).  It is the
3014  * callers duty to clean those orphaned rings.
3015  *
3016  * Return 0 on success, negative on failure
3017  **/
3018 static int ixgbevf_setup_all_tx_resources(struct ixgbevf_adapter *adapter)
3019 {
3020 	int i, err = 0;
3021 
3022 	for (i = 0; i < adapter->num_tx_queues; i++) {
3023 		err = ixgbevf_setup_tx_resources(adapter->tx_ring[i]);
3024 		if (!err)
3025 			continue;
3026 		hw_dbg(&adapter->hw, "Allocation for Tx Queue %u failed\n", i);
3027 		break;
3028 	}
3029 
3030 	return err;
3031 }
3032 
3033 /**
3034  * ixgbevf_setup_rx_resources - allocate Rx resources (Descriptors)
3035  * @rx_ring: Rx descriptor ring (for a specific queue) to setup
3036  *
3037  * Returns 0 on success, negative on failure
3038  **/
3039 int ixgbevf_setup_rx_resources(struct ixgbevf_ring *rx_ring)
3040 {
3041 	int size;
3042 
3043 	size = sizeof(struct ixgbevf_rx_buffer) * rx_ring->count;
3044 	rx_ring->rx_buffer_info = vzalloc(size);
3045 	if (!rx_ring->rx_buffer_info)
3046 		goto err;
3047 
3048 	/* Round up to nearest 4K */
3049 	rx_ring->size = rx_ring->count * sizeof(union ixgbe_adv_rx_desc);
3050 	rx_ring->size = ALIGN(rx_ring->size, 4096);
3051 
3052 	rx_ring->desc = dma_alloc_coherent(rx_ring->dev, rx_ring->size,
3053 					   &rx_ring->dma, GFP_KERNEL);
3054 
3055 	if (!rx_ring->desc)
3056 		goto err;
3057 
3058 	return 0;
3059 err:
3060 	vfree(rx_ring->rx_buffer_info);
3061 	rx_ring->rx_buffer_info = NULL;
3062 	dev_err(rx_ring->dev, "Unable to allocate memory for the Rx descriptor ring\n");
3063 	return -ENOMEM;
3064 }
3065 
3066 /**
3067  * ixgbevf_setup_all_rx_resources - allocate all queues Rx resources
3068  * @adapter: board private structure
3069  *
3070  * If this function returns with an error, then it's possible one or
3071  * more of the rings is populated (while the rest are not).  It is the
3072  * callers duty to clean those orphaned rings.
3073  *
3074  * Return 0 on success, negative on failure
3075  **/
3076 static int ixgbevf_setup_all_rx_resources(struct ixgbevf_adapter *adapter)
3077 {
3078 	int i, err = 0;
3079 
3080 	for (i = 0; i < adapter->num_rx_queues; i++) {
3081 		err = ixgbevf_setup_rx_resources(adapter->rx_ring[i]);
3082 		if (!err)
3083 			continue;
3084 		hw_dbg(&adapter->hw, "Allocation for Rx Queue %u failed\n", i);
3085 		break;
3086 	}
3087 	return err;
3088 }
3089 
3090 /**
3091  * ixgbevf_free_rx_resources - Free Rx Resources
3092  * @rx_ring: ring to clean the resources from
3093  *
3094  * Free all receive software resources
3095  **/
3096 void ixgbevf_free_rx_resources(struct ixgbevf_ring *rx_ring)
3097 {
3098 	ixgbevf_clean_rx_ring(rx_ring);
3099 
3100 	vfree(rx_ring->rx_buffer_info);
3101 	rx_ring->rx_buffer_info = NULL;
3102 
3103 	dma_free_coherent(rx_ring->dev, rx_ring->size, rx_ring->desc,
3104 			  rx_ring->dma);
3105 
3106 	rx_ring->desc = NULL;
3107 }
3108 
3109 /**
3110  * ixgbevf_free_all_rx_resources - Free Rx Resources for All Queues
3111  * @adapter: board private structure
3112  *
3113  * Free all receive software resources
3114  **/
3115 static void ixgbevf_free_all_rx_resources(struct ixgbevf_adapter *adapter)
3116 {
3117 	int i;
3118 
3119 	for (i = 0; i < adapter->num_rx_queues; i++)
3120 		if (adapter->rx_ring[i]->desc)
3121 			ixgbevf_free_rx_resources(adapter->rx_ring[i]);
3122 }
3123 
3124 /**
3125  * ixgbevf_open - Called when a network interface is made active
3126  * @netdev: network interface device structure
3127  *
3128  * Returns 0 on success, negative value on failure
3129  *
3130  * The open entry point is called when a network interface is made
3131  * active by the system (IFF_UP).  At this point all resources needed
3132  * for transmit and receive operations are allocated, the interrupt
3133  * handler is registered with the OS, the watchdog timer is started,
3134  * and the stack is notified that the interface is ready.
3135  **/
3136 int ixgbevf_open(struct net_device *netdev)
3137 {
3138 	struct ixgbevf_adapter *adapter = netdev_priv(netdev);
3139 	struct ixgbe_hw *hw = &adapter->hw;
3140 	int err;
3141 
3142 	/* A previous failure to open the device because of a lack of
3143 	 * available MSIX vector resources may have reset the number
3144 	 * of msix vectors variable to zero.  The only way to recover
3145 	 * is to unload/reload the driver and hope that the system has
3146 	 * been able to recover some MSIX vector resources.
3147 	 */
3148 	if (!adapter->num_msix_vectors)
3149 		return -ENOMEM;
3150 
3151 	if (hw->adapter_stopped) {
3152 		ixgbevf_reset(adapter);
3153 		/* if adapter is still stopped then PF isn't up and
3154 		 * the VF can't start.
3155 		 */
3156 		if (hw->adapter_stopped) {
3157 			err = IXGBE_ERR_MBX;
3158 			pr_err("Unable to start - perhaps the PF Driver isn't up yet\n");
3159 			goto err_setup_reset;
3160 		}
3161 	}
3162 
3163 	/* disallow open during test */
3164 	if (test_bit(__IXGBEVF_TESTING, &adapter->state))
3165 		return -EBUSY;
3166 
3167 	netif_carrier_off(netdev);
3168 
3169 	/* allocate transmit descriptors */
3170 	err = ixgbevf_setup_all_tx_resources(adapter);
3171 	if (err)
3172 		goto err_setup_tx;
3173 
3174 	/* allocate receive descriptors */
3175 	err = ixgbevf_setup_all_rx_resources(adapter);
3176 	if (err)
3177 		goto err_setup_rx;
3178 
3179 	ixgbevf_configure(adapter);
3180 
3181 	/* Map the Tx/Rx rings to the vectors we were allotted.
3182 	 * if request_irq will be called in this function map_rings
3183 	 * must be called *before* up_complete
3184 	 */
3185 	ixgbevf_map_rings_to_vectors(adapter);
3186 
3187 	err = ixgbevf_request_irq(adapter);
3188 	if (err)
3189 		goto err_req_irq;
3190 
3191 	ixgbevf_up_complete(adapter);
3192 
3193 	return 0;
3194 
3195 err_req_irq:
3196 	ixgbevf_down(adapter);
3197 err_setup_rx:
3198 	ixgbevf_free_all_rx_resources(adapter);
3199 err_setup_tx:
3200 	ixgbevf_free_all_tx_resources(adapter);
3201 	ixgbevf_reset(adapter);
3202 
3203 err_setup_reset:
3204 
3205 	return err;
3206 }
3207 
3208 /**
3209  * ixgbevf_close_suspend - actions necessary to both suspend and close flows
3210  * @adapter: the private adapter struct
3211  *
3212  * This function should contain the necessary work common to both suspending
3213  * and closing of the device.
3214  */
3215 static void ixgbevf_close_suspend(struct ixgbevf_adapter *adapter)
3216 {
3217 	ixgbevf_down(adapter);
3218 	ixgbevf_free_irq(adapter);
3219 	ixgbevf_free_all_tx_resources(adapter);
3220 	ixgbevf_free_all_rx_resources(adapter);
3221 }
3222 
3223 /**
3224  * ixgbevf_close - Disables a network interface
3225  * @netdev: network interface device structure
3226  *
3227  * Returns 0, this is not allowed to fail
3228  *
3229  * The close entry point is called when an interface is de-activated
3230  * by the OS.  The hardware is still under the drivers control, but
3231  * needs to be disabled.  A global MAC reset is issued to stop the
3232  * hardware, and all transmit and receive resources are freed.
3233  **/
3234 int ixgbevf_close(struct net_device *netdev)
3235 {
3236 	struct ixgbevf_adapter *adapter = netdev_priv(netdev);
3237 
3238 	if (netif_device_present(netdev))
3239 		ixgbevf_close_suspend(adapter);
3240 
3241 	return 0;
3242 }
3243 
3244 static void ixgbevf_queue_reset_subtask(struct ixgbevf_adapter *adapter)
3245 {
3246 	struct net_device *dev = adapter->netdev;
3247 
3248 	if (!test_and_clear_bit(__IXGBEVF_QUEUE_RESET_REQUESTED,
3249 				&adapter->state))
3250 		return;
3251 
3252 	/* if interface is down do nothing */
3253 	if (test_bit(__IXGBEVF_DOWN, &adapter->state) ||
3254 	    test_bit(__IXGBEVF_RESETTING, &adapter->state))
3255 		return;
3256 
3257 	/* Hardware has to reinitialize queues and interrupts to
3258 	 * match packet buffer alignment. Unfortunately, the
3259 	 * hardware is not flexible enough to do this dynamically.
3260 	 */
3261 	rtnl_lock();
3262 
3263 	if (netif_running(dev))
3264 		ixgbevf_close(dev);
3265 
3266 	ixgbevf_clear_interrupt_scheme(adapter);
3267 	ixgbevf_init_interrupt_scheme(adapter);
3268 
3269 	if (netif_running(dev))
3270 		ixgbevf_open(dev);
3271 
3272 	rtnl_unlock();
3273 }
3274 
3275 static void ixgbevf_tx_ctxtdesc(struct ixgbevf_ring *tx_ring,
3276 				u32 vlan_macip_lens, u32 type_tucmd,
3277 				u32 mss_l4len_idx)
3278 {
3279 	struct ixgbe_adv_tx_context_desc *context_desc;
3280 	u16 i = tx_ring->next_to_use;
3281 
3282 	context_desc = IXGBEVF_TX_CTXTDESC(tx_ring, i);
3283 
3284 	i++;
3285 	tx_ring->next_to_use = (i < tx_ring->count) ? i : 0;
3286 
3287 	/* set bits to identify this as an advanced context descriptor */
3288 	type_tucmd |= IXGBE_TXD_CMD_DEXT | IXGBE_ADVTXD_DTYP_CTXT;
3289 
3290 	context_desc->vlan_macip_lens	= cpu_to_le32(vlan_macip_lens);
3291 	context_desc->seqnum_seed	= 0;
3292 	context_desc->type_tucmd_mlhl	= cpu_to_le32(type_tucmd);
3293 	context_desc->mss_l4len_idx	= cpu_to_le32(mss_l4len_idx);
3294 }
3295 
3296 static int ixgbevf_tso(struct ixgbevf_ring *tx_ring,
3297 		       struct ixgbevf_tx_buffer *first,
3298 		       u8 *hdr_len)
3299 {
3300 	u32 vlan_macip_lens, type_tucmd, mss_l4len_idx;
3301 	struct sk_buff *skb = first->skb;
3302 	union {
3303 		struct iphdr *v4;
3304 		struct ipv6hdr *v6;
3305 		unsigned char *hdr;
3306 	} ip;
3307 	union {
3308 		struct tcphdr *tcp;
3309 		unsigned char *hdr;
3310 	} l4;
3311 	u32 paylen, l4_offset;
3312 	int err;
3313 
3314 	if (skb->ip_summed != CHECKSUM_PARTIAL)
3315 		return 0;
3316 
3317 	if (!skb_is_gso(skb))
3318 		return 0;
3319 
3320 	err = skb_cow_head(skb, 0);
3321 	if (err < 0)
3322 		return err;
3323 
3324 	ip.hdr = skb_network_header(skb);
3325 	l4.hdr = skb_checksum_start(skb);
3326 
3327 	/* ADV DTYP TUCMD MKRLOC/ISCSIHEDLEN */
3328 	type_tucmd = IXGBE_ADVTXD_TUCMD_L4T_TCP;
3329 
3330 	/* initialize outer IP header fields */
3331 	if (ip.v4->version == 4) {
3332 		unsigned char *csum_start = skb_checksum_start(skb);
3333 		unsigned char *trans_start = ip.hdr + (ip.v4->ihl * 4);
3334 
3335 		/* IP header will have to cancel out any data that
3336 		 * is not a part of the outer IP header
3337 		 */
3338 		ip.v4->check = csum_fold(csum_partial(trans_start,
3339 						      csum_start - trans_start,
3340 						      0));
3341 		type_tucmd |= IXGBE_ADVTXD_TUCMD_IPV4;
3342 
3343 		ip.v4->tot_len = 0;
3344 		first->tx_flags |= IXGBE_TX_FLAGS_TSO |
3345 				   IXGBE_TX_FLAGS_CSUM |
3346 				   IXGBE_TX_FLAGS_IPV4;
3347 	} else {
3348 		ip.v6->payload_len = 0;
3349 		first->tx_flags |= IXGBE_TX_FLAGS_TSO |
3350 				   IXGBE_TX_FLAGS_CSUM;
3351 	}
3352 
3353 	/* determine offset of inner transport header */
3354 	l4_offset = l4.hdr - skb->data;
3355 
3356 	/* compute length of segmentation header */
3357 	*hdr_len = (l4.tcp->doff * 4) + l4_offset;
3358 
3359 	/* remove payload length from inner checksum */
3360 	paylen = skb->len - l4_offset;
3361 	csum_replace_by_diff(&l4.tcp->check, htonl(paylen));
3362 
3363 	/* update gso size and bytecount with header size */
3364 	first->gso_segs = skb_shinfo(skb)->gso_segs;
3365 	first->bytecount += (first->gso_segs - 1) * *hdr_len;
3366 
3367 	/* mss_l4len_id: use 1 as index for TSO */
3368 	mss_l4len_idx = (*hdr_len - l4_offset) << IXGBE_ADVTXD_L4LEN_SHIFT;
3369 	mss_l4len_idx |= skb_shinfo(skb)->gso_size << IXGBE_ADVTXD_MSS_SHIFT;
3370 	mss_l4len_idx |= (1u << IXGBE_ADVTXD_IDX_SHIFT);
3371 
3372 	/* vlan_macip_lens: HEADLEN, MACLEN, VLAN tag */
3373 	vlan_macip_lens = l4.hdr - ip.hdr;
3374 	vlan_macip_lens |= (ip.hdr - skb->data) << IXGBE_ADVTXD_MACLEN_SHIFT;
3375 	vlan_macip_lens |= first->tx_flags & IXGBE_TX_FLAGS_VLAN_MASK;
3376 
3377 	ixgbevf_tx_ctxtdesc(tx_ring, vlan_macip_lens,
3378 			    type_tucmd, mss_l4len_idx);
3379 
3380 	return 1;
3381 }
3382 
3383 static inline bool ixgbevf_ipv6_csum_is_sctp(struct sk_buff *skb)
3384 {
3385 	unsigned int offset = 0;
3386 
3387 	ipv6_find_hdr(skb, &offset, IPPROTO_SCTP, NULL, NULL);
3388 
3389 	return offset == skb_checksum_start_offset(skb);
3390 }
3391 
3392 static void ixgbevf_tx_csum(struct ixgbevf_ring *tx_ring,
3393 			    struct ixgbevf_tx_buffer *first)
3394 {
3395 	struct sk_buff *skb = first->skb;
3396 	u32 vlan_macip_lens = 0;
3397 	u32 type_tucmd = 0;
3398 
3399 	if (skb->ip_summed != CHECKSUM_PARTIAL)
3400 		goto no_csum;
3401 
3402 	switch (skb->csum_offset) {
3403 	case offsetof(struct tcphdr, check):
3404 		type_tucmd = IXGBE_ADVTXD_TUCMD_L4T_TCP;
3405 		/* fall through */
3406 	case offsetof(struct udphdr, check):
3407 		break;
3408 	case offsetof(struct sctphdr, checksum):
3409 		/* validate that this is actually an SCTP request */
3410 		if (((first->protocol == htons(ETH_P_IP)) &&
3411 		     (ip_hdr(skb)->protocol == IPPROTO_SCTP)) ||
3412 		    ((first->protocol == htons(ETH_P_IPV6)) &&
3413 		     ixgbevf_ipv6_csum_is_sctp(skb))) {
3414 			type_tucmd = IXGBE_ADVTXD_TUCMD_L4T_SCTP;
3415 			break;
3416 		}
3417 		/* fall through */
3418 	default:
3419 		skb_checksum_help(skb);
3420 		goto no_csum;
3421 	}
3422 	/* update TX checksum flag */
3423 	first->tx_flags |= IXGBE_TX_FLAGS_CSUM;
3424 	vlan_macip_lens = skb_checksum_start_offset(skb) -
3425 			  skb_network_offset(skb);
3426 no_csum:
3427 	/* vlan_macip_lens: MACLEN, VLAN tag */
3428 	vlan_macip_lens |= skb_network_offset(skb) << IXGBE_ADVTXD_MACLEN_SHIFT;
3429 	vlan_macip_lens |= first->tx_flags & IXGBE_TX_FLAGS_VLAN_MASK;
3430 
3431 	ixgbevf_tx_ctxtdesc(tx_ring, vlan_macip_lens, type_tucmd, 0);
3432 }
3433 
3434 static __le32 ixgbevf_tx_cmd_type(u32 tx_flags)
3435 {
3436 	/* set type for advanced descriptor with frame checksum insertion */
3437 	__le32 cmd_type = cpu_to_le32(IXGBE_ADVTXD_DTYP_DATA |
3438 				      IXGBE_ADVTXD_DCMD_IFCS |
3439 				      IXGBE_ADVTXD_DCMD_DEXT);
3440 
3441 	/* set HW VLAN bit if VLAN is present */
3442 	if (tx_flags & IXGBE_TX_FLAGS_VLAN)
3443 		cmd_type |= cpu_to_le32(IXGBE_ADVTXD_DCMD_VLE);
3444 
3445 	/* set segmentation enable bits for TSO/FSO */
3446 	if (tx_flags & IXGBE_TX_FLAGS_TSO)
3447 		cmd_type |= cpu_to_le32(IXGBE_ADVTXD_DCMD_TSE);
3448 
3449 	return cmd_type;
3450 }
3451 
3452 static void ixgbevf_tx_olinfo_status(union ixgbe_adv_tx_desc *tx_desc,
3453 				     u32 tx_flags, unsigned int paylen)
3454 {
3455 	__le32 olinfo_status = cpu_to_le32(paylen << IXGBE_ADVTXD_PAYLEN_SHIFT);
3456 
3457 	/* enable L4 checksum for TSO and TX checksum offload */
3458 	if (tx_flags & IXGBE_TX_FLAGS_CSUM)
3459 		olinfo_status |= cpu_to_le32(IXGBE_ADVTXD_POPTS_TXSM);
3460 
3461 	/* enble IPv4 checksum for TSO */
3462 	if (tx_flags & IXGBE_TX_FLAGS_IPV4)
3463 		olinfo_status |= cpu_to_le32(IXGBE_ADVTXD_POPTS_IXSM);
3464 
3465 	/* use index 1 context for TSO/FSO/FCOE */
3466 	if (tx_flags & IXGBE_TX_FLAGS_TSO)
3467 		olinfo_status |= cpu_to_le32(1u << IXGBE_ADVTXD_IDX_SHIFT);
3468 
3469 	/* Check Context must be set if Tx switch is enabled, which it
3470 	 * always is for case where virtual functions are running
3471 	 */
3472 	olinfo_status |= cpu_to_le32(IXGBE_ADVTXD_CC);
3473 
3474 	tx_desc->read.olinfo_status = olinfo_status;
3475 }
3476 
3477 static void ixgbevf_tx_map(struct ixgbevf_ring *tx_ring,
3478 			   struct ixgbevf_tx_buffer *first,
3479 			   const u8 hdr_len)
3480 {
3481 	dma_addr_t dma;
3482 	struct sk_buff *skb = first->skb;
3483 	struct ixgbevf_tx_buffer *tx_buffer;
3484 	union ixgbe_adv_tx_desc *tx_desc;
3485 	struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[0];
3486 	unsigned int data_len = skb->data_len;
3487 	unsigned int size = skb_headlen(skb);
3488 	unsigned int paylen = skb->len - hdr_len;
3489 	u32 tx_flags = first->tx_flags;
3490 	__le32 cmd_type;
3491 	u16 i = tx_ring->next_to_use;
3492 
3493 	tx_desc = IXGBEVF_TX_DESC(tx_ring, i);
3494 
3495 	ixgbevf_tx_olinfo_status(tx_desc, tx_flags, paylen);
3496 	cmd_type = ixgbevf_tx_cmd_type(tx_flags);
3497 
3498 	dma = dma_map_single(tx_ring->dev, skb->data, size, DMA_TO_DEVICE);
3499 	if (dma_mapping_error(tx_ring->dev, dma))
3500 		goto dma_error;
3501 
3502 	/* record length, and DMA address */
3503 	dma_unmap_len_set(first, len, size);
3504 	dma_unmap_addr_set(first, dma, dma);
3505 
3506 	tx_desc->read.buffer_addr = cpu_to_le64(dma);
3507 
3508 	for (;;) {
3509 		while (unlikely(size > IXGBE_MAX_DATA_PER_TXD)) {
3510 			tx_desc->read.cmd_type_len =
3511 				cmd_type | cpu_to_le32(IXGBE_MAX_DATA_PER_TXD);
3512 
3513 			i++;
3514 			tx_desc++;
3515 			if (i == tx_ring->count) {
3516 				tx_desc = IXGBEVF_TX_DESC(tx_ring, 0);
3517 				i = 0;
3518 			}
3519 
3520 			dma += IXGBE_MAX_DATA_PER_TXD;
3521 			size -= IXGBE_MAX_DATA_PER_TXD;
3522 
3523 			tx_desc->read.buffer_addr = cpu_to_le64(dma);
3524 			tx_desc->read.olinfo_status = 0;
3525 		}
3526 
3527 		if (likely(!data_len))
3528 			break;
3529 
3530 		tx_desc->read.cmd_type_len = cmd_type | cpu_to_le32(size);
3531 
3532 		i++;
3533 		tx_desc++;
3534 		if (i == tx_ring->count) {
3535 			tx_desc = IXGBEVF_TX_DESC(tx_ring, 0);
3536 			i = 0;
3537 		}
3538 
3539 		size = skb_frag_size(frag);
3540 		data_len -= size;
3541 
3542 		dma = skb_frag_dma_map(tx_ring->dev, frag, 0, size,
3543 				       DMA_TO_DEVICE);
3544 		if (dma_mapping_error(tx_ring->dev, dma))
3545 			goto dma_error;
3546 
3547 		tx_buffer = &tx_ring->tx_buffer_info[i];
3548 		dma_unmap_len_set(tx_buffer, len, size);
3549 		dma_unmap_addr_set(tx_buffer, dma, dma);
3550 
3551 		tx_desc->read.buffer_addr = cpu_to_le64(dma);
3552 		tx_desc->read.olinfo_status = 0;
3553 
3554 		frag++;
3555 	}
3556 
3557 	/* write last descriptor with RS and EOP bits */
3558 	cmd_type |= cpu_to_le32(size) | cpu_to_le32(IXGBE_TXD_CMD);
3559 	tx_desc->read.cmd_type_len = cmd_type;
3560 
3561 	/* set the timestamp */
3562 	first->time_stamp = jiffies;
3563 
3564 	/* Force memory writes to complete before letting h/w know there
3565 	 * are new descriptors to fetch.  (Only applicable for weak-ordered
3566 	 * memory model archs, such as IA-64).
3567 	 *
3568 	 * We also need this memory barrier (wmb) to make certain all of the
3569 	 * status bits have been updated before next_to_watch is written.
3570 	 */
3571 	wmb();
3572 
3573 	/* set next_to_watch value indicating a packet is present */
3574 	first->next_to_watch = tx_desc;
3575 
3576 	i++;
3577 	if (i == tx_ring->count)
3578 		i = 0;
3579 
3580 	tx_ring->next_to_use = i;
3581 
3582 	/* notify HW of packet */
3583 	ixgbevf_write_tail(tx_ring, i);
3584 
3585 	return;
3586 dma_error:
3587 	dev_err(tx_ring->dev, "TX DMA map failed\n");
3588 
3589 	/* clear dma mappings for failed tx_buffer_info map */
3590 	for (;;) {
3591 		tx_buffer = &tx_ring->tx_buffer_info[i];
3592 		ixgbevf_unmap_and_free_tx_resource(tx_ring, tx_buffer);
3593 		if (tx_buffer == first)
3594 			break;
3595 		if (i == 0)
3596 			i = tx_ring->count;
3597 		i--;
3598 	}
3599 
3600 	tx_ring->next_to_use = i;
3601 }
3602 
3603 static int __ixgbevf_maybe_stop_tx(struct ixgbevf_ring *tx_ring, int size)
3604 {
3605 	netif_stop_subqueue(tx_ring->netdev, tx_ring->queue_index);
3606 	/* Herbert's original patch had:
3607 	 *  smp_mb__after_netif_stop_queue();
3608 	 * but since that doesn't exist yet, just open code it.
3609 	 */
3610 	smp_mb();
3611 
3612 	/* We need to check again in a case another CPU has just
3613 	 * made room available.
3614 	 */
3615 	if (likely(ixgbevf_desc_unused(tx_ring) < size))
3616 		return -EBUSY;
3617 
3618 	/* A reprieve! - use start_queue because it doesn't call schedule */
3619 	netif_start_subqueue(tx_ring->netdev, tx_ring->queue_index);
3620 	++tx_ring->tx_stats.restart_queue;
3621 
3622 	return 0;
3623 }
3624 
3625 static int ixgbevf_maybe_stop_tx(struct ixgbevf_ring *tx_ring, int size)
3626 {
3627 	if (likely(ixgbevf_desc_unused(tx_ring) >= size))
3628 		return 0;
3629 	return __ixgbevf_maybe_stop_tx(tx_ring, size);
3630 }
3631 
3632 static int ixgbevf_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
3633 {
3634 	struct ixgbevf_adapter *adapter = netdev_priv(netdev);
3635 	struct ixgbevf_tx_buffer *first;
3636 	struct ixgbevf_ring *tx_ring;
3637 	int tso;
3638 	u32 tx_flags = 0;
3639 	u16 count = TXD_USE_COUNT(skb_headlen(skb));
3640 #if PAGE_SIZE > IXGBE_MAX_DATA_PER_TXD
3641 	unsigned short f;
3642 #endif
3643 	u8 hdr_len = 0;
3644 	u8 *dst_mac = skb_header_pointer(skb, 0, 0, NULL);
3645 
3646 	if (!dst_mac || is_link_local_ether_addr(dst_mac)) {
3647 		dev_kfree_skb_any(skb);
3648 		return NETDEV_TX_OK;
3649 	}
3650 
3651 	tx_ring = adapter->tx_ring[skb->queue_mapping];
3652 
3653 	/* need: 1 descriptor per page * PAGE_SIZE/IXGBE_MAX_DATA_PER_TXD,
3654 	 *       + 1 desc for skb_headlen/IXGBE_MAX_DATA_PER_TXD,
3655 	 *       + 2 desc gap to keep tail from touching head,
3656 	 *       + 1 desc for context descriptor,
3657 	 * otherwise try next time
3658 	 */
3659 #if PAGE_SIZE > IXGBE_MAX_DATA_PER_TXD
3660 	for (f = 0; f < skb_shinfo(skb)->nr_frags; f++)
3661 		count += TXD_USE_COUNT(skb_shinfo(skb)->frags[f].size);
3662 #else
3663 	count += skb_shinfo(skb)->nr_frags;
3664 #endif
3665 	if (ixgbevf_maybe_stop_tx(tx_ring, count + 3)) {
3666 		tx_ring->tx_stats.tx_busy++;
3667 		return NETDEV_TX_BUSY;
3668 	}
3669 
3670 	/* record the location of the first descriptor for this packet */
3671 	first = &tx_ring->tx_buffer_info[tx_ring->next_to_use];
3672 	first->skb = skb;
3673 	first->bytecount = skb->len;
3674 	first->gso_segs = 1;
3675 
3676 	if (skb_vlan_tag_present(skb)) {
3677 		tx_flags |= skb_vlan_tag_get(skb);
3678 		tx_flags <<= IXGBE_TX_FLAGS_VLAN_SHIFT;
3679 		tx_flags |= IXGBE_TX_FLAGS_VLAN;
3680 	}
3681 
3682 	/* record initial flags and protocol */
3683 	first->tx_flags = tx_flags;
3684 	first->protocol = vlan_get_protocol(skb);
3685 
3686 	tso = ixgbevf_tso(tx_ring, first, &hdr_len);
3687 	if (tso < 0)
3688 		goto out_drop;
3689 	else if (!tso)
3690 		ixgbevf_tx_csum(tx_ring, first);
3691 
3692 	ixgbevf_tx_map(tx_ring, first, hdr_len);
3693 
3694 	ixgbevf_maybe_stop_tx(tx_ring, DESC_NEEDED);
3695 
3696 	return NETDEV_TX_OK;
3697 
3698 out_drop:
3699 	dev_kfree_skb_any(first->skb);
3700 	first->skb = NULL;
3701 
3702 	return NETDEV_TX_OK;
3703 }
3704 
3705 /**
3706  * ixgbevf_set_mac - Change the Ethernet Address of the NIC
3707  * @netdev: network interface device structure
3708  * @p: pointer to an address structure
3709  *
3710  * Returns 0 on success, negative on failure
3711  **/
3712 static int ixgbevf_set_mac(struct net_device *netdev, void *p)
3713 {
3714 	struct ixgbevf_adapter *adapter = netdev_priv(netdev);
3715 	struct ixgbe_hw *hw = &adapter->hw;
3716 	struct sockaddr *addr = p;
3717 	int err;
3718 
3719 	if (!is_valid_ether_addr(addr->sa_data))
3720 		return -EADDRNOTAVAIL;
3721 
3722 	spin_lock_bh(&adapter->mbx_lock);
3723 
3724 	err = hw->mac.ops.set_rar(hw, 0, addr->sa_data, 0);
3725 
3726 	spin_unlock_bh(&adapter->mbx_lock);
3727 
3728 	if (err)
3729 		return -EPERM;
3730 
3731 	ether_addr_copy(hw->mac.addr, addr->sa_data);
3732 	ether_addr_copy(netdev->dev_addr, addr->sa_data);
3733 
3734 	return 0;
3735 }
3736 
3737 /**
3738  * ixgbevf_change_mtu - Change the Maximum Transfer Unit
3739  * @netdev: network interface device structure
3740  * @new_mtu: new value for maximum frame size
3741  *
3742  * Returns 0 on success, negative on failure
3743  **/
3744 static int ixgbevf_change_mtu(struct net_device *netdev, int new_mtu)
3745 {
3746 	struct ixgbevf_adapter *adapter = netdev_priv(netdev);
3747 	struct ixgbe_hw *hw = &adapter->hw;
3748 	int max_frame = new_mtu + ETH_HLEN + ETH_FCS_LEN;
3749 	int ret;
3750 
3751 	spin_lock_bh(&adapter->mbx_lock);
3752 	/* notify the PF of our intent to use this size of frame */
3753 	ret = hw->mac.ops.set_rlpml(hw, max_frame);
3754 	spin_unlock_bh(&adapter->mbx_lock);
3755 	if (ret)
3756 		return -EINVAL;
3757 
3758 	hw_dbg(hw, "changing MTU from %d to %d\n",
3759 	       netdev->mtu, new_mtu);
3760 
3761 	/* must set new MTU before calling down or up */
3762 	netdev->mtu = new_mtu;
3763 
3764 	return 0;
3765 }
3766 
3767 #ifdef CONFIG_NET_POLL_CONTROLLER
3768 /* Polling 'interrupt' - used by things like netconsole to send skbs
3769  * without having to re-enable interrupts. It's not called while
3770  * the interrupt routine is executing.
3771  */
3772 static void ixgbevf_netpoll(struct net_device *netdev)
3773 {
3774 	struct ixgbevf_adapter *adapter = netdev_priv(netdev);
3775 	int i;
3776 
3777 	/* if interface is down do nothing */
3778 	if (test_bit(__IXGBEVF_DOWN, &adapter->state))
3779 		return;
3780 	for (i = 0; i < adapter->num_rx_queues; i++)
3781 		ixgbevf_msix_clean_rings(0, adapter->q_vector[i]);
3782 }
3783 #endif /* CONFIG_NET_POLL_CONTROLLER */
3784 
3785 static int ixgbevf_suspend(struct pci_dev *pdev, pm_message_t state)
3786 {
3787 	struct net_device *netdev = pci_get_drvdata(pdev);
3788 	struct ixgbevf_adapter *adapter = netdev_priv(netdev);
3789 #ifdef CONFIG_PM
3790 	int retval = 0;
3791 #endif
3792 
3793 	rtnl_lock();
3794 	netif_device_detach(netdev);
3795 
3796 	if (netif_running(netdev))
3797 		ixgbevf_close_suspend(adapter);
3798 
3799 	ixgbevf_clear_interrupt_scheme(adapter);
3800 	rtnl_unlock();
3801 
3802 #ifdef CONFIG_PM
3803 	retval = pci_save_state(pdev);
3804 	if (retval)
3805 		return retval;
3806 
3807 #endif
3808 	if (!test_and_set_bit(__IXGBEVF_DISABLED, &adapter->state))
3809 		pci_disable_device(pdev);
3810 
3811 	return 0;
3812 }
3813 
3814 #ifdef CONFIG_PM
3815 static int ixgbevf_resume(struct pci_dev *pdev)
3816 {
3817 	struct net_device *netdev = pci_get_drvdata(pdev);
3818 	struct ixgbevf_adapter *adapter = netdev_priv(netdev);
3819 	u32 err;
3820 
3821 	pci_restore_state(pdev);
3822 	/* pci_restore_state clears dev->state_saved so call
3823 	 * pci_save_state to restore it.
3824 	 */
3825 	pci_save_state(pdev);
3826 
3827 	err = pci_enable_device_mem(pdev);
3828 	if (err) {
3829 		dev_err(&pdev->dev, "Cannot enable PCI device from suspend\n");
3830 		return err;
3831 	}
3832 
3833 	adapter->hw.hw_addr = adapter->io_addr;
3834 	smp_mb__before_atomic();
3835 	clear_bit(__IXGBEVF_DISABLED, &adapter->state);
3836 	pci_set_master(pdev);
3837 
3838 	ixgbevf_reset(adapter);
3839 
3840 	rtnl_lock();
3841 	err = ixgbevf_init_interrupt_scheme(adapter);
3842 	rtnl_unlock();
3843 	if (err) {
3844 		dev_err(&pdev->dev, "Cannot initialize interrupts\n");
3845 		return err;
3846 	}
3847 
3848 	if (netif_running(netdev)) {
3849 		err = ixgbevf_open(netdev);
3850 		if (err)
3851 			return err;
3852 	}
3853 
3854 	netif_device_attach(netdev);
3855 
3856 	return err;
3857 }
3858 
3859 #endif /* CONFIG_PM */
3860 static void ixgbevf_shutdown(struct pci_dev *pdev)
3861 {
3862 	ixgbevf_suspend(pdev, PMSG_SUSPEND);
3863 }
3864 
3865 static void ixgbevf_get_stats(struct net_device *netdev,
3866 			      struct rtnl_link_stats64 *stats)
3867 {
3868 	struct ixgbevf_adapter *adapter = netdev_priv(netdev);
3869 	unsigned int start;
3870 	u64 bytes, packets;
3871 	const struct ixgbevf_ring *ring;
3872 	int i;
3873 
3874 	ixgbevf_update_stats(adapter);
3875 
3876 	stats->multicast = adapter->stats.vfmprc - adapter->stats.base_vfmprc;
3877 
3878 	for (i = 0; i < adapter->num_rx_queues; i++) {
3879 		ring = adapter->rx_ring[i];
3880 		do {
3881 			start = u64_stats_fetch_begin_irq(&ring->syncp);
3882 			bytes = ring->stats.bytes;
3883 			packets = ring->stats.packets;
3884 		} while (u64_stats_fetch_retry_irq(&ring->syncp, start));
3885 		stats->rx_bytes += bytes;
3886 		stats->rx_packets += packets;
3887 	}
3888 
3889 	for (i = 0; i < adapter->num_tx_queues; i++) {
3890 		ring = adapter->tx_ring[i];
3891 		do {
3892 			start = u64_stats_fetch_begin_irq(&ring->syncp);
3893 			bytes = ring->stats.bytes;
3894 			packets = ring->stats.packets;
3895 		} while (u64_stats_fetch_retry_irq(&ring->syncp, start));
3896 		stats->tx_bytes += bytes;
3897 		stats->tx_packets += packets;
3898 	}
3899 }
3900 
3901 #define IXGBEVF_MAX_MAC_HDR_LEN		127
3902 #define IXGBEVF_MAX_NETWORK_HDR_LEN	511
3903 
3904 static netdev_features_t
3905 ixgbevf_features_check(struct sk_buff *skb, struct net_device *dev,
3906 		       netdev_features_t features)
3907 {
3908 	unsigned int network_hdr_len, mac_hdr_len;
3909 
3910 	/* Make certain the headers can be described by a context descriptor */
3911 	mac_hdr_len = skb_network_header(skb) - skb->data;
3912 	if (unlikely(mac_hdr_len > IXGBEVF_MAX_MAC_HDR_LEN))
3913 		return features & ~(NETIF_F_HW_CSUM |
3914 				    NETIF_F_SCTP_CRC |
3915 				    NETIF_F_HW_VLAN_CTAG_TX |
3916 				    NETIF_F_TSO |
3917 				    NETIF_F_TSO6);
3918 
3919 	network_hdr_len = skb_checksum_start(skb) - skb_network_header(skb);
3920 	if (unlikely(network_hdr_len >  IXGBEVF_MAX_NETWORK_HDR_LEN))
3921 		return features & ~(NETIF_F_HW_CSUM |
3922 				    NETIF_F_SCTP_CRC |
3923 				    NETIF_F_TSO |
3924 				    NETIF_F_TSO6);
3925 
3926 	/* We can only support IPV4 TSO in tunnels if we can mangle the
3927 	 * inner IP ID field, so strip TSO if MANGLEID is not supported.
3928 	 */
3929 	if (skb->encapsulation && !(features & NETIF_F_TSO_MANGLEID))
3930 		features &= ~NETIF_F_TSO;
3931 
3932 	return features;
3933 }
3934 
3935 static const struct net_device_ops ixgbevf_netdev_ops = {
3936 	.ndo_open		= ixgbevf_open,
3937 	.ndo_stop		= ixgbevf_close,
3938 	.ndo_start_xmit		= ixgbevf_xmit_frame,
3939 	.ndo_set_rx_mode	= ixgbevf_set_rx_mode,
3940 	.ndo_get_stats64	= ixgbevf_get_stats,
3941 	.ndo_validate_addr	= eth_validate_addr,
3942 	.ndo_set_mac_address	= ixgbevf_set_mac,
3943 	.ndo_change_mtu		= ixgbevf_change_mtu,
3944 	.ndo_tx_timeout		= ixgbevf_tx_timeout,
3945 	.ndo_vlan_rx_add_vid	= ixgbevf_vlan_rx_add_vid,
3946 	.ndo_vlan_rx_kill_vid	= ixgbevf_vlan_rx_kill_vid,
3947 #ifdef CONFIG_NET_POLL_CONTROLLER
3948 	.ndo_poll_controller	= ixgbevf_netpoll,
3949 #endif
3950 	.ndo_features_check	= ixgbevf_features_check,
3951 };
3952 
3953 static void ixgbevf_assign_netdev_ops(struct net_device *dev)
3954 {
3955 	dev->netdev_ops = &ixgbevf_netdev_ops;
3956 	ixgbevf_set_ethtool_ops(dev);
3957 	dev->watchdog_timeo = 5 * HZ;
3958 }
3959 
3960 /**
3961  * ixgbevf_probe - Device Initialization Routine
3962  * @pdev: PCI device information struct
3963  * @ent: entry in ixgbevf_pci_tbl
3964  *
3965  * Returns 0 on success, negative on failure
3966  *
3967  * ixgbevf_probe initializes an adapter identified by a pci_dev structure.
3968  * The OS initialization, configuring of the adapter private structure,
3969  * and a hardware reset occur.
3970  **/
3971 static int ixgbevf_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
3972 {
3973 	struct net_device *netdev;
3974 	struct ixgbevf_adapter *adapter = NULL;
3975 	struct ixgbe_hw *hw = NULL;
3976 	const struct ixgbevf_info *ii = ixgbevf_info_tbl[ent->driver_data];
3977 	int err, pci_using_dac;
3978 	bool disable_dev = false;
3979 
3980 	err = pci_enable_device(pdev);
3981 	if (err)
3982 		return err;
3983 
3984 	if (!dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64))) {
3985 		pci_using_dac = 1;
3986 	} else {
3987 		err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
3988 		if (err) {
3989 			dev_err(&pdev->dev, "No usable DMA configuration, aborting\n");
3990 			goto err_dma;
3991 		}
3992 		pci_using_dac = 0;
3993 	}
3994 
3995 	err = pci_request_regions(pdev, ixgbevf_driver_name);
3996 	if (err) {
3997 		dev_err(&pdev->dev, "pci_request_regions failed 0x%x\n", err);
3998 		goto err_pci_reg;
3999 	}
4000 
4001 	pci_set_master(pdev);
4002 
4003 	netdev = alloc_etherdev_mq(sizeof(struct ixgbevf_adapter),
4004 				   MAX_TX_QUEUES);
4005 	if (!netdev) {
4006 		err = -ENOMEM;
4007 		goto err_alloc_etherdev;
4008 	}
4009 
4010 	SET_NETDEV_DEV(netdev, &pdev->dev);
4011 
4012 	adapter = netdev_priv(netdev);
4013 
4014 	adapter->netdev = netdev;
4015 	adapter->pdev = pdev;
4016 	hw = &adapter->hw;
4017 	hw->back = adapter;
4018 	adapter->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE);
4019 
4020 	/* call save state here in standalone driver because it relies on
4021 	 * adapter struct to exist, and needs to call netdev_priv
4022 	 */
4023 	pci_save_state(pdev);
4024 
4025 	hw->hw_addr = ioremap(pci_resource_start(pdev, 0),
4026 			      pci_resource_len(pdev, 0));
4027 	adapter->io_addr = hw->hw_addr;
4028 	if (!hw->hw_addr) {
4029 		err = -EIO;
4030 		goto err_ioremap;
4031 	}
4032 
4033 	ixgbevf_assign_netdev_ops(netdev);
4034 
4035 	/* Setup HW API */
4036 	memcpy(&hw->mac.ops, ii->mac_ops, sizeof(hw->mac.ops));
4037 	hw->mac.type  = ii->mac;
4038 
4039 	memcpy(&hw->mbx.ops, &ixgbevf_mbx_ops,
4040 	       sizeof(struct ixgbe_mbx_operations));
4041 
4042 	/* setup the private structure */
4043 	err = ixgbevf_sw_init(adapter);
4044 	if (err)
4045 		goto err_sw_init;
4046 
4047 	/* The HW MAC address was set and/or determined in sw_init */
4048 	if (!is_valid_ether_addr(netdev->dev_addr)) {
4049 		pr_err("invalid MAC address\n");
4050 		err = -EIO;
4051 		goto err_sw_init;
4052 	}
4053 
4054 	netdev->hw_features = NETIF_F_SG |
4055 			      NETIF_F_TSO |
4056 			      NETIF_F_TSO6 |
4057 			      NETIF_F_RXCSUM |
4058 			      NETIF_F_HW_CSUM |
4059 			      NETIF_F_SCTP_CRC;
4060 
4061 #define IXGBEVF_GSO_PARTIAL_FEATURES (NETIF_F_GSO_GRE | \
4062 				      NETIF_F_GSO_GRE_CSUM | \
4063 				      NETIF_F_GSO_IPXIP4 | \
4064 				      NETIF_F_GSO_IPXIP6 | \
4065 				      NETIF_F_GSO_UDP_TUNNEL | \
4066 				      NETIF_F_GSO_UDP_TUNNEL_CSUM)
4067 
4068 	netdev->gso_partial_features = IXGBEVF_GSO_PARTIAL_FEATURES;
4069 	netdev->hw_features |= NETIF_F_GSO_PARTIAL |
4070 			       IXGBEVF_GSO_PARTIAL_FEATURES;
4071 
4072 	netdev->features = netdev->hw_features;
4073 
4074 	if (pci_using_dac)
4075 		netdev->features |= NETIF_F_HIGHDMA;
4076 
4077 	netdev->vlan_features |= netdev->features | NETIF_F_TSO_MANGLEID;
4078 	netdev->mpls_features |= NETIF_F_HW_CSUM;
4079 	netdev->hw_enc_features |= netdev->vlan_features;
4080 
4081 	/* set this bit last since it cannot be part of vlan_features */
4082 	netdev->features |= NETIF_F_HW_VLAN_CTAG_FILTER |
4083 			    NETIF_F_HW_VLAN_CTAG_RX |
4084 			    NETIF_F_HW_VLAN_CTAG_TX;
4085 
4086 	netdev->priv_flags |= IFF_UNICAST_FLT;
4087 
4088 	/* MTU range: 68 - 1504 or 9710 */
4089 	netdev->min_mtu = ETH_MIN_MTU;
4090 	switch (adapter->hw.api_version) {
4091 	case ixgbe_mbox_api_11:
4092 	case ixgbe_mbox_api_12:
4093 	case ixgbe_mbox_api_13:
4094 		netdev->max_mtu = IXGBE_MAX_JUMBO_FRAME_SIZE -
4095 				  (ETH_HLEN + ETH_FCS_LEN);
4096 		break;
4097 	default:
4098 		if (adapter->hw.mac.type != ixgbe_mac_82599_vf)
4099 			netdev->max_mtu = IXGBE_MAX_JUMBO_FRAME_SIZE -
4100 					  (ETH_HLEN + ETH_FCS_LEN);
4101 		else
4102 			netdev->max_mtu = ETH_DATA_LEN + ETH_FCS_LEN;
4103 		break;
4104 	}
4105 
4106 	if (IXGBE_REMOVED(hw->hw_addr)) {
4107 		err = -EIO;
4108 		goto err_sw_init;
4109 	}
4110 
4111 	setup_timer(&adapter->service_timer, &ixgbevf_service_timer,
4112 		    (unsigned long)adapter);
4113 
4114 	INIT_WORK(&adapter->service_task, ixgbevf_service_task);
4115 	set_bit(__IXGBEVF_SERVICE_INITED, &adapter->state);
4116 	clear_bit(__IXGBEVF_SERVICE_SCHED, &adapter->state);
4117 
4118 	err = ixgbevf_init_interrupt_scheme(adapter);
4119 	if (err)
4120 		goto err_sw_init;
4121 
4122 	strcpy(netdev->name, "eth%d");
4123 
4124 	err = register_netdev(netdev);
4125 	if (err)
4126 		goto err_register;
4127 
4128 	pci_set_drvdata(pdev, netdev);
4129 	netif_carrier_off(netdev);
4130 
4131 	ixgbevf_init_last_counter_stats(adapter);
4132 
4133 	/* print the VF info */
4134 	dev_info(&pdev->dev, "%pM\n", netdev->dev_addr);
4135 	dev_info(&pdev->dev, "MAC: %d\n", hw->mac.type);
4136 
4137 	switch (hw->mac.type) {
4138 	case ixgbe_mac_X550_vf:
4139 		dev_info(&pdev->dev, "Intel(R) X550 Virtual Function\n");
4140 		break;
4141 	case ixgbe_mac_X540_vf:
4142 		dev_info(&pdev->dev, "Intel(R) X540 Virtual Function\n");
4143 		break;
4144 	case ixgbe_mac_82599_vf:
4145 	default:
4146 		dev_info(&pdev->dev, "Intel(R) 82599 Virtual Function\n");
4147 		break;
4148 	}
4149 
4150 	return 0;
4151 
4152 err_register:
4153 	ixgbevf_clear_interrupt_scheme(adapter);
4154 err_sw_init:
4155 	ixgbevf_reset_interrupt_capability(adapter);
4156 	iounmap(adapter->io_addr);
4157 	kfree(adapter->rss_key);
4158 err_ioremap:
4159 	disable_dev = !test_and_set_bit(__IXGBEVF_DISABLED, &adapter->state);
4160 	free_netdev(netdev);
4161 err_alloc_etherdev:
4162 	pci_release_regions(pdev);
4163 err_pci_reg:
4164 err_dma:
4165 	if (!adapter || disable_dev)
4166 		pci_disable_device(pdev);
4167 	return err;
4168 }
4169 
4170 /**
4171  * ixgbevf_remove - Device Removal Routine
4172  * @pdev: PCI device information struct
4173  *
4174  * ixgbevf_remove is called by the PCI subsystem to alert the driver
4175  * that it should release a PCI device.  The could be caused by a
4176  * Hot-Plug event, or because the driver is going to be removed from
4177  * memory.
4178  **/
4179 static void ixgbevf_remove(struct pci_dev *pdev)
4180 {
4181 	struct net_device *netdev = pci_get_drvdata(pdev);
4182 	struct ixgbevf_adapter *adapter;
4183 	bool disable_dev;
4184 
4185 	if (!netdev)
4186 		return;
4187 
4188 	adapter = netdev_priv(netdev);
4189 
4190 	set_bit(__IXGBEVF_REMOVING, &adapter->state);
4191 	cancel_work_sync(&adapter->service_task);
4192 
4193 	if (netdev->reg_state == NETREG_REGISTERED)
4194 		unregister_netdev(netdev);
4195 
4196 	ixgbevf_clear_interrupt_scheme(adapter);
4197 	ixgbevf_reset_interrupt_capability(adapter);
4198 
4199 	iounmap(adapter->io_addr);
4200 	pci_release_regions(pdev);
4201 
4202 	hw_dbg(&adapter->hw, "Remove complete\n");
4203 
4204 	kfree(adapter->rss_key);
4205 	disable_dev = !test_and_set_bit(__IXGBEVF_DISABLED, &adapter->state);
4206 	free_netdev(netdev);
4207 
4208 	if (disable_dev)
4209 		pci_disable_device(pdev);
4210 }
4211 
4212 /**
4213  * ixgbevf_io_error_detected - called when PCI error is detected
4214  * @pdev: Pointer to PCI device
4215  * @state: The current pci connection state
4216  *
4217  * This function is called after a PCI bus error affecting
4218  * this device has been detected.
4219  **/
4220 static pci_ers_result_t ixgbevf_io_error_detected(struct pci_dev *pdev,
4221 						  pci_channel_state_t state)
4222 {
4223 	struct net_device *netdev = pci_get_drvdata(pdev);
4224 	struct ixgbevf_adapter *adapter = netdev_priv(netdev);
4225 
4226 	if (!test_bit(__IXGBEVF_SERVICE_INITED, &adapter->state))
4227 		return PCI_ERS_RESULT_DISCONNECT;
4228 
4229 	rtnl_lock();
4230 	netif_device_detach(netdev);
4231 
4232 	if (state == pci_channel_io_perm_failure) {
4233 		rtnl_unlock();
4234 		return PCI_ERS_RESULT_DISCONNECT;
4235 	}
4236 
4237 	if (netif_running(netdev))
4238 		ixgbevf_close_suspend(adapter);
4239 
4240 	if (!test_and_set_bit(__IXGBEVF_DISABLED, &adapter->state))
4241 		pci_disable_device(pdev);
4242 	rtnl_unlock();
4243 
4244 	/* Request a slot slot reset. */
4245 	return PCI_ERS_RESULT_NEED_RESET;
4246 }
4247 
4248 /**
4249  * ixgbevf_io_slot_reset - called after the pci bus has been reset.
4250  * @pdev: Pointer to PCI device
4251  *
4252  * Restart the card from scratch, as if from a cold-boot. Implementation
4253  * resembles the first-half of the ixgbevf_resume routine.
4254  **/
4255 static pci_ers_result_t ixgbevf_io_slot_reset(struct pci_dev *pdev)
4256 {
4257 	struct net_device *netdev = pci_get_drvdata(pdev);
4258 	struct ixgbevf_adapter *adapter = netdev_priv(netdev);
4259 
4260 	if (pci_enable_device_mem(pdev)) {
4261 		dev_err(&pdev->dev,
4262 			"Cannot re-enable PCI device after reset.\n");
4263 		return PCI_ERS_RESULT_DISCONNECT;
4264 	}
4265 
4266 	adapter->hw.hw_addr = adapter->io_addr;
4267 	smp_mb__before_atomic();
4268 	clear_bit(__IXGBEVF_DISABLED, &adapter->state);
4269 	pci_set_master(pdev);
4270 
4271 	ixgbevf_reset(adapter);
4272 
4273 	return PCI_ERS_RESULT_RECOVERED;
4274 }
4275 
4276 /**
4277  * ixgbevf_io_resume - called when traffic can start flowing again.
4278  * @pdev: Pointer to PCI device
4279  *
4280  * This callback is called when the error recovery driver tells us that
4281  * its OK to resume normal operation. Implementation resembles the
4282  * second-half of the ixgbevf_resume routine.
4283  **/
4284 static void ixgbevf_io_resume(struct pci_dev *pdev)
4285 {
4286 	struct net_device *netdev = pci_get_drvdata(pdev);
4287 
4288 	rtnl_lock();
4289 	if (netif_running(netdev))
4290 		ixgbevf_open(netdev);
4291 
4292 	netif_device_attach(netdev);
4293 	rtnl_unlock();
4294 }
4295 
4296 /* PCI Error Recovery (ERS) */
4297 static const struct pci_error_handlers ixgbevf_err_handler = {
4298 	.error_detected = ixgbevf_io_error_detected,
4299 	.slot_reset = ixgbevf_io_slot_reset,
4300 	.resume = ixgbevf_io_resume,
4301 };
4302 
4303 static struct pci_driver ixgbevf_driver = {
4304 	.name		= ixgbevf_driver_name,
4305 	.id_table	= ixgbevf_pci_tbl,
4306 	.probe		= ixgbevf_probe,
4307 	.remove		= ixgbevf_remove,
4308 #ifdef CONFIG_PM
4309 	/* Power Management Hooks */
4310 	.suspend	= ixgbevf_suspend,
4311 	.resume		= ixgbevf_resume,
4312 #endif
4313 	.shutdown	= ixgbevf_shutdown,
4314 	.err_handler	= &ixgbevf_err_handler
4315 };
4316 
4317 /**
4318  * ixgbevf_init_module - Driver Registration Routine
4319  *
4320  * ixgbevf_init_module is the first routine called when the driver is
4321  * loaded. All it does is register with the PCI subsystem.
4322  **/
4323 static int __init ixgbevf_init_module(void)
4324 {
4325 	pr_info("%s - version %s\n", ixgbevf_driver_string,
4326 		ixgbevf_driver_version);
4327 
4328 	pr_info("%s\n", ixgbevf_copyright);
4329 	ixgbevf_wq = create_singlethread_workqueue(ixgbevf_driver_name);
4330 	if (!ixgbevf_wq) {
4331 		pr_err("%s: Failed to create workqueue\n", ixgbevf_driver_name);
4332 		return -ENOMEM;
4333 	}
4334 
4335 	return pci_register_driver(&ixgbevf_driver);
4336 }
4337 
4338 module_init(ixgbevf_init_module);
4339 
4340 /**
4341  * ixgbevf_exit_module - Driver Exit Cleanup Routine
4342  *
4343  * ixgbevf_exit_module is called just before the driver is removed
4344  * from memory.
4345  **/
4346 static void __exit ixgbevf_exit_module(void)
4347 {
4348 	pci_unregister_driver(&ixgbevf_driver);
4349 	if (ixgbevf_wq) {
4350 		destroy_workqueue(ixgbevf_wq);
4351 		ixgbevf_wq = NULL;
4352 	}
4353 }
4354 
4355 #ifdef DEBUG
4356 /**
4357  * ixgbevf_get_hw_dev_name - return device name string
4358  * used by hardware layer to print debugging information
4359  **/
4360 char *ixgbevf_get_hw_dev_name(struct ixgbe_hw *hw)
4361 {
4362 	struct ixgbevf_adapter *adapter = hw->back;
4363 
4364 	return adapter->netdev->name;
4365 }
4366 
4367 #endif
4368 module_exit(ixgbevf_exit_module);
4369 
4370 /* ixgbevf_main.c */
4371