• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*******************************************************************************
2 
3   Intel PRO/10GbE Linux driver
4   Copyright(c) 1999 - 2008 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, write to the Free Software Foundation, Inc.,
17   51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
18 
19   The full GNU General Public License is included in this distribution in
20   the file called "COPYING".
21 
22   Contact Information:
23   Linux NICS <linux.nics@intel.com>
24   e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
25   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
26 
27 *******************************************************************************/
28 
29 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
30 
31 #include <linux/prefetch.h>
32 #include "ixgb.h"
33 
34 char ixgb_driver_name[] = "ixgb";
35 static char ixgb_driver_string[] = "Intel(R) PRO/10GbE Network Driver";
36 
37 #define DRIVERNAPI "-NAPI"
38 #define DRV_VERSION "1.0.135-k2" DRIVERNAPI
39 const char ixgb_driver_version[] = DRV_VERSION;
40 static const char ixgb_copyright[] = "Copyright (c) 1999-2008 Intel Corporation.";
41 
42 #define IXGB_CB_LENGTH 256
43 static unsigned int copybreak __read_mostly = IXGB_CB_LENGTH;
44 module_param(copybreak, uint, 0644);
45 MODULE_PARM_DESC(copybreak,
46 	"Maximum size of packet that is copied to a new buffer on receive");
47 
48 /* ixgb_pci_tbl - PCI Device ID Table
49  *
50  * Wildcard entries (PCI_ANY_ID) should come last
51  * Last entry must be all 0s
52  *
53  * { Vendor ID, Device ID, SubVendor ID, SubDevice ID,
54  *   Class, Class Mask, private data (not used) }
55  */
56 static DEFINE_PCI_DEVICE_TABLE(ixgb_pci_tbl) = {
57 	{PCI_VENDOR_ID_INTEL, IXGB_DEVICE_ID_82597EX,
58 	 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
59 	{PCI_VENDOR_ID_INTEL, IXGB_DEVICE_ID_82597EX_CX4,
60 	 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
61 	{PCI_VENDOR_ID_INTEL, IXGB_DEVICE_ID_82597EX_SR,
62 	 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
63 	{PCI_VENDOR_ID_INTEL, IXGB_DEVICE_ID_82597EX_LR,
64 	 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
65 
66 	/* required last entry */
67 	{0,}
68 };
69 
70 MODULE_DEVICE_TABLE(pci, ixgb_pci_tbl);
71 
72 /* Local Function Prototypes */
73 static int ixgb_init_module(void);
74 static void ixgb_exit_module(void);
75 static int ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent);
76 static void ixgb_remove(struct pci_dev *pdev);
77 static int ixgb_sw_init(struct ixgb_adapter *adapter);
78 static int ixgb_open(struct net_device *netdev);
79 static int ixgb_close(struct net_device *netdev);
80 static void ixgb_configure_tx(struct ixgb_adapter *adapter);
81 static void ixgb_configure_rx(struct ixgb_adapter *adapter);
82 static void ixgb_setup_rctl(struct ixgb_adapter *adapter);
83 static void ixgb_clean_tx_ring(struct ixgb_adapter *adapter);
84 static void ixgb_clean_rx_ring(struct ixgb_adapter *adapter);
85 static void ixgb_set_multi(struct net_device *netdev);
86 static void ixgb_watchdog(unsigned long data);
87 static netdev_tx_t ixgb_xmit_frame(struct sk_buff *skb,
88 				   struct net_device *netdev);
89 static struct net_device_stats *ixgb_get_stats(struct net_device *netdev);
90 static int ixgb_change_mtu(struct net_device *netdev, int new_mtu);
91 static int ixgb_set_mac(struct net_device *netdev, void *p);
92 static irqreturn_t ixgb_intr(int irq, void *data);
93 static bool ixgb_clean_tx_irq(struct ixgb_adapter *adapter);
94 
95 static int ixgb_clean(struct napi_struct *, int);
96 static bool ixgb_clean_rx_irq(struct ixgb_adapter *, int *, int);
97 static void ixgb_alloc_rx_buffers(struct ixgb_adapter *, int);
98 
99 static void ixgb_tx_timeout(struct net_device *dev);
100 static void ixgb_tx_timeout_task(struct work_struct *work);
101 
102 static void ixgb_vlan_strip_enable(struct ixgb_adapter *adapter);
103 static void ixgb_vlan_strip_disable(struct ixgb_adapter *adapter);
104 static int ixgb_vlan_rx_add_vid(struct net_device *netdev,
105 				__be16 proto, u16 vid);
106 static int ixgb_vlan_rx_kill_vid(struct net_device *netdev,
107 				 __be16 proto, u16 vid);
108 static void ixgb_restore_vlan(struct ixgb_adapter *adapter);
109 
110 #ifdef CONFIG_NET_POLL_CONTROLLER
111 /* for netdump / net console */
112 static void ixgb_netpoll(struct net_device *dev);
113 #endif
114 
115 static pci_ers_result_t ixgb_io_error_detected (struct pci_dev *pdev,
116                              enum pci_channel_state state);
117 static pci_ers_result_t ixgb_io_slot_reset (struct pci_dev *pdev);
118 static void ixgb_io_resume (struct pci_dev *pdev);
119 
120 static const struct pci_error_handlers ixgb_err_handler = {
121 	.error_detected = ixgb_io_error_detected,
122 	.slot_reset = ixgb_io_slot_reset,
123 	.resume = ixgb_io_resume,
124 };
125 
126 static struct pci_driver ixgb_driver = {
127 	.name     = ixgb_driver_name,
128 	.id_table = ixgb_pci_tbl,
129 	.probe    = ixgb_probe,
130 	.remove   = ixgb_remove,
131 	.err_handler = &ixgb_err_handler
132 };
133 
134 MODULE_AUTHOR("Intel Corporation, <linux.nics@intel.com>");
135 MODULE_DESCRIPTION("Intel(R) PRO/10GbE Network Driver");
136 MODULE_LICENSE("GPL");
137 MODULE_VERSION(DRV_VERSION);
138 
139 #define DEFAULT_MSG_ENABLE (NETIF_MSG_DRV|NETIF_MSG_PROBE|NETIF_MSG_LINK)
140 static int debug = -1;
141 module_param(debug, int, 0);
142 MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
143 
144 /**
145  * ixgb_init_module - Driver Registration Routine
146  *
147  * ixgb_init_module is the first routine called when the driver is
148  * loaded. All it does is register with the PCI subsystem.
149  **/
150 
151 static int __init
ixgb_init_module(void)152 ixgb_init_module(void)
153 {
154 	pr_info("%s - version %s\n", ixgb_driver_string, ixgb_driver_version);
155 	pr_info("%s\n", ixgb_copyright);
156 
157 	return pci_register_driver(&ixgb_driver);
158 }
159 
160 module_init(ixgb_init_module);
161 
162 /**
163  * ixgb_exit_module - Driver Exit Cleanup Routine
164  *
165  * ixgb_exit_module is called just before the driver is removed
166  * from memory.
167  **/
168 
169 static void __exit
ixgb_exit_module(void)170 ixgb_exit_module(void)
171 {
172 	pci_unregister_driver(&ixgb_driver);
173 }
174 
175 module_exit(ixgb_exit_module);
176 
177 /**
178  * ixgb_irq_disable - Mask off interrupt generation on the NIC
179  * @adapter: board private structure
180  **/
181 
182 static void
ixgb_irq_disable(struct ixgb_adapter * adapter)183 ixgb_irq_disable(struct ixgb_adapter *adapter)
184 {
185 	IXGB_WRITE_REG(&adapter->hw, IMC, ~0);
186 	IXGB_WRITE_FLUSH(&adapter->hw);
187 	synchronize_irq(adapter->pdev->irq);
188 }
189 
190 /**
191  * ixgb_irq_enable - Enable default interrupt generation settings
192  * @adapter: board private structure
193  **/
194 
195 static void
ixgb_irq_enable(struct ixgb_adapter * adapter)196 ixgb_irq_enable(struct ixgb_adapter *adapter)
197 {
198 	u32 val = IXGB_INT_RXT0 | IXGB_INT_RXDMT0 |
199 		  IXGB_INT_TXDW | IXGB_INT_LSC;
200 	if (adapter->hw.subsystem_vendor_id == PCI_VENDOR_ID_SUN)
201 		val |= IXGB_INT_GPI0;
202 	IXGB_WRITE_REG(&adapter->hw, IMS, val);
203 	IXGB_WRITE_FLUSH(&adapter->hw);
204 }
205 
206 int
ixgb_up(struct ixgb_adapter * adapter)207 ixgb_up(struct ixgb_adapter *adapter)
208 {
209 	struct net_device *netdev = adapter->netdev;
210 	int err, irq_flags = IRQF_SHARED;
211 	int max_frame = netdev->mtu + ENET_HEADER_SIZE + ENET_FCS_LENGTH;
212 	struct ixgb_hw *hw = &adapter->hw;
213 
214 	/* hardware has been reset, we need to reload some things */
215 
216 	ixgb_rar_set(hw, netdev->dev_addr, 0);
217 	ixgb_set_multi(netdev);
218 
219 	ixgb_restore_vlan(adapter);
220 
221 	ixgb_configure_tx(adapter);
222 	ixgb_setup_rctl(adapter);
223 	ixgb_configure_rx(adapter);
224 	ixgb_alloc_rx_buffers(adapter, IXGB_DESC_UNUSED(&adapter->rx_ring));
225 
226 	/* disable interrupts and get the hardware into a known state */
227 	IXGB_WRITE_REG(&adapter->hw, IMC, 0xffffffff);
228 
229 	/* only enable MSI if bus is in PCI-X mode */
230 	if (IXGB_READ_REG(&adapter->hw, STATUS) & IXGB_STATUS_PCIX_MODE) {
231 		err = pci_enable_msi(adapter->pdev);
232 		if (!err) {
233 			adapter->have_msi = true;
234 			irq_flags = 0;
235 		}
236 		/* proceed to try to request regular interrupt */
237 	}
238 
239 	err = request_irq(adapter->pdev->irq, ixgb_intr, irq_flags,
240 	                  netdev->name, netdev);
241 	if (err) {
242 		if (adapter->have_msi)
243 			pci_disable_msi(adapter->pdev);
244 		netif_err(adapter, probe, adapter->netdev,
245 			  "Unable to allocate interrupt Error: %d\n", err);
246 		return err;
247 	}
248 
249 	if ((hw->max_frame_size != max_frame) ||
250 		(hw->max_frame_size !=
251 		(IXGB_READ_REG(hw, MFS) >> IXGB_MFS_SHIFT))) {
252 
253 		hw->max_frame_size = max_frame;
254 
255 		IXGB_WRITE_REG(hw, MFS, hw->max_frame_size << IXGB_MFS_SHIFT);
256 
257 		if (hw->max_frame_size >
258 		   IXGB_MAX_ENET_FRAME_SIZE_WITHOUT_FCS + ENET_FCS_LENGTH) {
259 			u32 ctrl0 = IXGB_READ_REG(hw, CTRL0);
260 
261 			if (!(ctrl0 & IXGB_CTRL0_JFE)) {
262 				ctrl0 |= IXGB_CTRL0_JFE;
263 				IXGB_WRITE_REG(hw, CTRL0, ctrl0);
264 			}
265 		}
266 	}
267 
268 	clear_bit(__IXGB_DOWN, &adapter->flags);
269 
270 	napi_enable(&adapter->napi);
271 	ixgb_irq_enable(adapter);
272 
273 	netif_wake_queue(netdev);
274 
275 	mod_timer(&adapter->watchdog_timer, jiffies);
276 
277 	return 0;
278 }
279 
280 void
ixgb_down(struct ixgb_adapter * adapter,bool kill_watchdog)281 ixgb_down(struct ixgb_adapter *adapter, bool kill_watchdog)
282 {
283 	struct net_device *netdev = adapter->netdev;
284 
285 	/* prevent the interrupt handler from restarting watchdog */
286 	set_bit(__IXGB_DOWN, &adapter->flags);
287 
288 	napi_disable(&adapter->napi);
289 	/* waiting for NAPI to complete can re-enable interrupts */
290 	ixgb_irq_disable(adapter);
291 	free_irq(adapter->pdev->irq, netdev);
292 
293 	if (adapter->have_msi)
294 		pci_disable_msi(adapter->pdev);
295 
296 	if (kill_watchdog)
297 		del_timer_sync(&adapter->watchdog_timer);
298 
299 	adapter->link_speed = 0;
300 	adapter->link_duplex = 0;
301 	netif_carrier_off(netdev);
302 	netif_stop_queue(netdev);
303 
304 	ixgb_reset(adapter);
305 	ixgb_clean_tx_ring(adapter);
306 	ixgb_clean_rx_ring(adapter);
307 }
308 
309 void
ixgb_reset(struct ixgb_adapter * adapter)310 ixgb_reset(struct ixgb_adapter *adapter)
311 {
312 	struct ixgb_hw *hw = &adapter->hw;
313 
314 	ixgb_adapter_stop(hw);
315 	if (!ixgb_init_hw(hw))
316 		netif_err(adapter, probe, adapter->netdev, "ixgb_init_hw failed\n");
317 
318 	/* restore frame size information */
319 	IXGB_WRITE_REG(hw, MFS, hw->max_frame_size << IXGB_MFS_SHIFT);
320 	if (hw->max_frame_size >
321 	    IXGB_MAX_ENET_FRAME_SIZE_WITHOUT_FCS + ENET_FCS_LENGTH) {
322 		u32 ctrl0 = IXGB_READ_REG(hw, CTRL0);
323 		if (!(ctrl0 & IXGB_CTRL0_JFE)) {
324 			ctrl0 |= IXGB_CTRL0_JFE;
325 			IXGB_WRITE_REG(hw, CTRL0, ctrl0);
326 		}
327 	}
328 }
329 
330 static netdev_features_t
ixgb_fix_features(struct net_device * netdev,netdev_features_t features)331 ixgb_fix_features(struct net_device *netdev, netdev_features_t features)
332 {
333 	/*
334 	 * Tx VLAN insertion does not work per HW design when Rx stripping is
335 	 * disabled.
336 	 */
337 	if (!(features & NETIF_F_HW_VLAN_CTAG_RX))
338 		features &= ~NETIF_F_HW_VLAN_CTAG_TX;
339 
340 	return features;
341 }
342 
343 static int
ixgb_set_features(struct net_device * netdev,netdev_features_t features)344 ixgb_set_features(struct net_device *netdev, netdev_features_t features)
345 {
346 	struct ixgb_adapter *adapter = netdev_priv(netdev);
347 	netdev_features_t changed = features ^ netdev->features;
348 
349 	if (!(changed & (NETIF_F_RXCSUM|NETIF_F_HW_VLAN_CTAG_RX)))
350 		return 0;
351 
352 	adapter->rx_csum = !!(features & NETIF_F_RXCSUM);
353 
354 	if (netif_running(netdev)) {
355 		ixgb_down(adapter, true);
356 		ixgb_up(adapter);
357 		ixgb_set_speed_duplex(netdev);
358 	} else
359 		ixgb_reset(adapter);
360 
361 	return 0;
362 }
363 
364 
365 static const struct net_device_ops ixgb_netdev_ops = {
366 	.ndo_open 		= ixgb_open,
367 	.ndo_stop		= ixgb_close,
368 	.ndo_start_xmit		= ixgb_xmit_frame,
369 	.ndo_get_stats		= ixgb_get_stats,
370 	.ndo_set_rx_mode	= ixgb_set_multi,
371 	.ndo_validate_addr	= eth_validate_addr,
372 	.ndo_set_mac_address	= ixgb_set_mac,
373 	.ndo_change_mtu		= ixgb_change_mtu,
374 	.ndo_tx_timeout		= ixgb_tx_timeout,
375 	.ndo_vlan_rx_add_vid	= ixgb_vlan_rx_add_vid,
376 	.ndo_vlan_rx_kill_vid	= ixgb_vlan_rx_kill_vid,
377 #ifdef CONFIG_NET_POLL_CONTROLLER
378 	.ndo_poll_controller	= ixgb_netpoll,
379 #endif
380 	.ndo_fix_features       = ixgb_fix_features,
381 	.ndo_set_features       = ixgb_set_features,
382 };
383 
384 /**
385  * ixgb_probe - Device Initialization Routine
386  * @pdev: PCI device information struct
387  * @ent: entry in ixgb_pci_tbl
388  *
389  * Returns 0 on success, negative on failure
390  *
391  * ixgb_probe initializes an adapter identified by a pci_dev structure.
392  * The OS initialization, configuring of the adapter private structure,
393  * and a hardware reset occur.
394  **/
395 
396 static int
ixgb_probe(struct pci_dev * pdev,const struct pci_device_id * ent)397 ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
398 {
399 	struct net_device *netdev = NULL;
400 	struct ixgb_adapter *adapter;
401 	static int cards_found = 0;
402 	int pci_using_dac;
403 	int i;
404 	int err;
405 
406 	err = pci_enable_device(pdev);
407 	if (err)
408 		return err;
409 
410 	pci_using_dac = 0;
411 	err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(64));
412 	if (!err) {
413 		err = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64));
414 		if (!err)
415 			pci_using_dac = 1;
416 	} else {
417 		err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
418 		if (err) {
419 			err = dma_set_coherent_mask(&pdev->dev,
420 						    DMA_BIT_MASK(32));
421 			if (err) {
422 				pr_err("No usable DMA configuration, aborting\n");
423 				goto err_dma_mask;
424 			}
425 		}
426 	}
427 
428 	err = pci_request_regions(pdev, ixgb_driver_name);
429 	if (err)
430 		goto err_request_regions;
431 
432 	pci_set_master(pdev);
433 
434 	netdev = alloc_etherdev(sizeof(struct ixgb_adapter));
435 	if (!netdev) {
436 		err = -ENOMEM;
437 		goto err_alloc_etherdev;
438 	}
439 
440 	SET_NETDEV_DEV(netdev, &pdev->dev);
441 
442 	pci_set_drvdata(pdev, netdev);
443 	adapter = netdev_priv(netdev);
444 	adapter->netdev = netdev;
445 	adapter->pdev = pdev;
446 	adapter->hw.back = adapter;
447 	adapter->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE);
448 
449 	adapter->hw.hw_addr = pci_ioremap_bar(pdev, BAR_0);
450 	if (!adapter->hw.hw_addr) {
451 		err = -EIO;
452 		goto err_ioremap;
453 	}
454 
455 	for (i = BAR_1; i <= BAR_5; i++) {
456 		if (pci_resource_len(pdev, i) == 0)
457 			continue;
458 		if (pci_resource_flags(pdev, i) & IORESOURCE_IO) {
459 			adapter->hw.io_base = pci_resource_start(pdev, i);
460 			break;
461 		}
462 	}
463 
464 	netdev->netdev_ops = &ixgb_netdev_ops;
465 	ixgb_set_ethtool_ops(netdev);
466 	netdev->watchdog_timeo = 5 * HZ;
467 	netif_napi_add(netdev, &adapter->napi, ixgb_clean, 64);
468 
469 	strncpy(netdev->name, pci_name(pdev), sizeof(netdev->name) - 1);
470 
471 	adapter->bd_number = cards_found;
472 	adapter->link_speed = 0;
473 	adapter->link_duplex = 0;
474 
475 	/* setup the private structure */
476 
477 	err = ixgb_sw_init(adapter);
478 	if (err)
479 		goto err_sw_init;
480 
481 	netdev->hw_features = NETIF_F_SG |
482 			   NETIF_F_TSO |
483 			   NETIF_F_HW_CSUM |
484 			   NETIF_F_HW_VLAN_CTAG_TX |
485 			   NETIF_F_HW_VLAN_CTAG_RX;
486 	netdev->features = netdev->hw_features |
487 			   NETIF_F_HW_VLAN_CTAG_FILTER;
488 	netdev->hw_features |= NETIF_F_RXCSUM;
489 
490 	if (pci_using_dac) {
491 		netdev->features |= NETIF_F_HIGHDMA;
492 		netdev->vlan_features |= NETIF_F_HIGHDMA;
493 	}
494 
495 	/* make sure the EEPROM is good */
496 
497 	if (!ixgb_validate_eeprom_checksum(&adapter->hw)) {
498 		netif_err(adapter, probe, adapter->netdev,
499 			  "The EEPROM Checksum Is Not Valid\n");
500 		err = -EIO;
501 		goto err_eeprom;
502 	}
503 
504 	ixgb_get_ee_mac_addr(&adapter->hw, netdev->dev_addr);
505 
506 	if (!is_valid_ether_addr(netdev->dev_addr)) {
507 		netif_err(adapter, probe, adapter->netdev, "Invalid MAC Address\n");
508 		err = -EIO;
509 		goto err_eeprom;
510 	}
511 
512 	adapter->part_num = ixgb_get_ee_pba_number(&adapter->hw);
513 
514 	init_timer(&adapter->watchdog_timer);
515 	adapter->watchdog_timer.function = ixgb_watchdog;
516 	adapter->watchdog_timer.data = (unsigned long)adapter;
517 
518 	INIT_WORK(&adapter->tx_timeout_task, ixgb_tx_timeout_task);
519 
520 	strcpy(netdev->name, "eth%d");
521 	err = register_netdev(netdev);
522 	if (err)
523 		goto err_register;
524 
525 	/* carrier off reporting is important to ethtool even BEFORE open */
526 	netif_carrier_off(netdev);
527 
528 	netif_info(adapter, probe, adapter->netdev,
529 		   "Intel(R) PRO/10GbE Network Connection\n");
530 	ixgb_check_options(adapter);
531 	/* reset the hardware with the new settings */
532 
533 	ixgb_reset(adapter);
534 
535 	cards_found++;
536 	return 0;
537 
538 err_register:
539 err_sw_init:
540 err_eeprom:
541 	iounmap(adapter->hw.hw_addr);
542 err_ioremap:
543 	free_netdev(netdev);
544 err_alloc_etherdev:
545 	pci_release_regions(pdev);
546 err_request_regions:
547 err_dma_mask:
548 	pci_disable_device(pdev);
549 	return err;
550 }
551 
552 /**
553  * ixgb_remove - Device Removal Routine
554  * @pdev: PCI device information struct
555  *
556  * ixgb_remove is called by the PCI subsystem to alert the driver
557  * that it should release a PCI device.  The could be caused by a
558  * Hot-Plug event, or because the driver is going to be removed from
559  * memory.
560  **/
561 
562 static void
ixgb_remove(struct pci_dev * pdev)563 ixgb_remove(struct pci_dev *pdev)
564 {
565 	struct net_device *netdev = pci_get_drvdata(pdev);
566 	struct ixgb_adapter *adapter = netdev_priv(netdev);
567 
568 	cancel_work_sync(&adapter->tx_timeout_task);
569 
570 	unregister_netdev(netdev);
571 
572 	iounmap(adapter->hw.hw_addr);
573 	pci_release_regions(pdev);
574 
575 	free_netdev(netdev);
576 	pci_disable_device(pdev);
577 }
578 
579 /**
580  * ixgb_sw_init - Initialize general software structures (struct ixgb_adapter)
581  * @adapter: board private structure to initialize
582  *
583  * ixgb_sw_init initializes the Adapter private data structure.
584  * Fields are initialized based on PCI device information and
585  * OS network device settings (MTU size).
586  **/
587 
588 static int
ixgb_sw_init(struct ixgb_adapter * adapter)589 ixgb_sw_init(struct ixgb_adapter *adapter)
590 {
591 	struct ixgb_hw *hw = &adapter->hw;
592 	struct net_device *netdev = adapter->netdev;
593 	struct pci_dev *pdev = adapter->pdev;
594 
595 	/* PCI config space info */
596 
597 	hw->vendor_id = pdev->vendor;
598 	hw->device_id = pdev->device;
599 	hw->subsystem_vendor_id = pdev->subsystem_vendor;
600 	hw->subsystem_id = pdev->subsystem_device;
601 
602 	hw->max_frame_size = netdev->mtu + ENET_HEADER_SIZE + ENET_FCS_LENGTH;
603 	adapter->rx_buffer_len = hw->max_frame_size + 8; /* + 8 for errata */
604 
605 	if ((hw->device_id == IXGB_DEVICE_ID_82597EX) ||
606 	    (hw->device_id == IXGB_DEVICE_ID_82597EX_CX4) ||
607 	    (hw->device_id == IXGB_DEVICE_ID_82597EX_LR) ||
608 	    (hw->device_id == IXGB_DEVICE_ID_82597EX_SR))
609 		hw->mac_type = ixgb_82597;
610 	else {
611 		/* should never have loaded on this device */
612 		netif_err(adapter, probe, adapter->netdev, "unsupported device id\n");
613 	}
614 
615 	/* enable flow control to be programmed */
616 	hw->fc.send_xon = 1;
617 
618 	set_bit(__IXGB_DOWN, &adapter->flags);
619 	return 0;
620 }
621 
622 /**
623  * ixgb_open - Called when a network interface is made active
624  * @netdev: network interface device structure
625  *
626  * Returns 0 on success, negative value on failure
627  *
628  * The open entry point is called when a network interface is made
629  * active by the system (IFF_UP).  At this point all resources needed
630  * for transmit and receive operations are allocated, the interrupt
631  * handler is registered with the OS, the watchdog timer is started,
632  * and the stack is notified that the interface is ready.
633  **/
634 
635 static int
ixgb_open(struct net_device * netdev)636 ixgb_open(struct net_device *netdev)
637 {
638 	struct ixgb_adapter *adapter = netdev_priv(netdev);
639 	int err;
640 
641 	/* allocate transmit descriptors */
642 	err = ixgb_setup_tx_resources(adapter);
643 	if (err)
644 		goto err_setup_tx;
645 
646 	netif_carrier_off(netdev);
647 
648 	/* allocate receive descriptors */
649 
650 	err = ixgb_setup_rx_resources(adapter);
651 	if (err)
652 		goto err_setup_rx;
653 
654 	err = ixgb_up(adapter);
655 	if (err)
656 		goto err_up;
657 
658 	netif_start_queue(netdev);
659 
660 	return 0;
661 
662 err_up:
663 	ixgb_free_rx_resources(adapter);
664 err_setup_rx:
665 	ixgb_free_tx_resources(adapter);
666 err_setup_tx:
667 	ixgb_reset(adapter);
668 
669 	return err;
670 }
671 
672 /**
673  * ixgb_close - Disables a network interface
674  * @netdev: network interface device structure
675  *
676  * Returns 0, this is not allowed to fail
677  *
678  * The close entry point is called when an interface is de-activated
679  * by the OS.  The hardware is still under the drivers control, but
680  * needs to be disabled.  A global MAC reset is issued to stop the
681  * hardware, and all transmit and receive resources are freed.
682  **/
683 
684 static int
ixgb_close(struct net_device * netdev)685 ixgb_close(struct net_device *netdev)
686 {
687 	struct ixgb_adapter *adapter = netdev_priv(netdev);
688 
689 	ixgb_down(adapter, true);
690 
691 	ixgb_free_tx_resources(adapter);
692 	ixgb_free_rx_resources(adapter);
693 
694 	return 0;
695 }
696 
697 /**
698  * ixgb_setup_tx_resources - allocate Tx resources (Descriptors)
699  * @adapter: board private structure
700  *
701  * Return 0 on success, negative on failure
702  **/
703 
704 int
ixgb_setup_tx_resources(struct ixgb_adapter * adapter)705 ixgb_setup_tx_resources(struct ixgb_adapter *adapter)
706 {
707 	struct ixgb_desc_ring *txdr = &adapter->tx_ring;
708 	struct pci_dev *pdev = adapter->pdev;
709 	int size;
710 
711 	size = sizeof(struct ixgb_buffer) * txdr->count;
712 	txdr->buffer_info = vzalloc(size);
713 	if (!txdr->buffer_info)
714 		return -ENOMEM;
715 
716 	/* round up to nearest 4K */
717 
718 	txdr->size = txdr->count * sizeof(struct ixgb_tx_desc);
719 	txdr->size = ALIGN(txdr->size, 4096);
720 
721 	txdr->desc = dma_alloc_coherent(&pdev->dev, txdr->size, &txdr->dma,
722 					GFP_KERNEL | __GFP_ZERO);
723 	if (!txdr->desc) {
724 		vfree(txdr->buffer_info);
725 		return -ENOMEM;
726 	}
727 
728 	txdr->next_to_use = 0;
729 	txdr->next_to_clean = 0;
730 
731 	return 0;
732 }
733 
734 /**
735  * ixgb_configure_tx - Configure 82597 Transmit Unit after Reset.
736  * @adapter: board private structure
737  *
738  * Configure the Tx unit of the MAC after a reset.
739  **/
740 
741 static void
ixgb_configure_tx(struct ixgb_adapter * adapter)742 ixgb_configure_tx(struct ixgb_adapter *adapter)
743 {
744 	u64 tdba = adapter->tx_ring.dma;
745 	u32 tdlen = adapter->tx_ring.count * sizeof(struct ixgb_tx_desc);
746 	u32 tctl;
747 	struct ixgb_hw *hw = &adapter->hw;
748 
749 	/* Setup the Base and Length of the Tx Descriptor Ring
750 	 * tx_ring.dma can be either a 32 or 64 bit value
751 	 */
752 
753 	IXGB_WRITE_REG(hw, TDBAL, (tdba & 0x00000000ffffffffULL));
754 	IXGB_WRITE_REG(hw, TDBAH, (tdba >> 32));
755 
756 	IXGB_WRITE_REG(hw, TDLEN, tdlen);
757 
758 	/* Setup the HW Tx Head and Tail descriptor pointers */
759 
760 	IXGB_WRITE_REG(hw, TDH, 0);
761 	IXGB_WRITE_REG(hw, TDT, 0);
762 
763 	/* don't set up txdctl, it induces performance problems if configured
764 	 * incorrectly */
765 	/* Set the Tx Interrupt Delay register */
766 
767 	IXGB_WRITE_REG(hw, TIDV, adapter->tx_int_delay);
768 
769 	/* Program the Transmit Control Register */
770 
771 	tctl = IXGB_TCTL_TCE | IXGB_TCTL_TXEN | IXGB_TCTL_TPDE;
772 	IXGB_WRITE_REG(hw, TCTL, tctl);
773 
774 	/* Setup Transmit Descriptor Settings for this adapter */
775 	adapter->tx_cmd_type =
776 		IXGB_TX_DESC_TYPE |
777 		(adapter->tx_int_delay_enable ? IXGB_TX_DESC_CMD_IDE : 0);
778 }
779 
780 /**
781  * ixgb_setup_rx_resources - allocate Rx resources (Descriptors)
782  * @adapter: board private structure
783  *
784  * Returns 0 on success, negative on failure
785  **/
786 
787 int
ixgb_setup_rx_resources(struct ixgb_adapter * adapter)788 ixgb_setup_rx_resources(struct ixgb_adapter *adapter)
789 {
790 	struct ixgb_desc_ring *rxdr = &adapter->rx_ring;
791 	struct pci_dev *pdev = adapter->pdev;
792 	int size;
793 
794 	size = sizeof(struct ixgb_buffer) * rxdr->count;
795 	rxdr->buffer_info = vzalloc(size);
796 	if (!rxdr->buffer_info)
797 		return -ENOMEM;
798 
799 	/* Round up to nearest 4K */
800 
801 	rxdr->size = rxdr->count * sizeof(struct ixgb_rx_desc);
802 	rxdr->size = ALIGN(rxdr->size, 4096);
803 
804 	rxdr->desc = dma_alloc_coherent(&pdev->dev, rxdr->size, &rxdr->dma,
805 					GFP_KERNEL);
806 
807 	if (!rxdr->desc) {
808 		vfree(rxdr->buffer_info);
809 		return -ENOMEM;
810 	}
811 	memset(rxdr->desc, 0, rxdr->size);
812 
813 	rxdr->next_to_clean = 0;
814 	rxdr->next_to_use = 0;
815 
816 	return 0;
817 }
818 
819 /**
820  * ixgb_setup_rctl - configure the receive control register
821  * @adapter: Board private structure
822  **/
823 
824 static void
ixgb_setup_rctl(struct ixgb_adapter * adapter)825 ixgb_setup_rctl(struct ixgb_adapter *adapter)
826 {
827 	u32 rctl;
828 
829 	rctl = IXGB_READ_REG(&adapter->hw, RCTL);
830 
831 	rctl &= ~(3 << IXGB_RCTL_MO_SHIFT);
832 
833 	rctl |=
834 		IXGB_RCTL_BAM | IXGB_RCTL_RDMTS_1_2 |
835 		IXGB_RCTL_RXEN | IXGB_RCTL_CFF |
836 		(adapter->hw.mc_filter_type << IXGB_RCTL_MO_SHIFT);
837 
838 	rctl |= IXGB_RCTL_SECRC;
839 
840 	if (adapter->rx_buffer_len <= IXGB_RXBUFFER_2048)
841 		rctl |= IXGB_RCTL_BSIZE_2048;
842 	else if (adapter->rx_buffer_len <= IXGB_RXBUFFER_4096)
843 		rctl |= IXGB_RCTL_BSIZE_4096;
844 	else if (adapter->rx_buffer_len <= IXGB_RXBUFFER_8192)
845 		rctl |= IXGB_RCTL_BSIZE_8192;
846 	else if (adapter->rx_buffer_len <= IXGB_RXBUFFER_16384)
847 		rctl |= IXGB_RCTL_BSIZE_16384;
848 
849 	IXGB_WRITE_REG(&adapter->hw, RCTL, rctl);
850 }
851 
852 /**
853  * ixgb_configure_rx - Configure 82597 Receive Unit after Reset.
854  * @adapter: board private structure
855  *
856  * Configure the Rx unit of the MAC after a reset.
857  **/
858 
859 static void
ixgb_configure_rx(struct ixgb_adapter * adapter)860 ixgb_configure_rx(struct ixgb_adapter *adapter)
861 {
862 	u64 rdba = adapter->rx_ring.dma;
863 	u32 rdlen = adapter->rx_ring.count * sizeof(struct ixgb_rx_desc);
864 	struct ixgb_hw *hw = &adapter->hw;
865 	u32 rctl;
866 	u32 rxcsum;
867 
868 	/* make sure receives are disabled while setting up the descriptors */
869 
870 	rctl = IXGB_READ_REG(hw, RCTL);
871 	IXGB_WRITE_REG(hw, RCTL, rctl & ~IXGB_RCTL_RXEN);
872 
873 	/* set the Receive Delay Timer Register */
874 
875 	IXGB_WRITE_REG(hw, RDTR, adapter->rx_int_delay);
876 
877 	/* Setup the Base and Length of the Rx Descriptor Ring */
878 
879 	IXGB_WRITE_REG(hw, RDBAL, (rdba & 0x00000000ffffffffULL));
880 	IXGB_WRITE_REG(hw, RDBAH, (rdba >> 32));
881 
882 	IXGB_WRITE_REG(hw, RDLEN, rdlen);
883 
884 	/* Setup the HW Rx Head and Tail Descriptor Pointers */
885 	IXGB_WRITE_REG(hw, RDH, 0);
886 	IXGB_WRITE_REG(hw, RDT, 0);
887 
888 	/* due to the hardware errata with RXDCTL, we are unable to use any of
889 	 * the performance enhancing features of it without causing other
890 	 * subtle bugs, some of the bugs could include receive length
891 	 * corruption at high data rates (WTHRESH > 0) and/or receive
892 	 * descriptor ring irregularites (particularly in hardware cache) */
893 	IXGB_WRITE_REG(hw, RXDCTL, 0);
894 
895 	/* Enable Receive Checksum Offload for TCP and UDP */
896 	if (adapter->rx_csum) {
897 		rxcsum = IXGB_READ_REG(hw, RXCSUM);
898 		rxcsum |= IXGB_RXCSUM_TUOFL;
899 		IXGB_WRITE_REG(hw, RXCSUM, rxcsum);
900 	}
901 
902 	/* Enable Receives */
903 
904 	IXGB_WRITE_REG(hw, RCTL, rctl);
905 }
906 
907 /**
908  * ixgb_free_tx_resources - Free Tx Resources
909  * @adapter: board private structure
910  *
911  * Free all transmit software resources
912  **/
913 
914 void
ixgb_free_tx_resources(struct ixgb_adapter * adapter)915 ixgb_free_tx_resources(struct ixgb_adapter *adapter)
916 {
917 	struct pci_dev *pdev = adapter->pdev;
918 
919 	ixgb_clean_tx_ring(adapter);
920 
921 	vfree(adapter->tx_ring.buffer_info);
922 	adapter->tx_ring.buffer_info = NULL;
923 
924 	dma_free_coherent(&pdev->dev, adapter->tx_ring.size,
925 			  adapter->tx_ring.desc, adapter->tx_ring.dma);
926 
927 	adapter->tx_ring.desc = NULL;
928 }
929 
930 static void
ixgb_unmap_and_free_tx_resource(struct ixgb_adapter * adapter,struct ixgb_buffer * buffer_info)931 ixgb_unmap_and_free_tx_resource(struct ixgb_adapter *adapter,
932                                 struct ixgb_buffer *buffer_info)
933 {
934 	if (buffer_info->dma) {
935 		if (buffer_info->mapped_as_page)
936 			dma_unmap_page(&adapter->pdev->dev, buffer_info->dma,
937 				       buffer_info->length, DMA_TO_DEVICE);
938 		else
939 			dma_unmap_single(&adapter->pdev->dev, buffer_info->dma,
940 					 buffer_info->length, DMA_TO_DEVICE);
941 		buffer_info->dma = 0;
942 	}
943 
944 	if (buffer_info->skb) {
945 		dev_kfree_skb_any(buffer_info->skb);
946 		buffer_info->skb = NULL;
947 	}
948 	buffer_info->time_stamp = 0;
949 	/* these fields must always be initialized in tx
950 	 * buffer_info->length = 0;
951 	 * buffer_info->next_to_watch = 0; */
952 }
953 
954 /**
955  * ixgb_clean_tx_ring - Free Tx Buffers
956  * @adapter: board private structure
957  **/
958 
959 static void
ixgb_clean_tx_ring(struct ixgb_adapter * adapter)960 ixgb_clean_tx_ring(struct ixgb_adapter *adapter)
961 {
962 	struct ixgb_desc_ring *tx_ring = &adapter->tx_ring;
963 	struct ixgb_buffer *buffer_info;
964 	unsigned long size;
965 	unsigned int i;
966 
967 	/* Free all the Tx ring sk_buffs */
968 
969 	for (i = 0; i < tx_ring->count; i++) {
970 		buffer_info = &tx_ring->buffer_info[i];
971 		ixgb_unmap_and_free_tx_resource(adapter, buffer_info);
972 	}
973 
974 	size = sizeof(struct ixgb_buffer) * tx_ring->count;
975 	memset(tx_ring->buffer_info, 0, size);
976 
977 	/* Zero out the descriptor ring */
978 
979 	memset(tx_ring->desc, 0, tx_ring->size);
980 
981 	tx_ring->next_to_use = 0;
982 	tx_ring->next_to_clean = 0;
983 
984 	IXGB_WRITE_REG(&adapter->hw, TDH, 0);
985 	IXGB_WRITE_REG(&adapter->hw, TDT, 0);
986 }
987 
988 /**
989  * ixgb_free_rx_resources - Free Rx Resources
990  * @adapter: board private structure
991  *
992  * Free all receive software resources
993  **/
994 
995 void
ixgb_free_rx_resources(struct ixgb_adapter * adapter)996 ixgb_free_rx_resources(struct ixgb_adapter *adapter)
997 {
998 	struct ixgb_desc_ring *rx_ring = &adapter->rx_ring;
999 	struct pci_dev *pdev = adapter->pdev;
1000 
1001 	ixgb_clean_rx_ring(adapter);
1002 
1003 	vfree(rx_ring->buffer_info);
1004 	rx_ring->buffer_info = NULL;
1005 
1006 	dma_free_coherent(&pdev->dev, rx_ring->size, rx_ring->desc,
1007 			  rx_ring->dma);
1008 
1009 	rx_ring->desc = NULL;
1010 }
1011 
1012 /**
1013  * ixgb_clean_rx_ring - Free Rx Buffers
1014  * @adapter: board private structure
1015  **/
1016 
1017 static void
ixgb_clean_rx_ring(struct ixgb_adapter * adapter)1018 ixgb_clean_rx_ring(struct ixgb_adapter *adapter)
1019 {
1020 	struct ixgb_desc_ring *rx_ring = &adapter->rx_ring;
1021 	struct ixgb_buffer *buffer_info;
1022 	struct pci_dev *pdev = adapter->pdev;
1023 	unsigned long size;
1024 	unsigned int i;
1025 
1026 	/* Free all the Rx ring sk_buffs */
1027 
1028 	for (i = 0; i < rx_ring->count; i++) {
1029 		buffer_info = &rx_ring->buffer_info[i];
1030 		if (buffer_info->dma) {
1031 			dma_unmap_single(&pdev->dev,
1032 					 buffer_info->dma,
1033 					 buffer_info->length,
1034 					 DMA_FROM_DEVICE);
1035 			buffer_info->dma = 0;
1036 			buffer_info->length = 0;
1037 		}
1038 
1039 		if (buffer_info->skb) {
1040 			dev_kfree_skb(buffer_info->skb);
1041 			buffer_info->skb = NULL;
1042 		}
1043 	}
1044 
1045 	size = sizeof(struct ixgb_buffer) * rx_ring->count;
1046 	memset(rx_ring->buffer_info, 0, size);
1047 
1048 	/* Zero out the descriptor ring */
1049 
1050 	memset(rx_ring->desc, 0, rx_ring->size);
1051 
1052 	rx_ring->next_to_clean = 0;
1053 	rx_ring->next_to_use = 0;
1054 
1055 	IXGB_WRITE_REG(&adapter->hw, RDH, 0);
1056 	IXGB_WRITE_REG(&adapter->hw, RDT, 0);
1057 }
1058 
1059 /**
1060  * ixgb_set_mac - Change the Ethernet Address of the NIC
1061  * @netdev: network interface device structure
1062  * @p: pointer to an address structure
1063  *
1064  * Returns 0 on success, negative on failure
1065  **/
1066 
1067 static int
ixgb_set_mac(struct net_device * netdev,void * p)1068 ixgb_set_mac(struct net_device *netdev, void *p)
1069 {
1070 	struct ixgb_adapter *adapter = netdev_priv(netdev);
1071 	struct sockaddr *addr = p;
1072 
1073 	if (!is_valid_ether_addr(addr->sa_data))
1074 		return -EADDRNOTAVAIL;
1075 
1076 	memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
1077 
1078 	ixgb_rar_set(&adapter->hw, addr->sa_data, 0);
1079 
1080 	return 0;
1081 }
1082 
1083 /**
1084  * ixgb_set_multi - Multicast and Promiscuous mode set
1085  * @netdev: network interface device structure
1086  *
1087  * The set_multi entry point is called whenever the multicast address
1088  * list or the network interface flags are updated.  This routine is
1089  * responsible for configuring the hardware for proper multicast,
1090  * promiscuous mode, and all-multi behavior.
1091  **/
1092 
1093 static void
ixgb_set_multi(struct net_device * netdev)1094 ixgb_set_multi(struct net_device *netdev)
1095 {
1096 	struct ixgb_adapter *adapter = netdev_priv(netdev);
1097 	struct ixgb_hw *hw = &adapter->hw;
1098 	struct netdev_hw_addr *ha;
1099 	u32 rctl;
1100 
1101 	/* Check for Promiscuous and All Multicast modes */
1102 
1103 	rctl = IXGB_READ_REG(hw, RCTL);
1104 
1105 	if (netdev->flags & IFF_PROMISC) {
1106 		rctl |= (IXGB_RCTL_UPE | IXGB_RCTL_MPE);
1107 		/* disable VLAN filtering */
1108 		rctl &= ~IXGB_RCTL_CFIEN;
1109 		rctl &= ~IXGB_RCTL_VFE;
1110 	} else {
1111 		if (netdev->flags & IFF_ALLMULTI) {
1112 			rctl |= IXGB_RCTL_MPE;
1113 			rctl &= ~IXGB_RCTL_UPE;
1114 		} else {
1115 			rctl &= ~(IXGB_RCTL_UPE | IXGB_RCTL_MPE);
1116 		}
1117 		/* enable VLAN filtering */
1118 		rctl |= IXGB_RCTL_VFE;
1119 		rctl &= ~IXGB_RCTL_CFIEN;
1120 	}
1121 
1122 	if (netdev_mc_count(netdev) > IXGB_MAX_NUM_MULTICAST_ADDRESSES) {
1123 		rctl |= IXGB_RCTL_MPE;
1124 		IXGB_WRITE_REG(hw, RCTL, rctl);
1125 	} else {
1126 		u8 *mta = kmalloc(IXGB_MAX_NUM_MULTICAST_ADDRESSES *
1127 			      ETH_ALEN, GFP_ATOMIC);
1128 		u8 *addr;
1129 		if (!mta)
1130 			goto alloc_failed;
1131 
1132 		IXGB_WRITE_REG(hw, RCTL, rctl);
1133 
1134 		addr = mta;
1135 		netdev_for_each_mc_addr(ha, netdev) {
1136 			memcpy(addr, ha->addr, ETH_ALEN);
1137 			addr += ETH_ALEN;
1138 		}
1139 
1140 		ixgb_mc_addr_list_update(hw, mta, netdev_mc_count(netdev), 0);
1141 		kfree(mta);
1142 	}
1143 
1144 alloc_failed:
1145 	if (netdev->features & NETIF_F_HW_VLAN_CTAG_RX)
1146 		ixgb_vlan_strip_enable(adapter);
1147 	else
1148 		ixgb_vlan_strip_disable(adapter);
1149 
1150 }
1151 
1152 /**
1153  * ixgb_watchdog - Timer Call-back
1154  * @data: pointer to netdev cast into an unsigned long
1155  **/
1156 
1157 static void
ixgb_watchdog(unsigned long data)1158 ixgb_watchdog(unsigned long data)
1159 {
1160 	struct ixgb_adapter *adapter = (struct ixgb_adapter *)data;
1161 	struct net_device *netdev = adapter->netdev;
1162 	struct ixgb_desc_ring *txdr = &adapter->tx_ring;
1163 
1164 	ixgb_check_for_link(&adapter->hw);
1165 
1166 	if (ixgb_check_for_bad_link(&adapter->hw)) {
1167 		/* force the reset path */
1168 		netif_stop_queue(netdev);
1169 	}
1170 
1171 	if (adapter->hw.link_up) {
1172 		if (!netif_carrier_ok(netdev)) {
1173 			netdev_info(netdev,
1174 				    "NIC Link is Up 10 Gbps Full Duplex, Flow Control: %s\n",
1175 				    (adapter->hw.fc.type == ixgb_fc_full) ?
1176 				    "RX/TX" :
1177 				    (adapter->hw.fc.type == ixgb_fc_rx_pause) ?
1178 				     "RX" :
1179 				    (adapter->hw.fc.type == ixgb_fc_tx_pause) ?
1180 				    "TX" : "None");
1181 			adapter->link_speed = 10000;
1182 			adapter->link_duplex = FULL_DUPLEX;
1183 			netif_carrier_on(netdev);
1184 		}
1185 	} else {
1186 		if (netif_carrier_ok(netdev)) {
1187 			adapter->link_speed = 0;
1188 			adapter->link_duplex = 0;
1189 			netdev_info(netdev, "NIC Link is Down\n");
1190 			netif_carrier_off(netdev);
1191 		}
1192 	}
1193 
1194 	ixgb_update_stats(adapter);
1195 
1196 	if (!netif_carrier_ok(netdev)) {
1197 		if (IXGB_DESC_UNUSED(txdr) + 1 < txdr->count) {
1198 			/* We've lost link, so the controller stops DMA,
1199 			 * but we've got queued Tx work that's never going
1200 			 * to get done, so reset controller to flush Tx.
1201 			 * (Do the reset outside of interrupt context). */
1202 			schedule_work(&adapter->tx_timeout_task);
1203 			/* return immediately since reset is imminent */
1204 			return;
1205 		}
1206 	}
1207 
1208 	/* Force detection of hung controller every watchdog period */
1209 	adapter->detect_tx_hung = true;
1210 
1211 	/* generate an interrupt to force clean up of any stragglers */
1212 	IXGB_WRITE_REG(&adapter->hw, ICS, IXGB_INT_TXDW);
1213 
1214 	/* Reset the timer */
1215 	mod_timer(&adapter->watchdog_timer, jiffies + 2 * HZ);
1216 }
1217 
1218 #define IXGB_TX_FLAGS_CSUM		0x00000001
1219 #define IXGB_TX_FLAGS_VLAN		0x00000002
1220 #define IXGB_TX_FLAGS_TSO		0x00000004
1221 
1222 static int
ixgb_tso(struct ixgb_adapter * adapter,struct sk_buff * skb)1223 ixgb_tso(struct ixgb_adapter *adapter, struct sk_buff *skb)
1224 {
1225 	struct ixgb_context_desc *context_desc;
1226 	unsigned int i;
1227 	u8 ipcss, ipcso, tucss, tucso, hdr_len;
1228 	u16 ipcse, tucse, mss;
1229 	int err;
1230 
1231 	if (likely(skb_is_gso(skb))) {
1232 		struct ixgb_buffer *buffer_info;
1233 		struct iphdr *iph;
1234 
1235 		if (skb_header_cloned(skb)) {
1236 			err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
1237 			if (err)
1238 				return err;
1239 		}
1240 
1241 		hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
1242 		mss = skb_shinfo(skb)->gso_size;
1243 		iph = ip_hdr(skb);
1244 		iph->tot_len = 0;
1245 		iph->check = 0;
1246 		tcp_hdr(skb)->check = ~csum_tcpudp_magic(iph->saddr,
1247 							 iph->daddr, 0,
1248 							 IPPROTO_TCP, 0);
1249 		ipcss = skb_network_offset(skb);
1250 		ipcso = (void *)&(iph->check) - (void *)skb->data;
1251 		ipcse = skb_transport_offset(skb) - 1;
1252 		tucss = skb_transport_offset(skb);
1253 		tucso = (void *)&(tcp_hdr(skb)->check) - (void *)skb->data;
1254 		tucse = 0;
1255 
1256 		i = adapter->tx_ring.next_to_use;
1257 		context_desc = IXGB_CONTEXT_DESC(adapter->tx_ring, i);
1258 		buffer_info = &adapter->tx_ring.buffer_info[i];
1259 		WARN_ON(buffer_info->dma != 0);
1260 
1261 		context_desc->ipcss = ipcss;
1262 		context_desc->ipcso = ipcso;
1263 		context_desc->ipcse = cpu_to_le16(ipcse);
1264 		context_desc->tucss = tucss;
1265 		context_desc->tucso = tucso;
1266 		context_desc->tucse = cpu_to_le16(tucse);
1267 		context_desc->mss = cpu_to_le16(mss);
1268 		context_desc->hdr_len = hdr_len;
1269 		context_desc->status = 0;
1270 		context_desc->cmd_type_len = cpu_to_le32(
1271 						  IXGB_CONTEXT_DESC_TYPE
1272 						| IXGB_CONTEXT_DESC_CMD_TSE
1273 						| IXGB_CONTEXT_DESC_CMD_IP
1274 						| IXGB_CONTEXT_DESC_CMD_TCP
1275 						| IXGB_CONTEXT_DESC_CMD_IDE
1276 						| (skb->len - (hdr_len)));
1277 
1278 
1279 		if (++i == adapter->tx_ring.count) i = 0;
1280 		adapter->tx_ring.next_to_use = i;
1281 
1282 		return 1;
1283 	}
1284 
1285 	return 0;
1286 }
1287 
1288 static bool
ixgb_tx_csum(struct ixgb_adapter * adapter,struct sk_buff * skb)1289 ixgb_tx_csum(struct ixgb_adapter *adapter, struct sk_buff *skb)
1290 {
1291 	struct ixgb_context_desc *context_desc;
1292 	unsigned int i;
1293 	u8 css, cso;
1294 
1295 	if (likely(skb->ip_summed == CHECKSUM_PARTIAL)) {
1296 		struct ixgb_buffer *buffer_info;
1297 		css = skb_checksum_start_offset(skb);
1298 		cso = css + skb->csum_offset;
1299 
1300 		i = adapter->tx_ring.next_to_use;
1301 		context_desc = IXGB_CONTEXT_DESC(adapter->tx_ring, i);
1302 		buffer_info = &adapter->tx_ring.buffer_info[i];
1303 		WARN_ON(buffer_info->dma != 0);
1304 
1305 		context_desc->tucss = css;
1306 		context_desc->tucso = cso;
1307 		context_desc->tucse = 0;
1308 		/* zero out any previously existing data in one instruction */
1309 		*(u32 *)&(context_desc->ipcss) = 0;
1310 		context_desc->status = 0;
1311 		context_desc->hdr_len = 0;
1312 		context_desc->mss = 0;
1313 		context_desc->cmd_type_len =
1314 			cpu_to_le32(IXGB_CONTEXT_DESC_TYPE
1315 				    | IXGB_TX_DESC_CMD_IDE);
1316 
1317 		if (++i == adapter->tx_ring.count) i = 0;
1318 		adapter->tx_ring.next_to_use = i;
1319 
1320 		return true;
1321 	}
1322 
1323 	return false;
1324 }
1325 
1326 #define IXGB_MAX_TXD_PWR	14
1327 #define IXGB_MAX_DATA_PER_TXD	(1<<IXGB_MAX_TXD_PWR)
1328 
1329 static int
ixgb_tx_map(struct ixgb_adapter * adapter,struct sk_buff * skb,unsigned int first)1330 ixgb_tx_map(struct ixgb_adapter *adapter, struct sk_buff *skb,
1331 	    unsigned int first)
1332 {
1333 	struct ixgb_desc_ring *tx_ring = &adapter->tx_ring;
1334 	struct pci_dev *pdev = adapter->pdev;
1335 	struct ixgb_buffer *buffer_info;
1336 	int len = skb_headlen(skb);
1337 	unsigned int offset = 0, size, count = 0, i;
1338 	unsigned int mss = skb_shinfo(skb)->gso_size;
1339 	unsigned int nr_frags = skb_shinfo(skb)->nr_frags;
1340 	unsigned int f;
1341 
1342 	i = tx_ring->next_to_use;
1343 
1344 	while (len) {
1345 		buffer_info = &tx_ring->buffer_info[i];
1346 		size = min(len, IXGB_MAX_DATA_PER_TXD);
1347 		/* Workaround for premature desc write-backs
1348 		 * in TSO mode.  Append 4-byte sentinel desc */
1349 		if (unlikely(mss && !nr_frags && size == len && size > 8))
1350 			size -= 4;
1351 
1352 		buffer_info->length = size;
1353 		WARN_ON(buffer_info->dma != 0);
1354 		buffer_info->time_stamp = jiffies;
1355 		buffer_info->mapped_as_page = false;
1356 		buffer_info->dma = dma_map_single(&pdev->dev,
1357 						  skb->data + offset,
1358 						  size, DMA_TO_DEVICE);
1359 		if (dma_mapping_error(&pdev->dev, buffer_info->dma))
1360 			goto dma_error;
1361 		buffer_info->next_to_watch = 0;
1362 
1363 		len -= size;
1364 		offset += size;
1365 		count++;
1366 		if (len) {
1367 			i++;
1368 			if (i == tx_ring->count)
1369 				i = 0;
1370 		}
1371 	}
1372 
1373 	for (f = 0; f < nr_frags; f++) {
1374 		const struct skb_frag_struct *frag;
1375 
1376 		frag = &skb_shinfo(skb)->frags[f];
1377 		len = skb_frag_size(frag);
1378 		offset = 0;
1379 
1380 		while (len) {
1381 			i++;
1382 			if (i == tx_ring->count)
1383 				i = 0;
1384 
1385 			buffer_info = &tx_ring->buffer_info[i];
1386 			size = min(len, IXGB_MAX_DATA_PER_TXD);
1387 
1388 			/* Workaround for premature desc write-backs
1389 			 * in TSO mode.  Append 4-byte sentinel desc */
1390 			if (unlikely(mss && (f == (nr_frags - 1))
1391 				     && size == len && size > 8))
1392 				size -= 4;
1393 
1394 			buffer_info->length = size;
1395 			buffer_info->time_stamp = jiffies;
1396 			buffer_info->mapped_as_page = true;
1397 			buffer_info->dma =
1398 				skb_frag_dma_map(&pdev->dev, frag, offset, size,
1399 						 DMA_TO_DEVICE);
1400 			if (dma_mapping_error(&pdev->dev, buffer_info->dma))
1401 				goto dma_error;
1402 			buffer_info->next_to_watch = 0;
1403 
1404 			len -= size;
1405 			offset += size;
1406 			count++;
1407 		}
1408 	}
1409 	tx_ring->buffer_info[i].skb = skb;
1410 	tx_ring->buffer_info[first].next_to_watch = i;
1411 
1412 	return count;
1413 
1414 dma_error:
1415 	dev_err(&pdev->dev, "TX DMA map failed\n");
1416 	buffer_info->dma = 0;
1417 	if (count)
1418 		count--;
1419 
1420 	while (count--) {
1421 		if (i==0)
1422 			i += tx_ring->count;
1423 		i--;
1424 		buffer_info = &tx_ring->buffer_info[i];
1425 		ixgb_unmap_and_free_tx_resource(adapter, buffer_info);
1426 	}
1427 
1428 	return 0;
1429 }
1430 
1431 static void
ixgb_tx_queue(struct ixgb_adapter * adapter,int count,int vlan_id,int tx_flags)1432 ixgb_tx_queue(struct ixgb_adapter *adapter, int count, int vlan_id,int tx_flags)
1433 {
1434 	struct ixgb_desc_ring *tx_ring = &adapter->tx_ring;
1435 	struct ixgb_tx_desc *tx_desc = NULL;
1436 	struct ixgb_buffer *buffer_info;
1437 	u32 cmd_type_len = adapter->tx_cmd_type;
1438 	u8 status = 0;
1439 	u8 popts = 0;
1440 	unsigned int i;
1441 
1442 	if (tx_flags & IXGB_TX_FLAGS_TSO) {
1443 		cmd_type_len |= IXGB_TX_DESC_CMD_TSE;
1444 		popts |= (IXGB_TX_DESC_POPTS_IXSM | IXGB_TX_DESC_POPTS_TXSM);
1445 	}
1446 
1447 	if (tx_flags & IXGB_TX_FLAGS_CSUM)
1448 		popts |= IXGB_TX_DESC_POPTS_TXSM;
1449 
1450 	if (tx_flags & IXGB_TX_FLAGS_VLAN)
1451 		cmd_type_len |= IXGB_TX_DESC_CMD_VLE;
1452 
1453 	i = tx_ring->next_to_use;
1454 
1455 	while (count--) {
1456 		buffer_info = &tx_ring->buffer_info[i];
1457 		tx_desc = IXGB_TX_DESC(*tx_ring, i);
1458 		tx_desc->buff_addr = cpu_to_le64(buffer_info->dma);
1459 		tx_desc->cmd_type_len =
1460 			cpu_to_le32(cmd_type_len | buffer_info->length);
1461 		tx_desc->status = status;
1462 		tx_desc->popts = popts;
1463 		tx_desc->vlan = cpu_to_le16(vlan_id);
1464 
1465 		if (++i == tx_ring->count) i = 0;
1466 	}
1467 
1468 	tx_desc->cmd_type_len |=
1469 		cpu_to_le32(IXGB_TX_DESC_CMD_EOP | IXGB_TX_DESC_CMD_RS);
1470 
1471 	/* Force memory writes to complete before letting h/w
1472 	 * know there are new descriptors to fetch.  (Only
1473 	 * applicable for weak-ordered memory model archs,
1474 	 * such as IA-64). */
1475 	wmb();
1476 
1477 	tx_ring->next_to_use = i;
1478 	IXGB_WRITE_REG(&adapter->hw, TDT, i);
1479 }
1480 
__ixgb_maybe_stop_tx(struct net_device * netdev,int size)1481 static int __ixgb_maybe_stop_tx(struct net_device *netdev, int size)
1482 {
1483 	struct ixgb_adapter *adapter = netdev_priv(netdev);
1484 	struct ixgb_desc_ring *tx_ring = &adapter->tx_ring;
1485 
1486 	netif_stop_queue(netdev);
1487 	/* Herbert's original patch had:
1488 	 *  smp_mb__after_netif_stop_queue();
1489 	 * but since that doesn't exist yet, just open code it. */
1490 	smp_mb();
1491 
1492 	/* We need to check again in a case another CPU has just
1493 	 * made room available. */
1494 	if (likely(IXGB_DESC_UNUSED(tx_ring) < size))
1495 		return -EBUSY;
1496 
1497 	/* A reprieve! */
1498 	netif_start_queue(netdev);
1499 	++adapter->restart_queue;
1500 	return 0;
1501 }
1502 
ixgb_maybe_stop_tx(struct net_device * netdev,struct ixgb_desc_ring * tx_ring,int size)1503 static int ixgb_maybe_stop_tx(struct net_device *netdev,
1504                               struct ixgb_desc_ring *tx_ring, int size)
1505 {
1506 	if (likely(IXGB_DESC_UNUSED(tx_ring) >= size))
1507 		return 0;
1508 	return __ixgb_maybe_stop_tx(netdev, size);
1509 }
1510 
1511 
1512 /* Tx Descriptors needed, worst case */
1513 #define TXD_USE_COUNT(S) (((S) >> IXGB_MAX_TXD_PWR) + \
1514 			 (((S) & (IXGB_MAX_DATA_PER_TXD - 1)) ? 1 : 0))
1515 #define DESC_NEEDED TXD_USE_COUNT(IXGB_MAX_DATA_PER_TXD) /* skb->date */ + \
1516 	MAX_SKB_FRAGS * TXD_USE_COUNT(PAGE_SIZE) + 1 /* for context */ \
1517 	+ 1 /* one more needed for sentinel TSO workaround */
1518 
1519 static netdev_tx_t
ixgb_xmit_frame(struct sk_buff * skb,struct net_device * netdev)1520 ixgb_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
1521 {
1522 	struct ixgb_adapter *adapter = netdev_priv(netdev);
1523 	unsigned int first;
1524 	unsigned int tx_flags = 0;
1525 	int vlan_id = 0;
1526 	int count = 0;
1527 	int tso;
1528 
1529 	if (test_bit(__IXGB_DOWN, &adapter->flags)) {
1530 		dev_kfree_skb(skb);
1531 		return NETDEV_TX_OK;
1532 	}
1533 
1534 	if (skb->len <= 0) {
1535 		dev_kfree_skb(skb);
1536 		return NETDEV_TX_OK;
1537 	}
1538 
1539 	if (unlikely(ixgb_maybe_stop_tx(netdev, &adapter->tx_ring,
1540                      DESC_NEEDED)))
1541 		return NETDEV_TX_BUSY;
1542 
1543 	if (vlan_tx_tag_present(skb)) {
1544 		tx_flags |= IXGB_TX_FLAGS_VLAN;
1545 		vlan_id = vlan_tx_tag_get(skb);
1546 	}
1547 
1548 	first = adapter->tx_ring.next_to_use;
1549 
1550 	tso = ixgb_tso(adapter, skb);
1551 	if (tso < 0) {
1552 		dev_kfree_skb(skb);
1553 		return NETDEV_TX_OK;
1554 	}
1555 
1556 	if (likely(tso))
1557 		tx_flags |= IXGB_TX_FLAGS_TSO;
1558 	else if (ixgb_tx_csum(adapter, skb))
1559 		tx_flags |= IXGB_TX_FLAGS_CSUM;
1560 
1561 	count = ixgb_tx_map(adapter, skb, first);
1562 
1563 	if (count) {
1564 		ixgb_tx_queue(adapter, count, vlan_id, tx_flags);
1565 		/* Make sure there is space in the ring for the next send. */
1566 		ixgb_maybe_stop_tx(netdev, &adapter->tx_ring, DESC_NEEDED);
1567 
1568 	} else {
1569 		dev_kfree_skb_any(skb);
1570 		adapter->tx_ring.buffer_info[first].time_stamp = 0;
1571 		adapter->tx_ring.next_to_use = first;
1572 	}
1573 
1574 	return NETDEV_TX_OK;
1575 }
1576 
1577 /**
1578  * ixgb_tx_timeout - Respond to a Tx Hang
1579  * @netdev: network interface device structure
1580  **/
1581 
1582 static void
ixgb_tx_timeout(struct net_device * netdev)1583 ixgb_tx_timeout(struct net_device *netdev)
1584 {
1585 	struct ixgb_adapter *adapter = netdev_priv(netdev);
1586 
1587 	/* Do the reset outside of interrupt context */
1588 	schedule_work(&adapter->tx_timeout_task);
1589 }
1590 
1591 static void
ixgb_tx_timeout_task(struct work_struct * work)1592 ixgb_tx_timeout_task(struct work_struct *work)
1593 {
1594 	struct ixgb_adapter *adapter =
1595 		container_of(work, struct ixgb_adapter, tx_timeout_task);
1596 
1597 	adapter->tx_timeout_count++;
1598 	ixgb_down(adapter, true);
1599 	ixgb_up(adapter);
1600 }
1601 
1602 /**
1603  * ixgb_get_stats - Get System Network Statistics
1604  * @netdev: network interface device structure
1605  *
1606  * Returns the address of the device statistics structure.
1607  * The statistics are actually updated from the timer callback.
1608  **/
1609 
1610 static struct net_device_stats *
ixgb_get_stats(struct net_device * netdev)1611 ixgb_get_stats(struct net_device *netdev)
1612 {
1613 	return &netdev->stats;
1614 }
1615 
1616 /**
1617  * ixgb_change_mtu - Change the Maximum Transfer Unit
1618  * @netdev: network interface device structure
1619  * @new_mtu: new value for maximum frame size
1620  *
1621  * Returns 0 on success, negative on failure
1622  **/
1623 
1624 static int
ixgb_change_mtu(struct net_device * netdev,int new_mtu)1625 ixgb_change_mtu(struct net_device *netdev, int new_mtu)
1626 {
1627 	struct ixgb_adapter *adapter = netdev_priv(netdev);
1628 	int max_frame = new_mtu + ENET_HEADER_SIZE + ENET_FCS_LENGTH;
1629 	int old_max_frame = netdev->mtu + ENET_HEADER_SIZE + ENET_FCS_LENGTH;
1630 
1631 	/* MTU < 68 is an error for IPv4 traffic, just don't allow it */
1632 	if ((new_mtu < 68) ||
1633 	    (max_frame > IXGB_MAX_JUMBO_FRAME_SIZE + ENET_FCS_LENGTH)) {
1634 		netif_err(adapter, probe, adapter->netdev,
1635 			  "Invalid MTU setting %d\n", new_mtu);
1636 		return -EINVAL;
1637 	}
1638 
1639 	if (old_max_frame == max_frame)
1640 		return 0;
1641 
1642 	if (netif_running(netdev))
1643 		ixgb_down(adapter, true);
1644 
1645 	adapter->rx_buffer_len = max_frame + 8; /* + 8 for errata */
1646 
1647 	netdev->mtu = new_mtu;
1648 
1649 	if (netif_running(netdev))
1650 		ixgb_up(adapter);
1651 
1652 	return 0;
1653 }
1654 
1655 /**
1656  * ixgb_update_stats - Update the board statistics counters.
1657  * @adapter: board private structure
1658  **/
1659 
1660 void
ixgb_update_stats(struct ixgb_adapter * adapter)1661 ixgb_update_stats(struct ixgb_adapter *adapter)
1662 {
1663 	struct net_device *netdev = adapter->netdev;
1664 	struct pci_dev *pdev = adapter->pdev;
1665 
1666 	/* Prevent stats update while adapter is being reset */
1667 	if (pci_channel_offline(pdev))
1668 		return;
1669 
1670 	if ((netdev->flags & IFF_PROMISC) || (netdev->flags & IFF_ALLMULTI) ||
1671 	   (netdev_mc_count(netdev) > IXGB_MAX_NUM_MULTICAST_ADDRESSES)) {
1672 		u64 multi = IXGB_READ_REG(&adapter->hw, MPRCL);
1673 		u32 bcast_l = IXGB_READ_REG(&adapter->hw, BPRCL);
1674 		u32 bcast_h = IXGB_READ_REG(&adapter->hw, BPRCH);
1675 		u64 bcast = ((u64)bcast_h << 32) | bcast_l;
1676 
1677 		multi |= ((u64)IXGB_READ_REG(&adapter->hw, MPRCH) << 32);
1678 		/* fix up multicast stats by removing broadcasts */
1679 		if (multi >= bcast)
1680 			multi -= bcast;
1681 
1682 		adapter->stats.mprcl += (multi & 0xFFFFFFFF);
1683 		adapter->stats.mprch += (multi >> 32);
1684 		adapter->stats.bprcl += bcast_l;
1685 		adapter->stats.bprch += bcast_h;
1686 	} else {
1687 		adapter->stats.mprcl += IXGB_READ_REG(&adapter->hw, MPRCL);
1688 		adapter->stats.mprch += IXGB_READ_REG(&adapter->hw, MPRCH);
1689 		adapter->stats.bprcl += IXGB_READ_REG(&adapter->hw, BPRCL);
1690 		adapter->stats.bprch += IXGB_READ_REG(&adapter->hw, BPRCH);
1691 	}
1692 	adapter->stats.tprl += IXGB_READ_REG(&adapter->hw, TPRL);
1693 	adapter->stats.tprh += IXGB_READ_REG(&adapter->hw, TPRH);
1694 	adapter->stats.gprcl += IXGB_READ_REG(&adapter->hw, GPRCL);
1695 	adapter->stats.gprch += IXGB_READ_REG(&adapter->hw, GPRCH);
1696 	adapter->stats.uprcl += IXGB_READ_REG(&adapter->hw, UPRCL);
1697 	adapter->stats.uprch += IXGB_READ_REG(&adapter->hw, UPRCH);
1698 	adapter->stats.vprcl += IXGB_READ_REG(&adapter->hw, VPRCL);
1699 	adapter->stats.vprch += IXGB_READ_REG(&adapter->hw, VPRCH);
1700 	adapter->stats.jprcl += IXGB_READ_REG(&adapter->hw, JPRCL);
1701 	adapter->stats.jprch += IXGB_READ_REG(&adapter->hw, JPRCH);
1702 	adapter->stats.gorcl += IXGB_READ_REG(&adapter->hw, GORCL);
1703 	adapter->stats.gorch += IXGB_READ_REG(&adapter->hw, GORCH);
1704 	adapter->stats.torl += IXGB_READ_REG(&adapter->hw, TORL);
1705 	adapter->stats.torh += IXGB_READ_REG(&adapter->hw, TORH);
1706 	adapter->stats.rnbc += IXGB_READ_REG(&adapter->hw, RNBC);
1707 	adapter->stats.ruc += IXGB_READ_REG(&adapter->hw, RUC);
1708 	adapter->stats.roc += IXGB_READ_REG(&adapter->hw, ROC);
1709 	adapter->stats.rlec += IXGB_READ_REG(&adapter->hw, RLEC);
1710 	adapter->stats.crcerrs += IXGB_READ_REG(&adapter->hw, CRCERRS);
1711 	adapter->stats.icbc += IXGB_READ_REG(&adapter->hw, ICBC);
1712 	adapter->stats.ecbc += IXGB_READ_REG(&adapter->hw, ECBC);
1713 	adapter->stats.mpc += IXGB_READ_REG(&adapter->hw, MPC);
1714 	adapter->stats.tptl += IXGB_READ_REG(&adapter->hw, TPTL);
1715 	adapter->stats.tpth += IXGB_READ_REG(&adapter->hw, TPTH);
1716 	adapter->stats.gptcl += IXGB_READ_REG(&adapter->hw, GPTCL);
1717 	adapter->stats.gptch += IXGB_READ_REG(&adapter->hw, GPTCH);
1718 	adapter->stats.bptcl += IXGB_READ_REG(&adapter->hw, BPTCL);
1719 	adapter->stats.bptch += IXGB_READ_REG(&adapter->hw, BPTCH);
1720 	adapter->stats.mptcl += IXGB_READ_REG(&adapter->hw, MPTCL);
1721 	adapter->stats.mptch += IXGB_READ_REG(&adapter->hw, MPTCH);
1722 	adapter->stats.uptcl += IXGB_READ_REG(&adapter->hw, UPTCL);
1723 	adapter->stats.uptch += IXGB_READ_REG(&adapter->hw, UPTCH);
1724 	adapter->stats.vptcl += IXGB_READ_REG(&adapter->hw, VPTCL);
1725 	adapter->stats.vptch += IXGB_READ_REG(&adapter->hw, VPTCH);
1726 	adapter->stats.jptcl += IXGB_READ_REG(&adapter->hw, JPTCL);
1727 	adapter->stats.jptch += IXGB_READ_REG(&adapter->hw, JPTCH);
1728 	adapter->stats.gotcl += IXGB_READ_REG(&adapter->hw, GOTCL);
1729 	adapter->stats.gotch += IXGB_READ_REG(&adapter->hw, GOTCH);
1730 	adapter->stats.totl += IXGB_READ_REG(&adapter->hw, TOTL);
1731 	adapter->stats.toth += IXGB_READ_REG(&adapter->hw, TOTH);
1732 	adapter->stats.dc += IXGB_READ_REG(&adapter->hw, DC);
1733 	adapter->stats.plt64c += IXGB_READ_REG(&adapter->hw, PLT64C);
1734 	adapter->stats.tsctc += IXGB_READ_REG(&adapter->hw, TSCTC);
1735 	adapter->stats.tsctfc += IXGB_READ_REG(&adapter->hw, TSCTFC);
1736 	adapter->stats.ibic += IXGB_READ_REG(&adapter->hw, IBIC);
1737 	adapter->stats.rfc += IXGB_READ_REG(&adapter->hw, RFC);
1738 	adapter->stats.lfc += IXGB_READ_REG(&adapter->hw, LFC);
1739 	adapter->stats.pfrc += IXGB_READ_REG(&adapter->hw, PFRC);
1740 	adapter->stats.pftc += IXGB_READ_REG(&adapter->hw, PFTC);
1741 	adapter->stats.mcfrc += IXGB_READ_REG(&adapter->hw, MCFRC);
1742 	adapter->stats.mcftc += IXGB_READ_REG(&adapter->hw, MCFTC);
1743 	adapter->stats.xonrxc += IXGB_READ_REG(&adapter->hw, XONRXC);
1744 	adapter->stats.xontxc += IXGB_READ_REG(&adapter->hw, XONTXC);
1745 	adapter->stats.xoffrxc += IXGB_READ_REG(&adapter->hw, XOFFRXC);
1746 	adapter->stats.xofftxc += IXGB_READ_REG(&adapter->hw, XOFFTXC);
1747 	adapter->stats.rjc += IXGB_READ_REG(&adapter->hw, RJC);
1748 
1749 	/* Fill out the OS statistics structure */
1750 
1751 	netdev->stats.rx_packets = adapter->stats.gprcl;
1752 	netdev->stats.tx_packets = adapter->stats.gptcl;
1753 	netdev->stats.rx_bytes = adapter->stats.gorcl;
1754 	netdev->stats.tx_bytes = adapter->stats.gotcl;
1755 	netdev->stats.multicast = adapter->stats.mprcl;
1756 	netdev->stats.collisions = 0;
1757 
1758 	/* ignore RLEC as it reports errors for padded (<64bytes) frames
1759 	 * with a length in the type/len field */
1760 	netdev->stats.rx_errors =
1761 	    /* adapter->stats.rnbc + */ adapter->stats.crcerrs +
1762 	    adapter->stats.ruc +
1763 	    adapter->stats.roc /*+ adapter->stats.rlec */  +
1764 	    adapter->stats.icbc +
1765 	    adapter->stats.ecbc + adapter->stats.mpc;
1766 
1767 	/* see above
1768 	 * netdev->stats.rx_length_errors = adapter->stats.rlec;
1769 	 */
1770 
1771 	netdev->stats.rx_crc_errors = adapter->stats.crcerrs;
1772 	netdev->stats.rx_fifo_errors = adapter->stats.mpc;
1773 	netdev->stats.rx_missed_errors = adapter->stats.mpc;
1774 	netdev->stats.rx_over_errors = adapter->stats.mpc;
1775 
1776 	netdev->stats.tx_errors = 0;
1777 	netdev->stats.rx_frame_errors = 0;
1778 	netdev->stats.tx_aborted_errors = 0;
1779 	netdev->stats.tx_carrier_errors = 0;
1780 	netdev->stats.tx_fifo_errors = 0;
1781 	netdev->stats.tx_heartbeat_errors = 0;
1782 	netdev->stats.tx_window_errors = 0;
1783 }
1784 
1785 #define IXGB_MAX_INTR 10
1786 /**
1787  * ixgb_intr - Interrupt Handler
1788  * @irq: interrupt number
1789  * @data: pointer to a network interface device structure
1790  **/
1791 
1792 static irqreturn_t
ixgb_intr(int irq,void * data)1793 ixgb_intr(int irq, void *data)
1794 {
1795 	struct net_device *netdev = data;
1796 	struct ixgb_adapter *adapter = netdev_priv(netdev);
1797 	struct ixgb_hw *hw = &adapter->hw;
1798 	u32 icr = IXGB_READ_REG(hw, ICR);
1799 
1800 	if (unlikely(!icr))
1801 		return IRQ_NONE;  /* Not our interrupt */
1802 
1803 	if (unlikely(icr & (IXGB_INT_RXSEQ | IXGB_INT_LSC)))
1804 		if (!test_bit(__IXGB_DOWN, &adapter->flags))
1805 			mod_timer(&adapter->watchdog_timer, jiffies);
1806 
1807 	if (napi_schedule_prep(&adapter->napi)) {
1808 
1809 		/* Disable interrupts and register for poll. The flush
1810 		  of the posted write is intentionally left out.
1811 		*/
1812 
1813 		IXGB_WRITE_REG(&adapter->hw, IMC, ~0);
1814 		__napi_schedule(&adapter->napi);
1815 	}
1816 	return IRQ_HANDLED;
1817 }
1818 
1819 /**
1820  * ixgb_clean - NAPI Rx polling callback
1821  * @adapter: board private structure
1822  **/
1823 
1824 static int
ixgb_clean(struct napi_struct * napi,int budget)1825 ixgb_clean(struct napi_struct *napi, int budget)
1826 {
1827 	struct ixgb_adapter *adapter = container_of(napi, struct ixgb_adapter, napi);
1828 	int work_done = 0;
1829 
1830 	ixgb_clean_tx_irq(adapter);
1831 	ixgb_clean_rx_irq(adapter, &work_done, budget);
1832 
1833 	/* If budget not fully consumed, exit the polling mode */
1834 	if (work_done < budget) {
1835 		napi_complete(napi);
1836 		if (!test_bit(__IXGB_DOWN, &adapter->flags))
1837 			ixgb_irq_enable(adapter);
1838 	}
1839 
1840 	return work_done;
1841 }
1842 
1843 /**
1844  * ixgb_clean_tx_irq - Reclaim resources after transmit completes
1845  * @adapter: board private structure
1846  **/
1847 
1848 static bool
ixgb_clean_tx_irq(struct ixgb_adapter * adapter)1849 ixgb_clean_tx_irq(struct ixgb_adapter *adapter)
1850 {
1851 	struct ixgb_desc_ring *tx_ring = &adapter->tx_ring;
1852 	struct net_device *netdev = adapter->netdev;
1853 	struct ixgb_tx_desc *tx_desc, *eop_desc;
1854 	struct ixgb_buffer *buffer_info;
1855 	unsigned int i, eop;
1856 	bool cleaned = false;
1857 
1858 	i = tx_ring->next_to_clean;
1859 	eop = tx_ring->buffer_info[i].next_to_watch;
1860 	eop_desc = IXGB_TX_DESC(*tx_ring, eop);
1861 
1862 	while (eop_desc->status & IXGB_TX_DESC_STATUS_DD) {
1863 
1864 		rmb(); /* read buffer_info after eop_desc */
1865 		for (cleaned = false; !cleaned; ) {
1866 			tx_desc = IXGB_TX_DESC(*tx_ring, i);
1867 			buffer_info = &tx_ring->buffer_info[i];
1868 
1869 			if (tx_desc->popts &
1870 			   (IXGB_TX_DESC_POPTS_TXSM |
1871 			    IXGB_TX_DESC_POPTS_IXSM))
1872 				adapter->hw_csum_tx_good++;
1873 
1874 			ixgb_unmap_and_free_tx_resource(adapter, buffer_info);
1875 
1876 			*(u32 *)&(tx_desc->status) = 0;
1877 
1878 			cleaned = (i == eop);
1879 			if (++i == tx_ring->count) i = 0;
1880 		}
1881 
1882 		eop = tx_ring->buffer_info[i].next_to_watch;
1883 		eop_desc = IXGB_TX_DESC(*tx_ring, eop);
1884 	}
1885 
1886 	tx_ring->next_to_clean = i;
1887 
1888 	if (unlikely(cleaned && netif_carrier_ok(netdev) &&
1889 		     IXGB_DESC_UNUSED(tx_ring) >= DESC_NEEDED)) {
1890 		/* Make sure that anybody stopping the queue after this
1891 		 * sees the new next_to_clean. */
1892 		smp_mb();
1893 
1894 		if (netif_queue_stopped(netdev) &&
1895 		    !(test_bit(__IXGB_DOWN, &adapter->flags))) {
1896 			netif_wake_queue(netdev);
1897 			++adapter->restart_queue;
1898 		}
1899 	}
1900 
1901 	if (adapter->detect_tx_hung) {
1902 		/* detect a transmit hang in hardware, this serializes the
1903 		 * check with the clearing of time_stamp and movement of i */
1904 		adapter->detect_tx_hung = false;
1905 		if (tx_ring->buffer_info[eop].time_stamp &&
1906 		   time_after(jiffies, tx_ring->buffer_info[eop].time_stamp + HZ)
1907 		   && !(IXGB_READ_REG(&adapter->hw, STATUS) &
1908 		        IXGB_STATUS_TXOFF)) {
1909 			/* detected Tx unit hang */
1910 			netif_err(adapter, drv, adapter->netdev,
1911 				  "Detected Tx Unit Hang\n"
1912 				  "  TDH                  <%x>\n"
1913 				  "  TDT                  <%x>\n"
1914 				  "  next_to_use          <%x>\n"
1915 				  "  next_to_clean        <%x>\n"
1916 				  "buffer_info[next_to_clean]\n"
1917 				  "  time_stamp           <%lx>\n"
1918 				  "  next_to_watch        <%x>\n"
1919 				  "  jiffies              <%lx>\n"
1920 				  "  next_to_watch.status <%x>\n",
1921 				  IXGB_READ_REG(&adapter->hw, TDH),
1922 				  IXGB_READ_REG(&adapter->hw, TDT),
1923 				  tx_ring->next_to_use,
1924 				  tx_ring->next_to_clean,
1925 				  tx_ring->buffer_info[eop].time_stamp,
1926 				  eop,
1927 				  jiffies,
1928 				  eop_desc->status);
1929 			netif_stop_queue(netdev);
1930 		}
1931 	}
1932 
1933 	return cleaned;
1934 }
1935 
1936 /**
1937  * ixgb_rx_checksum - Receive Checksum Offload for 82597.
1938  * @adapter: board private structure
1939  * @rx_desc: receive descriptor
1940  * @sk_buff: socket buffer with received data
1941  **/
1942 
1943 static void
ixgb_rx_checksum(struct ixgb_adapter * adapter,struct ixgb_rx_desc * rx_desc,struct sk_buff * skb)1944 ixgb_rx_checksum(struct ixgb_adapter *adapter,
1945                  struct ixgb_rx_desc *rx_desc,
1946                  struct sk_buff *skb)
1947 {
1948 	/* Ignore Checksum bit is set OR
1949 	 * TCP Checksum has not been calculated
1950 	 */
1951 	if ((rx_desc->status & IXGB_RX_DESC_STATUS_IXSM) ||
1952 	   (!(rx_desc->status & IXGB_RX_DESC_STATUS_TCPCS))) {
1953 		skb_checksum_none_assert(skb);
1954 		return;
1955 	}
1956 
1957 	/* At this point we know the hardware did the TCP checksum */
1958 	/* now look at the TCP checksum error bit */
1959 	if (rx_desc->errors & IXGB_RX_DESC_ERRORS_TCPE) {
1960 		/* let the stack verify checksum errors */
1961 		skb_checksum_none_assert(skb);
1962 		adapter->hw_csum_rx_error++;
1963 	} else {
1964 		/* TCP checksum is good */
1965 		skb->ip_summed = CHECKSUM_UNNECESSARY;
1966 		adapter->hw_csum_rx_good++;
1967 	}
1968 }
1969 
1970 /*
1971  * this should improve performance for small packets with large amounts
1972  * of reassembly being done in the stack
1973  */
ixgb_check_copybreak(struct net_device * netdev,struct ixgb_buffer * buffer_info,u32 length,struct sk_buff ** skb)1974 static void ixgb_check_copybreak(struct net_device *netdev,
1975 				 struct ixgb_buffer *buffer_info,
1976 				 u32 length, struct sk_buff **skb)
1977 {
1978 	struct sk_buff *new_skb;
1979 
1980 	if (length > copybreak)
1981 		return;
1982 
1983 	new_skb = netdev_alloc_skb_ip_align(netdev, length);
1984 	if (!new_skb)
1985 		return;
1986 
1987 	skb_copy_to_linear_data_offset(new_skb, -NET_IP_ALIGN,
1988 				       (*skb)->data - NET_IP_ALIGN,
1989 				       length + NET_IP_ALIGN);
1990 	/* save the skb in buffer_info as good */
1991 	buffer_info->skb = *skb;
1992 	*skb = new_skb;
1993 }
1994 
1995 /**
1996  * ixgb_clean_rx_irq - Send received data up the network stack,
1997  * @adapter: board private structure
1998  **/
1999 
2000 static bool
ixgb_clean_rx_irq(struct ixgb_adapter * adapter,int * work_done,int work_to_do)2001 ixgb_clean_rx_irq(struct ixgb_adapter *adapter, int *work_done, int work_to_do)
2002 {
2003 	struct ixgb_desc_ring *rx_ring = &adapter->rx_ring;
2004 	struct net_device *netdev = adapter->netdev;
2005 	struct pci_dev *pdev = adapter->pdev;
2006 	struct ixgb_rx_desc *rx_desc, *next_rxd;
2007 	struct ixgb_buffer *buffer_info, *next_buffer, *next2_buffer;
2008 	u32 length;
2009 	unsigned int i, j;
2010 	int cleaned_count = 0;
2011 	bool cleaned = false;
2012 
2013 	i = rx_ring->next_to_clean;
2014 	rx_desc = IXGB_RX_DESC(*rx_ring, i);
2015 	buffer_info = &rx_ring->buffer_info[i];
2016 
2017 	while (rx_desc->status & IXGB_RX_DESC_STATUS_DD) {
2018 		struct sk_buff *skb;
2019 		u8 status;
2020 
2021 		if (*work_done >= work_to_do)
2022 			break;
2023 
2024 		(*work_done)++;
2025 		rmb();	/* read descriptor and rx_buffer_info after status DD */
2026 		status = rx_desc->status;
2027 		skb = buffer_info->skb;
2028 		buffer_info->skb = NULL;
2029 
2030 		prefetch(skb->data - NET_IP_ALIGN);
2031 
2032 		if (++i == rx_ring->count)
2033 			i = 0;
2034 		next_rxd = IXGB_RX_DESC(*rx_ring, i);
2035 		prefetch(next_rxd);
2036 
2037 		j = i + 1;
2038 		if (j == rx_ring->count)
2039 			j = 0;
2040 		next2_buffer = &rx_ring->buffer_info[j];
2041 		prefetch(next2_buffer);
2042 
2043 		next_buffer = &rx_ring->buffer_info[i];
2044 
2045 		cleaned = true;
2046 		cleaned_count++;
2047 
2048 		dma_unmap_single(&pdev->dev,
2049 				 buffer_info->dma,
2050 				 buffer_info->length,
2051 				 DMA_FROM_DEVICE);
2052 		buffer_info->dma = 0;
2053 
2054 		length = le16_to_cpu(rx_desc->length);
2055 		rx_desc->length = 0;
2056 
2057 		if (unlikely(!(status & IXGB_RX_DESC_STATUS_EOP))) {
2058 
2059 			/* All receives must fit into a single buffer */
2060 
2061 			pr_debug("Receive packet consumed multiple buffers length<%x>\n",
2062 				 length);
2063 
2064 			dev_kfree_skb_irq(skb);
2065 			goto rxdesc_done;
2066 		}
2067 
2068 		if (unlikely(rx_desc->errors &
2069 		    (IXGB_RX_DESC_ERRORS_CE | IXGB_RX_DESC_ERRORS_SE |
2070 		     IXGB_RX_DESC_ERRORS_P | IXGB_RX_DESC_ERRORS_RXE))) {
2071 			dev_kfree_skb_irq(skb);
2072 			goto rxdesc_done;
2073 		}
2074 
2075 		ixgb_check_copybreak(netdev, buffer_info, length, &skb);
2076 
2077 		/* Good Receive */
2078 		skb_put(skb, length);
2079 
2080 		/* Receive Checksum Offload */
2081 		ixgb_rx_checksum(adapter, rx_desc, skb);
2082 
2083 		skb->protocol = eth_type_trans(skb, netdev);
2084 		if (status & IXGB_RX_DESC_STATUS_VP)
2085 			__vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q),
2086 				       le16_to_cpu(rx_desc->special));
2087 
2088 		netif_receive_skb(skb);
2089 
2090 rxdesc_done:
2091 		/* clean up descriptor, might be written over by hw */
2092 		rx_desc->status = 0;
2093 
2094 		/* return some buffers to hardware, one at a time is too slow */
2095 		if (unlikely(cleaned_count >= IXGB_RX_BUFFER_WRITE)) {
2096 			ixgb_alloc_rx_buffers(adapter, cleaned_count);
2097 			cleaned_count = 0;
2098 		}
2099 
2100 		/* use prefetched values */
2101 		rx_desc = next_rxd;
2102 		buffer_info = next_buffer;
2103 	}
2104 
2105 	rx_ring->next_to_clean = i;
2106 
2107 	cleaned_count = IXGB_DESC_UNUSED(rx_ring);
2108 	if (cleaned_count)
2109 		ixgb_alloc_rx_buffers(adapter, cleaned_count);
2110 
2111 	return cleaned;
2112 }
2113 
2114 /**
2115  * ixgb_alloc_rx_buffers - Replace used receive buffers
2116  * @adapter: address of board private structure
2117  **/
2118 
2119 static void
ixgb_alloc_rx_buffers(struct ixgb_adapter * adapter,int cleaned_count)2120 ixgb_alloc_rx_buffers(struct ixgb_adapter *adapter, int cleaned_count)
2121 {
2122 	struct ixgb_desc_ring *rx_ring = &adapter->rx_ring;
2123 	struct net_device *netdev = adapter->netdev;
2124 	struct pci_dev *pdev = adapter->pdev;
2125 	struct ixgb_rx_desc *rx_desc;
2126 	struct ixgb_buffer *buffer_info;
2127 	struct sk_buff *skb;
2128 	unsigned int i;
2129 	long cleancount;
2130 
2131 	i = rx_ring->next_to_use;
2132 	buffer_info = &rx_ring->buffer_info[i];
2133 	cleancount = IXGB_DESC_UNUSED(rx_ring);
2134 
2135 
2136 	/* leave three descriptors unused */
2137 	while (--cleancount > 2 && cleaned_count--) {
2138 		/* recycle! its good for you */
2139 		skb = buffer_info->skb;
2140 		if (skb) {
2141 			skb_trim(skb, 0);
2142 			goto map_skb;
2143 		}
2144 
2145 		skb = netdev_alloc_skb_ip_align(netdev, adapter->rx_buffer_len);
2146 		if (unlikely(!skb)) {
2147 			/* Better luck next round */
2148 			adapter->alloc_rx_buff_failed++;
2149 			break;
2150 		}
2151 
2152 		buffer_info->skb = skb;
2153 		buffer_info->length = adapter->rx_buffer_len;
2154 map_skb:
2155 		buffer_info->dma = dma_map_single(&pdev->dev,
2156 		                                  skb->data,
2157 		                                  adapter->rx_buffer_len,
2158 						  DMA_FROM_DEVICE);
2159 		if (dma_mapping_error(&pdev->dev, buffer_info->dma)) {
2160 			adapter->alloc_rx_buff_failed++;
2161 			break;
2162 		}
2163 
2164 		rx_desc = IXGB_RX_DESC(*rx_ring, i);
2165 		rx_desc->buff_addr = cpu_to_le64(buffer_info->dma);
2166 		/* guarantee DD bit not set now before h/w gets descriptor
2167 		 * this is the rest of the workaround for h/w double
2168 		 * writeback. */
2169 		rx_desc->status = 0;
2170 
2171 
2172 		if (++i == rx_ring->count)
2173 			i = 0;
2174 		buffer_info = &rx_ring->buffer_info[i];
2175 	}
2176 
2177 	if (likely(rx_ring->next_to_use != i)) {
2178 		rx_ring->next_to_use = i;
2179 		if (unlikely(i-- == 0))
2180 			i = (rx_ring->count - 1);
2181 
2182 		/* Force memory writes to complete before letting h/w
2183 		 * know there are new descriptors to fetch.  (Only
2184 		 * applicable for weak-ordered memory model archs, such
2185 		 * as IA-64). */
2186 		wmb();
2187 		IXGB_WRITE_REG(&adapter->hw, RDT, i);
2188 	}
2189 }
2190 
2191 static void
ixgb_vlan_strip_enable(struct ixgb_adapter * adapter)2192 ixgb_vlan_strip_enable(struct ixgb_adapter *adapter)
2193 {
2194 	u32 ctrl;
2195 
2196 	/* enable VLAN tag insert/strip */
2197 	ctrl = IXGB_READ_REG(&adapter->hw, CTRL0);
2198 	ctrl |= IXGB_CTRL0_VME;
2199 	IXGB_WRITE_REG(&adapter->hw, CTRL0, ctrl);
2200 }
2201 
2202 static void
ixgb_vlan_strip_disable(struct ixgb_adapter * adapter)2203 ixgb_vlan_strip_disable(struct ixgb_adapter *adapter)
2204 {
2205 	u32 ctrl;
2206 
2207 	/* disable VLAN tag insert/strip */
2208 	ctrl = IXGB_READ_REG(&adapter->hw, CTRL0);
2209 	ctrl &= ~IXGB_CTRL0_VME;
2210 	IXGB_WRITE_REG(&adapter->hw, CTRL0, ctrl);
2211 }
2212 
2213 static int
ixgb_vlan_rx_add_vid(struct net_device * netdev,__be16 proto,u16 vid)2214 ixgb_vlan_rx_add_vid(struct net_device *netdev, __be16 proto, u16 vid)
2215 {
2216 	struct ixgb_adapter *adapter = netdev_priv(netdev);
2217 	u32 vfta, index;
2218 
2219 	/* add VID to filter table */
2220 
2221 	index = (vid >> 5) & 0x7F;
2222 	vfta = IXGB_READ_REG_ARRAY(&adapter->hw, VFTA, index);
2223 	vfta |= (1 << (vid & 0x1F));
2224 	ixgb_write_vfta(&adapter->hw, index, vfta);
2225 	set_bit(vid, adapter->active_vlans);
2226 
2227 	return 0;
2228 }
2229 
2230 static int
ixgb_vlan_rx_kill_vid(struct net_device * netdev,__be16 proto,u16 vid)2231 ixgb_vlan_rx_kill_vid(struct net_device *netdev, __be16 proto, u16 vid)
2232 {
2233 	struct ixgb_adapter *adapter = netdev_priv(netdev);
2234 	u32 vfta, index;
2235 
2236 	/* remove VID from filter table */
2237 
2238 	index = (vid >> 5) & 0x7F;
2239 	vfta = IXGB_READ_REG_ARRAY(&adapter->hw, VFTA, index);
2240 	vfta &= ~(1 << (vid & 0x1F));
2241 	ixgb_write_vfta(&adapter->hw, index, vfta);
2242 	clear_bit(vid, adapter->active_vlans);
2243 
2244 	return 0;
2245 }
2246 
2247 static void
ixgb_restore_vlan(struct ixgb_adapter * adapter)2248 ixgb_restore_vlan(struct ixgb_adapter *adapter)
2249 {
2250 	u16 vid;
2251 
2252 	for_each_set_bit(vid, adapter->active_vlans, VLAN_N_VID)
2253 		ixgb_vlan_rx_add_vid(adapter->netdev, htons(ETH_P_8021Q), vid);
2254 }
2255 
2256 #ifdef CONFIG_NET_POLL_CONTROLLER
2257 /*
2258  * Polling 'interrupt' - used by things like netconsole to send skbs
2259  * without having to re-enable interrupts. It's not called while
2260  * the interrupt routine is executing.
2261  */
2262 
ixgb_netpoll(struct net_device * dev)2263 static void ixgb_netpoll(struct net_device *dev)
2264 {
2265 	struct ixgb_adapter *adapter = netdev_priv(dev);
2266 
2267 	disable_irq(adapter->pdev->irq);
2268 	ixgb_intr(adapter->pdev->irq, dev);
2269 	enable_irq(adapter->pdev->irq);
2270 }
2271 #endif
2272 
2273 /**
2274  * ixgb_io_error_detected - called when PCI error is detected
2275  * @pdev:    pointer to pci device with error
2276  * @state:   pci channel state after error
2277  *
2278  * This callback is called by the PCI subsystem whenever
2279  * a PCI bus error is detected.
2280  */
ixgb_io_error_detected(struct pci_dev * pdev,enum pci_channel_state state)2281 static pci_ers_result_t ixgb_io_error_detected(struct pci_dev *pdev,
2282                                                enum pci_channel_state state)
2283 {
2284 	struct net_device *netdev = pci_get_drvdata(pdev);
2285 	struct ixgb_adapter *adapter = netdev_priv(netdev);
2286 
2287 	netif_device_detach(netdev);
2288 
2289 	if (state == pci_channel_io_perm_failure)
2290 		return PCI_ERS_RESULT_DISCONNECT;
2291 
2292 	if (netif_running(netdev))
2293 		ixgb_down(adapter, true);
2294 
2295 	pci_disable_device(pdev);
2296 
2297 	/* Request a slot reset. */
2298 	return PCI_ERS_RESULT_NEED_RESET;
2299 }
2300 
2301 /**
2302  * ixgb_io_slot_reset - called after the pci bus has been reset.
2303  * @pdev    pointer to pci device with error
2304  *
2305  * This callback is called after the PCI bus has been reset.
2306  * Basically, this tries to restart the card from scratch.
2307  * This is a shortened version of the device probe/discovery code,
2308  * it resembles the first-half of the ixgb_probe() routine.
2309  */
ixgb_io_slot_reset(struct pci_dev * pdev)2310 static pci_ers_result_t ixgb_io_slot_reset(struct pci_dev *pdev)
2311 {
2312 	struct net_device *netdev = pci_get_drvdata(pdev);
2313 	struct ixgb_adapter *adapter = netdev_priv(netdev);
2314 
2315 	if (pci_enable_device(pdev)) {
2316 		netif_err(adapter, probe, adapter->netdev,
2317 			  "Cannot re-enable PCI device after reset\n");
2318 		return PCI_ERS_RESULT_DISCONNECT;
2319 	}
2320 
2321 	/* Perform card reset only on one instance of the card */
2322 	if (0 != PCI_FUNC (pdev->devfn))
2323 		return PCI_ERS_RESULT_RECOVERED;
2324 
2325 	pci_set_master(pdev);
2326 
2327 	netif_carrier_off(netdev);
2328 	netif_stop_queue(netdev);
2329 	ixgb_reset(adapter);
2330 
2331 	/* Make sure the EEPROM is good */
2332 	if (!ixgb_validate_eeprom_checksum(&adapter->hw)) {
2333 		netif_err(adapter, probe, adapter->netdev,
2334 			  "After reset, the EEPROM checksum is not valid\n");
2335 		return PCI_ERS_RESULT_DISCONNECT;
2336 	}
2337 	ixgb_get_ee_mac_addr(&adapter->hw, netdev->dev_addr);
2338 	memcpy(netdev->perm_addr, netdev->dev_addr, netdev->addr_len);
2339 
2340 	if (!is_valid_ether_addr(netdev->perm_addr)) {
2341 		netif_err(adapter, probe, adapter->netdev,
2342 			  "After reset, invalid MAC address\n");
2343 		return PCI_ERS_RESULT_DISCONNECT;
2344 	}
2345 
2346 	return PCI_ERS_RESULT_RECOVERED;
2347 }
2348 
2349 /**
2350  * ixgb_io_resume - called when its OK to resume normal operations
2351  * @pdev    pointer to pci device with error
2352  *
2353  * The error recovery driver tells us that its OK to resume
2354  * normal operation. Implementation resembles the second-half
2355  * of the ixgb_probe() routine.
2356  */
ixgb_io_resume(struct pci_dev * pdev)2357 static void ixgb_io_resume(struct pci_dev *pdev)
2358 {
2359 	struct net_device *netdev = pci_get_drvdata(pdev);
2360 	struct ixgb_adapter *adapter = netdev_priv(netdev);
2361 
2362 	pci_set_master(pdev);
2363 
2364 	if (netif_running(netdev)) {
2365 		if (ixgb_up(adapter)) {
2366 			pr_err("can't bring device back up after reset\n");
2367 			return;
2368 		}
2369 	}
2370 
2371 	netif_device_attach(netdev);
2372 	mod_timer(&adapter->watchdog_timer, jiffies);
2373 }
2374 
2375 /* ixgb_main.c */
2376