ixgb_main.c 62.7 KB
Newer Older
L
Linus Torvalds 已提交
1 2
/*******************************************************************************

3
  Intel PRO/10GbE Linux driver
4
  Copyright(c) 1999 - 2008 Intel Corporation.
5 6 7 8 9 10 11 12

  This program is free software; you can redistribute it and/or modify it
  under the terms and conditions of the GNU General Public License,
  version 2, as published by the Free Software Foundation.

  This program is distributed in the hope it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
L
Linus Torvalds 已提交
13
  more details.
14

L
Linus Torvalds 已提交
15
  You should have received a copy of the GNU General Public License along with
16 17 18 19 20 21
  this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.

  The full GNU General Public License is included in this distribution in
  the file called "COPYING".

L
Linus Torvalds 已提交
22 23
  Contact Information:
  Linux NICS <linux.nics@intel.com>
24
  e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
L
Linus Torvalds 已提交
25 26 27 28
  Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497

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

29 30
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

L
Linus Torvalds 已提交
31 32 33
#include "ixgb.h"

char ixgb_driver_name[] = "ixgb";
34
static char ixgb_driver_string[] = "Intel(R) PRO/10GbE Network Driver";
L
Linus Torvalds 已提交
35 36

#define DRIVERNAPI "-NAPI"
37
#define DRV_VERSION "1.0.135-k2" DRIVERNAPI
S
Stephen Hemminger 已提交
38
const char ixgb_driver_version[] = DRV_VERSION;
39
static const char ixgb_copyright[] = "Copyright (c) 1999-2008 Intel Corporation.";
L
Linus Torvalds 已提交
40

J
Jesse Brandeburg 已提交
41 42 43 44 45 46
#define IXGB_CB_LENGTH 256
static unsigned int copybreak __read_mostly = IXGB_CB_LENGTH;
module_param(copybreak, uint, 0644);
MODULE_PARM_DESC(copybreak,
	"Maximum size of packet that is copied to a new buffer on receive");

L
Linus Torvalds 已提交
47 48 49 50 51 52 53 54
/* ixgb_pci_tbl - PCI Device ID Table
 *
 * Wildcard entries (PCI_ANY_ID) should come last
 * Last entry must be all 0s
 *
 * { Vendor ID, Device ID, SubVendor ID, SubDevice ID,
 *   Class, Class Mask, private data (not used) }
 */
55
static DEFINE_PCI_DEVICE_TABLE(ixgb_pci_tbl) = {
L
Linus Torvalds 已提交
56 57
	{INTEL_VENDOR_ID, IXGB_DEVICE_ID_82597EX,
	 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
A
Auke Kok 已提交
58 59
	{INTEL_VENDOR_ID, IXGB_DEVICE_ID_82597EX_CX4,
	 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
L
Linus Torvalds 已提交
60 61
	{INTEL_VENDOR_ID, IXGB_DEVICE_ID_82597EX_SR,
	 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
62
	{INTEL_VENDOR_ID, IXGB_DEVICE_ID_82597EX_LR,
L
Linus Torvalds 已提交
63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85
	 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},

	/* required last entry */
	{0,}
};

MODULE_DEVICE_TABLE(pci, ixgb_pci_tbl);

/* Local Function Prototypes */
static int ixgb_init_module(void);
static void ixgb_exit_module(void);
static int ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent);
static void __devexit ixgb_remove(struct pci_dev *pdev);
static int ixgb_sw_init(struct ixgb_adapter *adapter);
static int ixgb_open(struct net_device *netdev);
static int ixgb_close(struct net_device *netdev);
static void ixgb_configure_tx(struct ixgb_adapter *adapter);
static void ixgb_configure_rx(struct ixgb_adapter *adapter);
static void ixgb_setup_rctl(struct ixgb_adapter *adapter);
static void ixgb_clean_tx_ring(struct ixgb_adapter *adapter);
static void ixgb_clean_rx_ring(struct ixgb_adapter *adapter);
static void ixgb_set_multi(struct net_device *netdev);
static void ixgb_watchdog(unsigned long data);
86 87
static netdev_tx_t ixgb_xmit_frame(struct sk_buff *skb,
				   struct net_device *netdev);
L
Linus Torvalds 已提交
88 89 90
static struct net_device_stats *ixgb_get_stats(struct net_device *netdev);
static int ixgb_change_mtu(struct net_device *netdev, int new_mtu);
static int ixgb_set_mac(struct net_device *netdev, void *p);
91
static irqreturn_t ixgb_intr(int irq, void *data);
J
Joe Perches 已提交
92
static bool ixgb_clean_tx_irq(struct ixgb_adapter *adapter);
93

94 95
static int ixgb_clean(struct napi_struct *, int);
static bool ixgb_clean_rx_irq(struct ixgb_adapter *, int *, int);
96
static void ixgb_alloc_rx_buffers(struct ixgb_adapter *, int);
97

L
Linus Torvalds 已提交
98
static void ixgb_tx_timeout(struct net_device *dev);
D
David Howells 已提交
99
static void ixgb_tx_timeout_task(struct work_struct *work);
100

L
Linus Torvalds 已提交
101
static void ixgb_vlan_rx_register(struct net_device *netdev,
102
                                  struct vlan_group *grp);
103 104
static void ixgb_vlan_rx_add_vid(struct net_device *netdev, u16 vid);
static void ixgb_vlan_rx_kill_vid(struct net_device *netdev, u16 vid);
L
Linus Torvalds 已提交
105 106 107 108 109 110 111
static void ixgb_restore_vlan(struct ixgb_adapter *adapter);

#ifdef CONFIG_NET_POLL_CONTROLLER
/* for netdump / net console */
static void ixgb_netpoll(struct net_device *dev);
#endif

112
static pci_ers_result_t ixgb_io_error_detected (struct pci_dev *pdev,
113
                             enum pci_channel_state state);
114 115
static pci_ers_result_t ixgb_io_slot_reset (struct pci_dev *pdev);
static void ixgb_io_resume (struct pci_dev *pdev);
L
Linus Torvalds 已提交
116

117 118 119 120 121 122
static struct pci_error_handlers ixgb_err_handler = {
	.error_detected = ixgb_io_error_detected,
	.slot_reset = ixgb_io_slot_reset,
	.resume = ixgb_io_resume,
};

L
Linus Torvalds 已提交
123
static struct pci_driver ixgb_driver = {
124
	.name     = ixgb_driver_name,
L
Linus Torvalds 已提交
125
	.id_table = ixgb_pci_tbl,
126 127
	.probe    = ixgb_probe,
	.remove   = __devexit_p(ixgb_remove),
128
	.err_handler = &ixgb_err_handler
L
Linus Torvalds 已提交
129 130 131 132 133
};

MODULE_AUTHOR("Intel Corporation, <linux.nics@intel.com>");
MODULE_DESCRIPTION("Intel(R) PRO/10GbE Network Driver");
MODULE_LICENSE("GPL");
134
MODULE_VERSION(DRV_VERSION);
L
Linus Torvalds 已提交
135

136 137 138 139 140
#define DEFAULT_DEBUG_LEVEL_SHIFT 3
static int debug = DEFAULT_DEBUG_LEVEL_SHIFT;
module_param(debug, int, 0);
MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");

L
Linus Torvalds 已提交
141 142 143 144 145 146 147 148 149 150
/**
 * ixgb_init_module - Driver Registration Routine
 *
 * ixgb_init_module is the first routine called when the driver is
 * loaded. All it does is register with the PCI subsystem.
 **/

static int __init
ixgb_init_module(void)
{
151 152
	pr_info("%s - version %s\n", ixgb_driver_string, ixgb_driver_version);
	pr_info("%s\n", ixgb_copyright);
L
Linus Torvalds 已提交
153

154
	return pci_register_driver(&ixgb_driver);
L
Linus Torvalds 已提交
155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178
}

module_init(ixgb_init_module);

/**
 * ixgb_exit_module - Driver Exit Cleanup Routine
 *
 * ixgb_exit_module is called just before the driver is removed
 * from memory.
 **/

static void __exit
ixgb_exit_module(void)
{
	pci_unregister_driver(&ixgb_driver);
}

module_exit(ixgb_exit_module);

/**
 * ixgb_irq_disable - Mask off interrupt generation on the NIC
 * @adapter: board private structure
 **/

179
static void
L
Linus Torvalds 已提交
180 181 182 183 184 185 186 187 188 189 190 191
ixgb_irq_disable(struct ixgb_adapter *adapter)
{
	IXGB_WRITE_REG(&adapter->hw, IMC, ~0);
	IXGB_WRITE_FLUSH(&adapter->hw);
	synchronize_irq(adapter->pdev->irq);
}

/**
 * ixgb_irq_enable - Enable default interrupt generation settings
 * @adapter: board private structure
 **/

192
static void
L
Linus Torvalds 已提交
193 194
ixgb_irq_enable(struct ixgb_adapter *adapter)
{
J
Jesse Brandeburg 已提交
195 196 197 198 199 200
	u32 val = IXGB_INT_RXT0 | IXGB_INT_RXDMT0 |
		  IXGB_INT_TXDW | IXGB_INT_LSC;
	if (adapter->hw.subsystem_vendor_id == SUN_SUBVENDOR_ID)
		val |= IXGB_INT_GPI0;
	IXGB_WRITE_REG(&adapter->hw, IMS, val);
	IXGB_WRITE_FLUSH(&adapter->hw);
L
Linus Torvalds 已提交
201 202 203 204 205 206
}

int
ixgb_up(struct ixgb_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;
207
	int err, irq_flags = IRQF_SHARED;
L
Linus Torvalds 已提交
208 209 210 211 212
	int max_frame = netdev->mtu + ENET_HEADER_SIZE + ENET_FCS_LENGTH;
	struct ixgb_hw *hw = &adapter->hw;

	/* hardware has been reset, we need to reload some things */

213
	ixgb_rar_set(hw, netdev->dev_addr, 0);
L
Linus Torvalds 已提交
214 215 216 217 218 219 220
	ixgb_set_multi(netdev);

	ixgb_restore_vlan(adapter);

	ixgb_configure_tx(adapter);
	ixgb_setup_rctl(adapter);
	ixgb_configure_rx(adapter);
221
	ixgb_alloc_rx_buffers(adapter, IXGB_DESC_UNUSED(&adapter->rx_ring));
L
Linus Torvalds 已提交
222

A
Auke Kok 已提交
223 224 225
	/* disable interrupts and get the hardware into a known state */
	IXGB_WRITE_REG(&adapter->hw, IMC, 0xffffffff);

226 227 228 229 230 231 232
	/* only enable MSI if bus is in PCI-X mode */
	if (IXGB_READ_REG(&adapter->hw, STATUS) & IXGB_STATUS_PCIX_MODE) {
		err = pci_enable_msi(adapter->pdev);
		if (!err) {
			adapter->have_msi = 1;
			irq_flags = 0;
		}
L
Linus Torvalds 已提交
233 234 235
		/* proceed to try to request regular interrupt */
	}

236
	err = request_irq(adapter->pdev->irq, ixgb_intr, irq_flags,
237 238 239 240
	                  netdev->name, netdev);
	if (err) {
		if (adapter->have_msi)
			pci_disable_msi(adapter->pdev);
241 242
		netif_err(adapter, probe, adapter->netdev,
			  "Unable to allocate interrupt Error: %d\n", err);
L
Linus Torvalds 已提交
243
		return err;
244
	}
L
Linus Torvalds 已提交
245

246
	if ((hw->max_frame_size != max_frame) ||
L
Linus Torvalds 已提交
247 248 249 250 251 252 253
		(hw->max_frame_size !=
		(IXGB_READ_REG(hw, MFS) >> IXGB_MFS_SHIFT))) {

		hw->max_frame_size = max_frame;

		IXGB_WRITE_REG(hw, MFS, hw->max_frame_size << IXGB_MFS_SHIFT);

254
		if (hw->max_frame_size >
L
Linus Torvalds 已提交
255
		   IXGB_MAX_ENET_FRAME_SIZE_WITHOUT_FCS + ENET_FCS_LENGTH) {
256
			u32 ctrl0 = IXGB_READ_REG(hw, CTRL0);
L
Linus Torvalds 已提交
257

258
			if (!(ctrl0 & IXGB_CTRL0_JFE)) {
L
Linus Torvalds 已提交
259 260 261 262 263 264
				ctrl0 |= IXGB_CTRL0_JFE;
				IXGB_WRITE_REG(hw, CTRL0, ctrl0);
			}
		}
	}

265
	clear_bit(__IXGB_DOWN, &adapter->flags);
L
Linus Torvalds 已提交
266

267
	napi_enable(&adapter->napi);
A
Auke Kok 已提交
268 269
	ixgb_irq_enable(adapter);

270 271
	netif_wake_queue(netdev);

272 273
	mod_timer(&adapter->watchdog_timer, jiffies);

L
Linus Torvalds 已提交
274 275 276 277
	return 0;
}

void
J
Joe Perches 已提交
278
ixgb_down(struct ixgb_adapter *adapter, bool kill_watchdog)
L
Linus Torvalds 已提交
279 280 281
{
	struct net_device *netdev = adapter->netdev;

282 283 284
	/* prevent the interrupt handler from restarting watchdog */
	set_bit(__IXGB_DOWN, &adapter->flags);

285
	napi_disable(&adapter->napi);
286
	/* waiting for NAPI to complete can re-enable interrupts */
L
Linus Torvalds 已提交
287 288
	ixgb_irq_disable(adapter);
	free_irq(adapter->pdev->irq, netdev);
289 290

	if (adapter->have_msi)
L
Linus Torvalds 已提交
291 292
		pci_disable_msi(adapter->pdev);

293
	if (kill_watchdog)
L
Linus Torvalds 已提交
294
		del_timer_sync(&adapter->watchdog_timer);
295

L
Linus Torvalds 已提交
296 297 298 299 300 301 302 303 304 305 306 307 308
	adapter->link_speed = 0;
	adapter->link_duplex = 0;
	netif_carrier_off(netdev);
	netif_stop_queue(netdev);

	ixgb_reset(adapter);
	ixgb_clean_tx_ring(adapter);
	ixgb_clean_rx_ring(adapter);
}

void
ixgb_reset(struct ixgb_adapter *adapter)
{
309
	struct ixgb_hw *hw = &adapter->hw;
L
Linus Torvalds 已提交
310

311 312
	ixgb_adapter_stop(hw);
	if (!ixgb_init_hw(hw))
313
		netif_err(adapter, probe, adapter->netdev, "ixgb_init_hw failed\n");
314 315 316 317 318 319 320 321 322 323 324

	/* restore frame size information */
	IXGB_WRITE_REG(hw, MFS, hw->max_frame_size << IXGB_MFS_SHIFT);
	if (hw->max_frame_size >
	    IXGB_MAX_ENET_FRAME_SIZE_WITHOUT_FCS + ENET_FCS_LENGTH) {
		u32 ctrl0 = IXGB_READ_REG(hw, CTRL0);
		if (!(ctrl0 & IXGB_CTRL0_JFE)) {
			ctrl0 |= IXGB_CTRL0_JFE;
			IXGB_WRITE_REG(hw, CTRL0, ctrl0);
		}
	}
L
Linus Torvalds 已提交
325 326
}

327 328 329
static const struct net_device_ops ixgb_netdev_ops = {
	.ndo_open 		= ixgb_open,
	.ndo_stop		= ixgb_close,
330
	.ndo_start_xmit		= ixgb_xmit_frame,
331 332 333 334 335 336 337 338 339 340 341 342 343 344
	.ndo_get_stats		= ixgb_get_stats,
	.ndo_set_multicast_list	= ixgb_set_multi,
	.ndo_validate_addr	= eth_validate_addr,
	.ndo_set_mac_address	= ixgb_set_mac,
	.ndo_change_mtu		= ixgb_change_mtu,
	.ndo_tx_timeout		= ixgb_tx_timeout,
	.ndo_vlan_rx_register	= ixgb_vlan_rx_register,
	.ndo_vlan_rx_add_vid	= ixgb_vlan_rx_add_vid,
	.ndo_vlan_rx_kill_vid	= ixgb_vlan_rx_kill_vid,
#ifdef CONFIG_NET_POLL_CONTROLLER
	.ndo_poll_controller	= ixgb_netpoll,
#endif
};

L
Linus Torvalds 已提交
345 346 347 348 349 350 351 352 353 354 355 356 357
/**
 * ixgb_probe - Device Initialization Routine
 * @pdev: PCI device information struct
 * @ent: entry in ixgb_pci_tbl
 *
 * Returns 0 on success, negative on failure
 *
 * ixgb_probe initializes an adapter identified by a pci_dev structure.
 * The OS initialization, configuring of the adapter private structure,
 * and a hardware reset occur.
 **/

static int __devinit
J
Jesse Brandeburg 已提交
358
ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
L
Linus Torvalds 已提交
359 360 361 362 363 364 365 366
{
	struct net_device *netdev = NULL;
	struct ixgb_adapter *adapter;
	static int cards_found = 0;
	int pci_using_dac;
	int i;
	int err;

367 368
	err = pci_enable_device(pdev);
	if (err)
L
Linus Torvalds 已提交
369 370
		return err;

371 372 373 374 375 376
	pci_using_dac = 0;
	err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(64));
	if (!err) {
		err = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64));
		if (!err)
			pci_using_dac = 1;
L
Linus Torvalds 已提交
377
	} else {
378 379 380 381 382 383 384 385
		err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
		if (err) {
			err = dma_set_coherent_mask(&pdev->dev,
						    DMA_BIT_MASK(32));
			if (err) {
				pr_err("No usable DMA configuration, aborting\n");
				goto err_dma_mask;
			}
L
Linus Torvalds 已提交
386 387 388
		}
	}

389 390
	err = pci_request_regions(pdev, ixgb_driver_name);
	if (err)
391
		goto err_request_regions;
L
Linus Torvalds 已提交
392 393 394 395

	pci_set_master(pdev);

	netdev = alloc_etherdev(sizeof(struct ixgb_adapter));
396
	if (!netdev) {
L
Linus Torvalds 已提交
397 398 399 400 401 402 403
		err = -ENOMEM;
		goto err_alloc_etherdev;
	}

	SET_NETDEV_DEV(netdev, &pdev->dev);

	pci_set_drvdata(pdev, netdev);
404
	adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
405 406 407
	adapter->netdev = netdev;
	adapter->pdev = pdev;
	adapter->hw.back = adapter;
408
	adapter->msg_enable = netif_msg_init(debug, DEFAULT_DEBUG_LEVEL_SHIFT);
L
Linus Torvalds 已提交
409

410
	adapter->hw.hw_addr = pci_ioremap_bar(pdev, BAR_0);
411
	if (!adapter->hw.hw_addr) {
L
Linus Torvalds 已提交
412 413 414 415
		err = -EIO;
		goto err_ioremap;
	}

416
	for (i = BAR_1; i <= BAR_5; i++) {
417
		if (pci_resource_len(pdev, i) == 0)
L
Linus Torvalds 已提交
418
			continue;
419
		if (pci_resource_flags(pdev, i) & IORESOURCE_IO) {
L
Linus Torvalds 已提交
420 421 422 423 424
			adapter->hw.io_base = pci_resource_start(pdev, i);
			break;
		}
	}

425
	netdev->netdev_ops = &ixgb_netdev_ops;
L
Linus Torvalds 已提交
426
	ixgb_set_ethtool_ops(netdev);
A
Auke Kok 已提交
427
	netdev->watchdog_timeo = 5 * HZ;
428
	netif_napi_add(netdev, &adapter->napi, ixgb_clean, 64);
L
Linus Torvalds 已提交
429

430
	strncpy(netdev->name, pci_name(pdev), sizeof(netdev->name) - 1);
L
Linus Torvalds 已提交
431 432 433 434 435 436 437

	adapter->bd_number = cards_found;
	adapter->link_speed = 0;
	adapter->link_duplex = 0;

	/* setup the private structure */

438 439
	err = ixgb_sw_init(adapter);
	if (err)
L
Linus Torvalds 已提交
440 441 442 443 444 445 446 447 448
		goto err_sw_init;

	netdev->features = NETIF_F_SG |
			   NETIF_F_HW_CSUM |
			   NETIF_F_HW_VLAN_TX |
			   NETIF_F_HW_VLAN_RX |
			   NETIF_F_HW_VLAN_FILTER;
	netdev->features |= NETIF_F_TSO;

449
	if (pci_using_dac) {
L
Linus Torvalds 已提交
450
		netdev->features |= NETIF_F_HIGHDMA;
451 452
		netdev->vlan_features |= NETIF_F_HIGHDMA;
	}
L
Linus Torvalds 已提交
453 454 455

	/* make sure the EEPROM is good */

456
	if (!ixgb_validate_eeprom_checksum(&adapter->hw)) {
457 458
		netif_err(adapter, probe, adapter->netdev,
			  "The EEPROM Checksum Is Not Valid\n");
L
Linus Torvalds 已提交
459 460 461 462 463
		err = -EIO;
		goto err_eeprom;
	}

	ixgb_get_ee_mac_addr(&adapter->hw, netdev->dev_addr);
464
	memcpy(netdev->perm_addr, netdev->dev_addr, netdev->addr_len);
L
Linus Torvalds 已提交
465

466
	if (!is_valid_ether_addr(netdev->perm_addr)) {
467
		netif_err(adapter, probe, adapter->netdev, "Invalid MAC Address\n");
L
Linus Torvalds 已提交
468 469 470 471 472 473 474
		err = -EIO;
		goto err_eeprom;
	}

	adapter->part_num = ixgb_get_ee_pba_number(&adapter->hw);

	init_timer(&adapter->watchdog_timer);
475
	adapter->watchdog_timer.function = ixgb_watchdog;
L
Linus Torvalds 已提交
476 477
	adapter->watchdog_timer.data = (unsigned long)adapter;

D
David Howells 已提交
478
	INIT_WORK(&adapter->tx_timeout_task, ixgb_tx_timeout_task);
L
Linus Torvalds 已提交
479

480
	strcpy(netdev->name, "eth%d");
481 482
	err = register_netdev(netdev);
	if (err)
L
Linus Torvalds 已提交
483 484
		goto err_register;

485
	/* carrier off reporting is important to ethtool even BEFORE open */
L
Linus Torvalds 已提交
486 487
	netif_carrier_off(netdev);

488 489
	netif_info(adapter, probe, adapter->netdev,
		   "Intel(R) PRO/10GbE Network Connection\n");
L
Linus Torvalds 已提交
490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505
	ixgb_check_options(adapter);
	/* reset the hardware with the new settings */

	ixgb_reset(adapter);

	cards_found++;
	return 0;

err_register:
err_sw_init:
err_eeprom:
	iounmap(adapter->hw.hw_addr);
err_ioremap:
	free_netdev(netdev);
err_alloc_etherdev:
	pci_release_regions(pdev);
506 507 508
err_request_regions:
err_dma_mask:
	pci_disable_device(pdev);
L
Linus Torvalds 已提交
509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525
	return err;
}

/**
 * ixgb_remove - Device Removal Routine
 * @pdev: PCI device information struct
 *
 * ixgb_remove is called by the PCI subsystem to alert the driver
 * that it should release a PCI device.  The could be caused by a
 * Hot-Plug event, or because the driver is going to be removed from
 * memory.
 **/

static void __devexit
ixgb_remove(struct pci_dev *pdev)
{
	struct net_device *netdev = pci_get_drvdata(pdev);
526
	struct ixgb_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
527

528 529
	flush_scheduled_work();

L
Linus Torvalds 已提交
530 531 532 533 534 535
	unregister_netdev(netdev);

	iounmap(adapter->hw.hw_addr);
	pci_release_regions(pdev);

	free_netdev(netdev);
536
	pci_disable_device(pdev);
L
Linus Torvalds 已提交
537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562
}

/**
 * ixgb_sw_init - Initialize general software structures (struct ixgb_adapter)
 * @adapter: board private structure to initialize
 *
 * ixgb_sw_init initializes the Adapter private data structure.
 * Fields are initialized based on PCI device information and
 * OS network device settings (MTU size).
 **/

static int __devinit
ixgb_sw_init(struct ixgb_adapter *adapter)
{
	struct ixgb_hw *hw = &adapter->hw;
	struct net_device *netdev = adapter->netdev;
	struct pci_dev *pdev = adapter->pdev;

	/* PCI config space info */

	hw->vendor_id = pdev->vendor;
	hw->device_id = pdev->device;
	hw->subsystem_vendor_id = pdev->subsystem_vendor;
	hw->subsystem_id = pdev->subsystem_device;

	hw->max_frame_size = netdev->mtu + ENET_HEADER_SIZE + ENET_FCS_LENGTH;
563
	adapter->rx_buffer_len = hw->max_frame_size + 8; /* + 8 for errata */
L
Linus Torvalds 已提交
564

565 566 567 568
	if ((hw->device_id == IXGB_DEVICE_ID_82597EX) ||
	    (hw->device_id == IXGB_DEVICE_ID_82597EX_CX4) ||
	    (hw->device_id == IXGB_DEVICE_ID_82597EX_LR) ||
	    (hw->device_id == IXGB_DEVICE_ID_82597EX_SR))
J
Jesse Brandeburg 已提交
569
		hw->mac_type = ixgb_82597;
L
Linus Torvalds 已提交
570 571
	else {
		/* should never have loaded on this device */
572
		netif_err(adapter, probe, adapter->netdev, "unsupported device id\n");
L
Linus Torvalds 已提交
573 574 575 576 577
	}

	/* enable flow control to be programmed */
	hw->fc.send_xon = 1;

578
	set_bit(__IXGB_DOWN, &adapter->flags);
L
Linus Torvalds 已提交
579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597
	return 0;
}

/**
 * ixgb_open - Called when a network interface is made active
 * @netdev: network interface device structure
 *
 * Returns 0 on success, negative value on failure
 *
 * The open entry point is called when a network interface is made
 * active by the system (IFF_UP).  At this point all resources needed
 * for transmit and receive operations are allocated, the interrupt
 * handler is registered with the OS, the watchdog timer is started,
 * and the stack is notified that the interface is ready.
 **/

static int
ixgb_open(struct net_device *netdev)
{
598
	struct ixgb_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
599 600 601
	int err;

	/* allocate transmit descriptors */
602 603
	err = ixgb_setup_tx_resources(adapter);
	if (err)
L
Linus Torvalds 已提交
604 605
		goto err_setup_tx;

606 607
	netif_carrier_off(netdev);

L
Linus Torvalds 已提交
608 609
	/* allocate receive descriptors */

610 611
	err = ixgb_setup_rx_resources(adapter);
	if (err)
L
Linus Torvalds 已提交
612 613
		goto err_setup_rx;

614 615
	err = ixgb_up(adapter);
	if (err)
L
Linus Torvalds 已提交
616 617
		goto err_up;

618 619
	netif_start_queue(netdev);

L
Linus Torvalds 已提交
620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646
	return 0;

err_up:
	ixgb_free_rx_resources(adapter);
err_setup_rx:
	ixgb_free_tx_resources(adapter);
err_setup_tx:
	ixgb_reset(adapter);

	return err;
}

/**
 * ixgb_close - Disables a network interface
 * @netdev: network interface device structure
 *
 * Returns 0, this is not allowed to fail
 *
 * The close entry point is called when an interface is de-activated
 * by the OS.  The hardware is still under the drivers control, but
 * needs to be disabled.  A global MAC reset is issued to stop the
 * hardware, and all transmit and receive resources are freed.
 **/

static int
ixgb_close(struct net_device *netdev)
{
647
	struct ixgb_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
648

J
Joe Perches 已提交
649
	ixgb_down(adapter, true);
L
Linus Torvalds 已提交
650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672

	ixgb_free_tx_resources(adapter);
	ixgb_free_rx_resources(adapter);

	return 0;
}

/**
 * ixgb_setup_tx_resources - allocate Tx resources (Descriptors)
 * @adapter: board private structure
 *
 * Return 0 on success, negative on failure
 **/

int
ixgb_setup_tx_resources(struct ixgb_adapter *adapter)
{
	struct ixgb_desc_ring *txdr = &adapter->tx_ring;
	struct pci_dev *pdev = adapter->pdev;
	int size;

	size = sizeof(struct ixgb_buffer) * txdr->count;
	txdr->buffer_info = vmalloc(size);
673
	if (!txdr->buffer_info) {
674 675
		netif_err(adapter, probe, adapter->netdev,
			  "Unable to allocate transmit descriptor ring memory\n");
L
Linus Torvalds 已提交
676 677 678 679 680 681 682
		return -ENOMEM;
	}
	memset(txdr->buffer_info, 0, size);

	/* round up to nearest 4K */

	txdr->size = txdr->count * sizeof(struct ixgb_tx_desc);
683
	txdr->size = ALIGN(txdr->size, 4096);
L
Linus Torvalds 已提交
684

685 686
	txdr->desc = dma_alloc_coherent(&pdev->dev, txdr->size, &txdr->dma,
					GFP_KERNEL);
687
	if (!txdr->desc) {
L
Linus Torvalds 已提交
688
		vfree(txdr->buffer_info);
689 690
		netif_err(adapter, probe, adapter->netdev,
			  "Unable to allocate transmit descriptor memory\n");
L
Linus Torvalds 已提交
691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710
		return -ENOMEM;
	}
	memset(txdr->desc, 0, txdr->size);

	txdr->next_to_use = 0;
	txdr->next_to_clean = 0;

	return 0;
}

/**
 * ixgb_configure_tx - Configure 82597 Transmit Unit after Reset.
 * @adapter: board private structure
 *
 * Configure the Tx unit of the MAC after a reset.
 **/

static void
ixgb_configure_tx(struct ixgb_adapter *adapter)
{
711 712 713
	u64 tdba = adapter->tx_ring.dma;
	u32 tdlen = adapter->tx_ring.count * sizeof(struct ixgb_tx_desc);
	u32 tctl;
L
Linus Torvalds 已提交
714 715
	struct ixgb_hw *hw = &adapter->hw;

J
Jesse Brandeburg 已提交
716 717
	/* Setup the Base and Length of the Tx Descriptor Ring
	 * tx_ring.dma can be either a 32 or 64 bit value
L
Linus Torvalds 已提交
718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742
	 */

	IXGB_WRITE_REG(hw, TDBAL, (tdba & 0x00000000ffffffffULL));
	IXGB_WRITE_REG(hw, TDBAH, (tdba >> 32));

	IXGB_WRITE_REG(hw, TDLEN, tdlen);

	/* Setup the HW Tx Head and Tail descriptor pointers */

	IXGB_WRITE_REG(hw, TDH, 0);
	IXGB_WRITE_REG(hw, TDT, 0);

	/* don't set up txdctl, it induces performance problems if configured
	 * incorrectly */
	/* Set the Tx Interrupt Delay register */

	IXGB_WRITE_REG(hw, TIDV, adapter->tx_int_delay);

	/* Program the Transmit Control Register */

	tctl = IXGB_TCTL_TCE | IXGB_TCTL_TXEN | IXGB_TCTL_TPDE;
	IXGB_WRITE_REG(hw, TCTL, tctl);

	/* Setup Transmit Descriptor Settings for this adapter */
	adapter->tx_cmd_type =
J
Jesse Brandeburg 已提交
743 744
		IXGB_TX_DESC_TYPE |
		(adapter->tx_int_delay_enable ? IXGB_TX_DESC_CMD_IDE : 0);
L
Linus Torvalds 已提交
745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762
}

/**
 * ixgb_setup_rx_resources - allocate Rx resources (Descriptors)
 * @adapter: board private structure
 *
 * Returns 0 on success, negative on failure
 **/

int
ixgb_setup_rx_resources(struct ixgb_adapter *adapter)
{
	struct ixgb_desc_ring *rxdr = &adapter->rx_ring;
	struct pci_dev *pdev = adapter->pdev;
	int size;

	size = sizeof(struct ixgb_buffer) * rxdr->count;
	rxdr->buffer_info = vmalloc(size);
763
	if (!rxdr->buffer_info) {
764 765
		netif_err(adapter, probe, adapter->netdev,
			  "Unable to allocate receive descriptor ring\n");
L
Linus Torvalds 已提交
766 767 768 769 770 771 772
		return -ENOMEM;
	}
	memset(rxdr->buffer_info, 0, size);

	/* Round up to nearest 4K */

	rxdr->size = rxdr->count * sizeof(struct ixgb_rx_desc);
773
	rxdr->size = ALIGN(rxdr->size, 4096);
L
Linus Torvalds 已提交
774

775 776
	rxdr->desc = dma_alloc_coherent(&pdev->dev, rxdr->size, &rxdr->dma,
					GFP_KERNEL);
L
Linus Torvalds 已提交
777

778
	if (!rxdr->desc) {
L
Linus Torvalds 已提交
779
		vfree(rxdr->buffer_info);
780 781
		netif_err(adapter, probe, adapter->netdev,
			  "Unable to allocate receive descriptors\n");
L
Linus Torvalds 已提交
782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799
		return -ENOMEM;
	}
	memset(rxdr->desc, 0, rxdr->size);

	rxdr->next_to_clean = 0;
	rxdr->next_to_use = 0;

	return 0;
}

/**
 * ixgb_setup_rctl - configure the receive control register
 * @adapter: Board private structure
 **/

static void
ixgb_setup_rctl(struct ixgb_adapter *adapter)
{
800
	u32 rctl;
L
Linus Torvalds 已提交
801 802 803 804 805 806

	rctl = IXGB_READ_REG(&adapter->hw, RCTL);

	rctl &= ~(3 << IXGB_RCTL_MO_SHIFT);

	rctl |=
J
Jesse Brandeburg 已提交
807 808
		IXGB_RCTL_BAM | IXGB_RCTL_RDMTS_1_2 |
		IXGB_RCTL_RXEN | IXGB_RCTL_CFF |
L
Linus Torvalds 已提交
809 810 811 812
		(adapter->hw.mc_filter_type << IXGB_RCTL_MO_SHIFT);

	rctl |= IXGB_RCTL_SECRC;

A
Auke Kok 已提交
813
	if (adapter->rx_buffer_len <= IXGB_RXBUFFER_2048)
L
Linus Torvalds 已提交
814
		rctl |= IXGB_RCTL_BSIZE_2048;
A
Auke Kok 已提交
815
	else if (adapter->rx_buffer_len <= IXGB_RXBUFFER_4096)
L
Linus Torvalds 已提交
816
		rctl |= IXGB_RCTL_BSIZE_4096;
A
Auke Kok 已提交
817
	else if (adapter->rx_buffer_len <= IXGB_RXBUFFER_8192)
L
Linus Torvalds 已提交
818
		rctl |= IXGB_RCTL_BSIZE_8192;
A
Auke Kok 已提交
819
	else if (adapter->rx_buffer_len <= IXGB_RXBUFFER_16384)
L
Linus Torvalds 已提交
820 821 822 823 824 825 826 827 828 829 830 831 832 833 834
		rctl |= IXGB_RCTL_BSIZE_16384;

	IXGB_WRITE_REG(&adapter->hw, RCTL, rctl);
}

/**
 * ixgb_configure_rx - Configure 82597 Receive Unit after Reset.
 * @adapter: board private structure
 *
 * Configure the Rx unit of the MAC after a reset.
 **/

static void
ixgb_configure_rx(struct ixgb_adapter *adapter)
{
835 836
	u64 rdba = adapter->rx_ring.dma;
	u32 rdlen = adapter->rx_ring.count * sizeof(struct ixgb_rx_desc);
L
Linus Torvalds 已提交
837
	struct ixgb_hw *hw = &adapter->hw;
838 839
	u32 rctl;
	u32 rxcsum;
L
Linus Torvalds 已提交
840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860

	/* make sure receives are disabled while setting up the descriptors */

	rctl = IXGB_READ_REG(hw, RCTL);
	IXGB_WRITE_REG(hw, RCTL, rctl & ~IXGB_RCTL_RXEN);

	/* set the Receive Delay Timer Register */

	IXGB_WRITE_REG(hw, RDTR, adapter->rx_int_delay);

	/* Setup the Base and Length of the Rx Descriptor Ring */

	IXGB_WRITE_REG(hw, RDBAL, (rdba & 0x00000000ffffffffULL));
	IXGB_WRITE_REG(hw, RDBAH, (rdba >> 32));

	IXGB_WRITE_REG(hw, RDLEN, rdlen);

	/* Setup the HW Rx Head and Tail Descriptor Pointers */
	IXGB_WRITE_REG(hw, RDH, 0);
	IXGB_WRITE_REG(hw, RDT, 0);

861 862 863 864 865 866
	/* due to the hardware errata with RXDCTL, we are unable to use any of
	 * the performance enhancing features of it without causing other
	 * subtle bugs, some of the bugs could include receive length
	 * corruption at high data rates (WTHRESH > 0) and/or receive
	 * descriptor ring irregularites (particularly in hardware cache) */
	IXGB_WRITE_REG(hw, RXDCTL, 0);
L
Linus Torvalds 已提交
867 868

	/* Enable Receive Checksum Offload for TCP and UDP */
J
Joe Perches 已提交
869
	if (adapter->rx_csum) {
L
Linus Torvalds 已提交
870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896
		rxcsum = IXGB_READ_REG(hw, RXCSUM);
		rxcsum |= IXGB_RXCSUM_TUOFL;
		IXGB_WRITE_REG(hw, RXCSUM, rxcsum);
	}

	/* Enable Receives */

	IXGB_WRITE_REG(hw, RCTL, rctl);
}

/**
 * ixgb_free_tx_resources - Free Tx Resources
 * @adapter: board private structure
 *
 * Free all transmit software resources
 **/

void
ixgb_free_tx_resources(struct ixgb_adapter *adapter)
{
	struct pci_dev *pdev = adapter->pdev;

	ixgb_clean_tx_ring(adapter);

	vfree(adapter->tx_ring.buffer_info);
	adapter->tx_ring.buffer_info = NULL;

897 898
	dma_free_coherent(&pdev->dev, adapter->tx_ring.size,
			  adapter->tx_ring.desc, adapter->tx_ring.dma);
L
Linus Torvalds 已提交
899 900 901 902

	adapter->tx_ring.desc = NULL;
}

903
static void
L
Linus Torvalds 已提交
904
ixgb_unmap_and_free_tx_resource(struct ixgb_adapter *adapter,
J
Jesse Brandeburg 已提交
905
                                struct ixgb_buffer *buffer_info)
L
Linus Torvalds 已提交
906
{
907 908
	if (buffer_info->dma) {
		if (buffer_info->mapped_as_page)
909 910
			dma_unmap_page(&adapter->pdev->dev, buffer_info->dma,
				       buffer_info->length, DMA_TO_DEVICE);
911
		else
912 913
			dma_unmap_single(&adapter->pdev->dev, buffer_info->dma,
					 buffer_info->length, DMA_TO_DEVICE);
914 915 916
		buffer_info->dma = 0;
	}

917 918 919 920
	if (buffer_info->skb) {
		dev_kfree_skb_any(buffer_info->skb);
		buffer_info->skb = NULL;
	}
921 922 923 924
	buffer_info->time_stamp = 0;
	/* these fields must always be initialized in tx
	 * buffer_info->length = 0;
	 * buffer_info->next_to_watch = 0; */
L
Linus Torvalds 已提交
925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941
}

/**
 * ixgb_clean_tx_ring - Free Tx Buffers
 * @adapter: board private structure
 **/

static void
ixgb_clean_tx_ring(struct ixgb_adapter *adapter)
{
	struct ixgb_desc_ring *tx_ring = &adapter->tx_ring;
	struct ixgb_buffer *buffer_info;
	unsigned long size;
	unsigned int i;

	/* Free all the Tx ring sk_buffs */

942
	for (i = 0; i < tx_ring->count; i++) {
L
Linus Torvalds 已提交
943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978
		buffer_info = &tx_ring->buffer_info[i];
		ixgb_unmap_and_free_tx_resource(adapter, buffer_info);
	}

	size = sizeof(struct ixgb_buffer) * tx_ring->count;
	memset(tx_ring->buffer_info, 0, size);

	/* Zero out the descriptor ring */

	memset(tx_ring->desc, 0, tx_ring->size);

	tx_ring->next_to_use = 0;
	tx_ring->next_to_clean = 0;

	IXGB_WRITE_REG(&adapter->hw, TDH, 0);
	IXGB_WRITE_REG(&adapter->hw, TDT, 0);
}

/**
 * ixgb_free_rx_resources - Free Rx Resources
 * @adapter: board private structure
 *
 * Free all receive software resources
 **/

void
ixgb_free_rx_resources(struct ixgb_adapter *adapter)
{
	struct ixgb_desc_ring *rx_ring = &adapter->rx_ring;
	struct pci_dev *pdev = adapter->pdev;

	ixgb_clean_rx_ring(adapter);

	vfree(rx_ring->buffer_info);
	rx_ring->buffer_info = NULL;

979 980
	dma_free_coherent(&pdev->dev, rx_ring->size, rx_ring->desc,
			  rx_ring->dma);
L
Linus Torvalds 已提交
981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000

	rx_ring->desc = NULL;
}

/**
 * ixgb_clean_rx_ring - Free Rx Buffers
 * @adapter: board private structure
 **/

static void
ixgb_clean_rx_ring(struct ixgb_adapter *adapter)
{
	struct ixgb_desc_ring *rx_ring = &adapter->rx_ring;
	struct ixgb_buffer *buffer_info;
	struct pci_dev *pdev = adapter->pdev;
	unsigned long size;
	unsigned int i;

	/* Free all the Rx ring sk_buffs */

1001
	for (i = 0; i < rx_ring->count; i++) {
L
Linus Torvalds 已提交
1002
		buffer_info = &rx_ring->buffer_info[i];
1003
		if (buffer_info->dma) {
1004
			dma_unmap_single(&pdev->dev,
L
Linus Torvalds 已提交
1005 1006
					 buffer_info->dma,
					 buffer_info->length,
1007
					 DMA_FROM_DEVICE);
1008 1009 1010
			buffer_info->dma = 0;
			buffer_info->length = 0;
		}
L
Linus Torvalds 已提交
1011

1012
		if (buffer_info->skb) {
L
Linus Torvalds 已提交
1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042
			dev_kfree_skb(buffer_info->skb);
			buffer_info->skb = NULL;
		}
	}

	size = sizeof(struct ixgb_buffer) * rx_ring->count;
	memset(rx_ring->buffer_info, 0, size);

	/* Zero out the descriptor ring */

	memset(rx_ring->desc, 0, rx_ring->size);

	rx_ring->next_to_clean = 0;
	rx_ring->next_to_use = 0;

	IXGB_WRITE_REG(&adapter->hw, RDH, 0);
	IXGB_WRITE_REG(&adapter->hw, RDT, 0);
}

/**
 * ixgb_set_mac - Change the Ethernet Address of the NIC
 * @netdev: network interface device structure
 * @p: pointer to an address structure
 *
 * Returns 0 on success, negative on failure
 **/

static int
ixgb_set_mac(struct net_device *netdev, void *p)
{
1043
	struct ixgb_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
1044 1045
	struct sockaddr *addr = p;

1046
	if (!is_valid_ether_addr(addr->sa_data))
L
Linus Torvalds 已提交
1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068
		return -EADDRNOTAVAIL;

	memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);

	ixgb_rar_set(&adapter->hw, addr->sa_data, 0);

	return 0;
}

/**
 * ixgb_set_multi - Multicast and Promiscuous mode set
 * @netdev: network interface device structure
 *
 * The set_multi entry point is called whenever the multicast address
 * list or the network interface flags are updated.  This routine is
 * responsible for configuring the hardware for proper multicast,
 * promiscuous mode, and all-multi behavior.
 **/

static void
ixgb_set_multi(struct net_device *netdev)
{
1069
	struct ixgb_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
1070
	struct ixgb_hw *hw = &adapter->hw;
1071
	struct netdev_hw_addr *ha;
1072
	u32 rctl;
L
Linus Torvalds 已提交
1073 1074 1075 1076 1077 1078
	int i;

	/* Check for Promiscuous and All Multicast modes */

	rctl = IXGB_READ_REG(hw, RCTL);

1079
	if (netdev->flags & IFF_PROMISC) {
L
Linus Torvalds 已提交
1080
		rctl |= (IXGB_RCTL_UPE | IXGB_RCTL_MPE);
1081
		rctl &= ~IXGB_RCTL_VFE;
L
Linus Torvalds 已提交
1082
	} else {
1083 1084 1085 1086 1087 1088
		if (netdev->flags & IFF_ALLMULTI) {
			rctl |= IXGB_RCTL_MPE;
			rctl &= ~IXGB_RCTL_UPE;
		} else {
			rctl &= ~(IXGB_RCTL_UPE | IXGB_RCTL_MPE);
		}
1089
		rctl |= IXGB_RCTL_VFE;
L
Linus Torvalds 已提交
1090 1091
	}

1092
	if (netdev_mc_count(netdev) > IXGB_MAX_NUM_MULTICAST_ADDRESSES) {
L
Linus Torvalds 已提交
1093 1094 1095
		rctl |= IXGB_RCTL_MPE;
		IXGB_WRITE_REG(hw, RCTL, rctl);
	} else {
1096
		u8 mta[IXGB_MAX_NUM_MULTICAST_ADDRESSES *
S
Stephen Hemminger 已提交
1097
			    IXGB_ETH_LENGTH_OF_ADDRESS];
L
Linus Torvalds 已提交
1098 1099 1100

		IXGB_WRITE_REG(hw, RCTL, rctl);

1101
		i = 0;
1102
		netdev_for_each_mc_addr(ha, netdev)
1103
			memcpy(&mta[i++ * IXGB_ETH_LENGTH_OF_ADDRESS],
1104
			       ha->addr, IXGB_ETH_LENGTH_OF_ADDRESS);
L
Linus Torvalds 已提交
1105

1106
		ixgb_mc_addr_list_update(hw, mta, netdev_mc_count(netdev), 0);
L
Linus Torvalds 已提交
1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128
	}
}

/**
 * ixgb_watchdog - Timer Call-back
 * @data: pointer to netdev cast into an unsigned long
 **/

static void
ixgb_watchdog(unsigned long data)
{
	struct ixgb_adapter *adapter = (struct ixgb_adapter *)data;
	struct net_device *netdev = adapter->netdev;
	struct ixgb_desc_ring *txdr = &adapter->tx_ring;

	ixgb_check_for_link(&adapter->hw);

	if (ixgb_check_for_bad_link(&adapter->hw)) {
		/* force the reset path */
		netif_stop_queue(netdev);
	}

1129 1130
	if (adapter->hw.link_up) {
		if (!netif_carrier_ok(netdev)) {
1131 1132 1133 1134 1135 1136 1137 1138
			netdev_info(netdev,
				    "NIC Link is Up 10 Gbps Full Duplex, Flow Control: %s\n",
				    (adapter->hw.fc.type == ixgb_fc_full) ?
				    "RX/TX" :
				    (adapter->hw.fc.type == ixgb_fc_rx_pause) ?
				     "RX" :
				    (adapter->hw.fc.type == ixgb_fc_tx_pause) ?
				    "TX" : "None");
L
Linus Torvalds 已提交
1139 1140 1141 1142 1143
			adapter->link_speed = 10000;
			adapter->link_duplex = FULL_DUPLEX;
			netif_carrier_on(netdev);
		}
	} else {
1144
		if (netif_carrier_ok(netdev)) {
L
Linus Torvalds 已提交
1145 1146
			adapter->link_speed = 0;
			adapter->link_duplex = 0;
1147
			netdev_info(netdev, "NIC Link is Down\n");
L
Linus Torvalds 已提交
1148 1149 1150 1151 1152 1153
			netif_carrier_off(netdev);
		}
	}

	ixgb_update_stats(adapter);

1154 1155
	if (!netif_carrier_ok(netdev)) {
		if (IXGB_DESC_UNUSED(txdr) + 1 < txdr->count) {
L
Linus Torvalds 已提交
1156 1157 1158 1159 1160
			/* We've lost link, so the controller stops DMA,
			 * but we've got queued Tx work that's never going
			 * to get done, so reset controller to flush Tx.
			 * (Do the reset outside of interrupt context). */
			schedule_work(&adapter->tx_timeout_task);
1161 1162
			/* return immediately since reset is imminent */
			return;
L
Linus Torvalds 已提交
1163 1164 1165 1166
		}
	}

	/* Force detection of hung controller every watchdog period */
J
Joe Perches 已提交
1167
	adapter->detect_tx_hung = true;
L
Linus Torvalds 已提交
1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179

	/* generate an interrupt to force clean up of any stragglers */
	IXGB_WRITE_REG(&adapter->hw, ICS, IXGB_INT_TXDW);

	/* Reset the timer */
	mod_timer(&adapter->watchdog_timer, jiffies + 2 * HZ);
}

#define IXGB_TX_FLAGS_CSUM		0x00000001
#define IXGB_TX_FLAGS_VLAN		0x00000002
#define IXGB_TX_FLAGS_TSO		0x00000004

1180
static int
L
Linus Torvalds 已提交
1181 1182 1183 1184
ixgb_tso(struct ixgb_adapter *adapter, struct sk_buff *skb)
{
	struct ixgb_context_desc *context_desc;
	unsigned int i;
1185 1186
	u8 ipcss, ipcso, tucss, tucso, hdr_len;
	u16 ipcse, tucse, mss;
L
Linus Torvalds 已提交
1187 1188
	int err;

H
Herbert Xu 已提交
1189
	if (likely(skb_is_gso(skb))) {
1190
		struct ixgb_buffer *buffer_info;
1191 1192
		struct iphdr *iph;

L
Linus Torvalds 已提交
1193 1194 1195 1196 1197 1198
		if (skb_header_cloned(skb)) {
			err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
			if (err)
				return err;
		}

1199
		hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
1200
		mss = skb_shinfo(skb)->gso_size;
1201 1202 1203
		iph = ip_hdr(skb);
		iph->tot_len = 0;
		iph->check = 0;
1204 1205 1206
		tcp_hdr(skb)->check = ~csum_tcpudp_magic(iph->saddr,
							 iph->daddr, 0,
							 IPPROTO_TCP, 0);
1207
		ipcss = skb_network_offset(skb);
1208
		ipcso = (void *)&(iph->check) - (void *)skb->data;
1209 1210
		ipcse = skb_transport_offset(skb) - 1;
		tucss = skb_transport_offset(skb);
1211
		tucso = (void *)&(tcp_hdr(skb)->check) - (void *)skb->data;
L
Linus Torvalds 已提交
1212 1213 1214 1215
		tucse = 0;

		i = adapter->tx_ring.next_to_use;
		context_desc = IXGB_CONTEXT_DESC(adapter->tx_ring, i);
1216 1217
		buffer_info = &adapter->tx_ring.buffer_info[i];
		WARN_ON(buffer_info->dma != 0);
L
Linus Torvalds 已提交
1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228

		context_desc->ipcss = ipcss;
		context_desc->ipcso = ipcso;
		context_desc->ipcse = cpu_to_le16(ipcse);
		context_desc->tucss = tucss;
		context_desc->tucso = tucso;
		context_desc->tucse = cpu_to_le16(tucse);
		context_desc->mss = cpu_to_le16(mss);
		context_desc->hdr_len = hdr_len;
		context_desc->status = 0;
		context_desc->cmd_type_len = cpu_to_le32(
J
Jesse Brandeburg 已提交
1229
						  IXGB_CONTEXT_DESC_TYPE
L
Linus Torvalds 已提交
1230 1231 1232 1233 1234 1235
						| IXGB_CONTEXT_DESC_CMD_TSE
						| IXGB_CONTEXT_DESC_CMD_IP
						| IXGB_CONTEXT_DESC_CMD_TCP
						| IXGB_CONTEXT_DESC_CMD_IDE
						| (skb->len - (hdr_len)));

1236

1237
		if (++i == adapter->tx_ring.count) i = 0;
L
Linus Torvalds 已提交
1238 1239 1240 1241 1242 1243 1244 1245
		adapter->tx_ring.next_to_use = i;

		return 1;
	}

	return 0;
}

J
Joe Perches 已提交
1246
static bool
L
Linus Torvalds 已提交
1247 1248 1249 1250
ixgb_tx_csum(struct ixgb_adapter *adapter, struct sk_buff *skb)
{
	struct ixgb_context_desc *context_desc;
	unsigned int i;
1251
	u8 css, cso;
L
Linus Torvalds 已提交
1252

1253
	if (likely(skb->ip_summed == CHECKSUM_PARTIAL)) {
1254
		struct ixgb_buffer *buffer_info;
1255
		css = skb_transport_offset(skb);
A
Al Viro 已提交
1256
		cso = css + skb->csum_offset;
L
Linus Torvalds 已提交
1257 1258 1259

		i = adapter->tx_ring.next_to_use;
		context_desc = IXGB_CONTEXT_DESC(adapter->tx_ring, i);
1260 1261
		buffer_info = &adapter->tx_ring.buffer_info[i];
		WARN_ON(buffer_info->dma != 0);
L
Linus Torvalds 已提交
1262 1263 1264 1265 1266

		context_desc->tucss = css;
		context_desc->tucso = cso;
		context_desc->tucse = 0;
		/* zero out any previously existing data in one instruction */
1267
		*(u32 *)&(context_desc->ipcss) = 0;
L
Linus Torvalds 已提交
1268 1269 1270 1271 1272
		context_desc->status = 0;
		context_desc->hdr_len = 0;
		context_desc->mss = 0;
		context_desc->cmd_type_len =
			cpu_to_le32(IXGB_CONTEXT_DESC_TYPE
1273
				    | IXGB_TX_DESC_CMD_IDE);
L
Linus Torvalds 已提交
1274

1275
		if (++i == adapter->tx_ring.count) i = 0;
L
Linus Torvalds 已提交
1276 1277
		adapter->tx_ring.next_to_use = i;

J
Joe Perches 已提交
1278
		return true;
L
Linus Torvalds 已提交
1279 1280
	}

J
Joe Perches 已提交
1281
	return false;
L
Linus Torvalds 已提交
1282 1283 1284 1285 1286
}

#define IXGB_MAX_TXD_PWR	14
#define IXGB_MAX_DATA_PER_TXD	(1<<IXGB_MAX_TXD_PWR)

1287
static int
L
Linus Torvalds 已提交
1288 1289 1290 1291
ixgb_tx_map(struct ixgb_adapter *adapter, struct sk_buff *skb,
	    unsigned int first)
{
	struct ixgb_desc_ring *tx_ring = &adapter->tx_ring;
1292
	struct pci_dev *pdev = adapter->pdev;
L
Linus Torvalds 已提交
1293
	struct ixgb_buffer *buffer_info;
1294
	int len = skb_headlen(skb);
L
Linus Torvalds 已提交
1295
	unsigned int offset = 0, size, count = 0, i;
1296
	unsigned int mss = skb_shinfo(skb)->gso_size;
L
Linus Torvalds 已提交
1297 1298 1299 1300 1301
	unsigned int nr_frags = skb_shinfo(skb)->nr_frags;
	unsigned int f;

	i = tx_ring->next_to_use;

1302
	while (len) {
L
Linus Torvalds 已提交
1303
		buffer_info = &tx_ring->buffer_info[i];
1304
		size = min(len, IXGB_MAX_DATA_PER_TXD);
1305 1306 1307 1308 1309
		/* Workaround for premature desc write-backs
		 * in TSO mode.  Append 4-byte sentinel desc */
		if (unlikely(mss && !nr_frags && size == len && size > 8))
			size -= 4;

L
Linus Torvalds 已提交
1310
		buffer_info->length = size;
1311
		WARN_ON(buffer_info->dma != 0);
1312
		buffer_info->time_stamp = jiffies;
1313
		buffer_info->mapped_as_page = false;
1314 1315 1316 1317
		buffer_info->dma = dma_map_single(&pdev->dev,
						  skb->data + offset,
						  size, DMA_TO_DEVICE);
		if (dma_mapping_error(&pdev->dev, buffer_info->dma))
1318
			goto dma_error;
1319
		buffer_info->next_to_watch = 0;
L
Linus Torvalds 已提交
1320 1321 1322 1323

		len -= size;
		offset += size;
		count++;
1324 1325 1326 1327 1328
		if (len) {
			i++;
			if (i == tx_ring->count)
				i = 0;
		}
L
Linus Torvalds 已提交
1329 1330
	}

1331
	for (f = 0; f < nr_frags; f++) {
L
Linus Torvalds 已提交
1332 1333 1334 1335
		struct skb_frag_struct *frag;

		frag = &skb_shinfo(skb)->frags[f];
		len = frag->size;
1336
		offset = frag->page_offset;
L
Linus Torvalds 已提交
1337

1338
		while (len) {
1339 1340 1341 1342
			i++;
			if (i == tx_ring->count)
				i = 0;

L
Linus Torvalds 已提交
1343
			buffer_info = &tx_ring->buffer_info[i];
1344
			size = min(len, IXGB_MAX_DATA_PER_TXD);
1345 1346 1347

			/* Workaround for premature desc write-backs
			 * in TSO mode.  Append 4-byte sentinel desc */
A
Auke Kok 已提交
1348 1349
			if (unlikely(mss && (f == (nr_frags - 1))
				     && size == len && size > 8))
1350 1351
				size -= 4;

L
Linus Torvalds 已提交
1352
			buffer_info->length = size;
1353
			buffer_info->time_stamp = jiffies;
1354 1355
			buffer_info->mapped_as_page = true;
			buffer_info->dma =
1356 1357 1358
				dma_map_page(&pdev->dev, frag->page,
					     offset, size, DMA_TO_DEVICE);
			if (dma_mapping_error(&pdev->dev, buffer_info->dma))
1359
				goto dma_error;
1360
			buffer_info->next_to_watch = 0;
L
Linus Torvalds 已提交
1361 1362 1363 1364 1365 1366 1367 1368 1369 1370

			len -= size;
			offset += size;
			count++;
		}
	}
	tx_ring->buffer_info[i].skb = skb;
	tx_ring->buffer_info[first].next_to_watch = i;

	return count;
1371 1372 1373 1374

dma_error:
	dev_err(&pdev->dev, "TX DMA map failed\n");
	buffer_info->dma = 0;
1375
	if (count)
1376
		count--;
1377 1378 1379

	while (count--) {
		if (i==0)
1380
			i += tx_ring->count;
1381
		i--;
1382 1383 1384 1385 1386
		buffer_info = &tx_ring->buffer_info[i];
		ixgb_unmap_and_free_tx_resource(adapter, buffer_info);
	}

	return 0;
L
Linus Torvalds 已提交
1387 1388
}

1389
static void
L
Linus Torvalds 已提交
1390 1391 1392 1393 1394
ixgb_tx_queue(struct ixgb_adapter *adapter, int count, int vlan_id,int tx_flags)
{
	struct ixgb_desc_ring *tx_ring = &adapter->tx_ring;
	struct ixgb_tx_desc *tx_desc = NULL;
	struct ixgb_buffer *buffer_info;
1395 1396 1397
	u32 cmd_type_len = adapter->tx_cmd_type;
	u8 status = 0;
	u8 popts = 0;
L
Linus Torvalds 已提交
1398 1399
	unsigned int i;

1400
	if (tx_flags & IXGB_TX_FLAGS_TSO) {
L
Linus Torvalds 已提交
1401 1402 1403 1404
		cmd_type_len |= IXGB_TX_DESC_CMD_TSE;
		popts |= (IXGB_TX_DESC_POPTS_IXSM | IXGB_TX_DESC_POPTS_TXSM);
	}

1405
	if (tx_flags & IXGB_TX_FLAGS_CSUM)
L
Linus Torvalds 已提交
1406 1407
		popts |= IXGB_TX_DESC_POPTS_TXSM;

1408
	if (tx_flags & IXGB_TX_FLAGS_VLAN)
L
Linus Torvalds 已提交
1409 1410 1411 1412
		cmd_type_len |= IXGB_TX_DESC_CMD_VLE;

	i = tx_ring->next_to_use;

1413
	while (count--) {
L
Linus Torvalds 已提交
1414 1415 1416 1417 1418 1419 1420 1421 1422
		buffer_info = &tx_ring->buffer_info[i];
		tx_desc = IXGB_TX_DESC(*tx_ring, i);
		tx_desc->buff_addr = cpu_to_le64(buffer_info->dma);
		tx_desc->cmd_type_len =
			cpu_to_le32(cmd_type_len | buffer_info->length);
		tx_desc->status = status;
		tx_desc->popts = popts;
		tx_desc->vlan = cpu_to_le16(vlan_id);

1423
		if (++i == tx_ring->count) i = 0;
L
Linus Torvalds 已提交
1424 1425
	}

J
Jesse Brandeburg 已提交
1426 1427
	tx_desc->cmd_type_len |=
		cpu_to_le32(IXGB_TX_DESC_CMD_EOP | IXGB_TX_DESC_CMD_RS);
L
Linus Torvalds 已提交
1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438

	/* Force memory writes to complete before letting h/w
	 * know there are new descriptors to fetch.  (Only
	 * applicable for weak-ordered memory model archs,
	 * such as IA-64). */
	wmb();

	tx_ring->next_to_use = i;
	IXGB_WRITE_REG(&adapter->hw, TDT, i);
}

1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469
static int __ixgb_maybe_stop_tx(struct net_device *netdev, int size)
{
	struct ixgb_adapter *adapter = netdev_priv(netdev);
	struct ixgb_desc_ring *tx_ring = &adapter->tx_ring;

	netif_stop_queue(netdev);
	/* Herbert's original patch had:
	 *  smp_mb__after_netif_stop_queue();
	 * but since that doesn't exist yet, just open code it. */
	smp_mb();

	/* We need to check again in a case another CPU has just
	 * made room available. */
	if (likely(IXGB_DESC_UNUSED(tx_ring) < size))
		return -EBUSY;

	/* A reprieve! */
	netif_start_queue(netdev);
	++adapter->restart_queue;
	return 0;
}

static int ixgb_maybe_stop_tx(struct net_device *netdev,
                              struct ixgb_desc_ring *tx_ring, int size)
{
	if (likely(IXGB_DESC_UNUSED(tx_ring) >= size))
		return 0;
	return __ixgb_maybe_stop_tx(netdev, size);
}


L
Linus Torvalds 已提交
1470 1471 1472
/* Tx Descriptors needed, worst case */
#define TXD_USE_COUNT(S) (((S) >> IXGB_MAX_TXD_PWR) + \
			 (((S) & (IXGB_MAX_DATA_PER_TXD - 1)) ? 1 : 0))
1473 1474 1475
#define DESC_NEEDED TXD_USE_COUNT(IXGB_MAX_DATA_PER_TXD) /* skb->date */ + \
	MAX_SKB_FRAGS * TXD_USE_COUNT(PAGE_SIZE) + 1 /* for context */ \
	+ 1 /* one more needed for sentinel TSO workaround */
L
Linus Torvalds 已提交
1476

1477
static netdev_tx_t
L
Linus Torvalds 已提交
1478 1479
ixgb_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
{
1480
	struct ixgb_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
1481 1482 1483
	unsigned int first;
	unsigned int tx_flags = 0;
	int vlan_id = 0;
1484
	int count = 0;
L
Linus Torvalds 已提交
1485 1486
	int tso;

1487 1488 1489 1490 1491
	if (test_bit(__IXGB_DOWN, &adapter->flags)) {
		dev_kfree_skb(skb);
		return NETDEV_TX_OK;
	}

1492
	if (skb->len <= 0) {
1493
		dev_kfree_skb(skb);
1494
		return NETDEV_TX_OK;
L
Linus Torvalds 已提交
1495 1496
	}

1497
	if (unlikely(ixgb_maybe_stop_tx(netdev, &adapter->tx_ring,
1498
                     DESC_NEEDED)))
1499
		return NETDEV_TX_BUSY;
L
Linus Torvalds 已提交
1500

1501
	if (adapter->vlgrp && vlan_tx_tag_present(skb)) {
L
Linus Torvalds 已提交
1502 1503 1504 1505 1506
		tx_flags |= IXGB_TX_FLAGS_VLAN;
		vlan_id = vlan_tx_tag_get(skb);
	}

	first = adapter->tx_ring.next_to_use;
J
Jesse Brandeburg 已提交
1507

L
Linus Torvalds 已提交
1508 1509
	tso = ixgb_tso(adapter, skb);
	if (tso < 0) {
1510
		dev_kfree_skb(skb);
L
Linus Torvalds 已提交
1511 1512 1513
		return NETDEV_TX_OK;
	}

A
Auke Kok 已提交
1514
	if (likely(tso))
L
Linus Torvalds 已提交
1515
		tx_flags |= IXGB_TX_FLAGS_TSO;
1516
	else if (ixgb_tx_csum(adapter, skb))
L
Linus Torvalds 已提交
1517 1518
		tx_flags |= IXGB_TX_FLAGS_CSUM;

1519
	count = ixgb_tx_map(adapter, skb, first);
L
Linus Torvalds 已提交
1520

1521 1522 1523 1524
	if (count) {
		ixgb_tx_queue(adapter, count, vlan_id, tx_flags);
		/* Make sure there is space in the ring for the next send. */
		ixgb_maybe_stop_tx(netdev, &adapter->tx_ring, DESC_NEEDED);
L
Linus Torvalds 已提交
1525

1526 1527 1528 1529 1530
	} else {
		dev_kfree_skb_any(skb);
		adapter->tx_ring.buffer_info[first].time_stamp = 0;
		adapter->tx_ring.next_to_use = first;
	}
1531 1532

	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
1533 1534 1535 1536 1537 1538 1539 1540 1541 1542
}

/**
 * ixgb_tx_timeout - Respond to a Tx Hang
 * @netdev: network interface device structure
 **/

static void
ixgb_tx_timeout(struct net_device *netdev)
{
1543
	struct ixgb_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
1544 1545 1546 1547 1548 1549

	/* Do the reset outside of interrupt context */
	schedule_work(&adapter->tx_timeout_task);
}

static void
D
David Howells 已提交
1550
ixgb_tx_timeout_task(struct work_struct *work)
L
Linus Torvalds 已提交
1551
{
D
David Howells 已提交
1552 1553
	struct ixgb_adapter *adapter =
		container_of(work, struct ixgb_adapter, tx_timeout_task);
L
Linus Torvalds 已提交
1554

A
Auke Kok 已提交
1555
	adapter->tx_timeout_count++;
J
Joe Perches 已提交
1556
	ixgb_down(adapter, true);
L
Linus Torvalds 已提交
1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570
	ixgb_up(adapter);
}

/**
 * ixgb_get_stats - Get System Network Statistics
 * @netdev: network interface device structure
 *
 * Returns the address of the device statistics structure.
 * The statistics are actually updated from the timer callback.
 **/

static struct net_device_stats *
ixgb_get_stats(struct net_device *netdev)
{
1571
	return &netdev->stats;
L
Linus Torvalds 已提交
1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584
}

/**
 * ixgb_change_mtu - Change the Maximum Transfer Unit
 * @netdev: network interface device structure
 * @new_mtu: new value for maximum frame size
 *
 * Returns 0 on success, negative on failure
 **/

static int
ixgb_change_mtu(struct net_device *netdev, int new_mtu)
{
1585
	struct ixgb_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
1586 1587 1588
	int max_frame = new_mtu + ENET_HEADER_SIZE + ENET_FCS_LENGTH;
	int old_max_frame = netdev->mtu + ENET_HEADER_SIZE + ENET_FCS_LENGTH;

1589 1590 1591
	/* MTU < 68 is an error for IPv4 traffic, just don't allow it */
	if ((new_mtu < 68) ||
	    (max_frame > IXGB_MAX_JUMBO_FRAME_SIZE + ENET_FCS_LENGTH)) {
1592 1593
		netif_err(adapter, probe, adapter->netdev,
			  "Invalid MTU setting %d\n", new_mtu);
L
Linus Torvalds 已提交
1594 1595 1596
		return -EINVAL;
	}

1597 1598 1599 1600 1601 1602
	if (old_max_frame == max_frame)
		return 0;

	if (netif_running(netdev))
		ixgb_down(adapter, true);

1603
	adapter->rx_buffer_len = max_frame + 8; /* + 8 for errata */
L
Linus Torvalds 已提交
1604 1605 1606

	netdev->mtu = new_mtu;

1607
	if (netif_running(netdev))
L
Linus Torvalds 已提交
1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620
		ixgb_up(adapter);

	return 0;
}

/**
 * ixgb_update_stats - Update the board statistics counters.
 * @adapter: board private structure
 **/

void
ixgb_update_stats(struct ixgb_adapter *adapter)
{
1621
	struct net_device *netdev = adapter->netdev;
1622 1623 1624
	struct pci_dev *pdev = adapter->pdev;

	/* Prevent stats update while adapter is being reset */
1625
	if (pci_channel_offline(pdev))
1626
		return;
1627

1628
	if ((netdev->flags & IFF_PROMISC) || (netdev->flags & IFF_ALLMULTI) ||
1629
	   (netdev_mc_count(netdev) > IXGB_MAX_NUM_MULTICAST_ADDRESSES)) {
1630 1631 1632
		u64 multi = IXGB_READ_REG(&adapter->hw, MPRCL);
		u32 bcast_l = IXGB_READ_REG(&adapter->hw, BPRCL);
		u32 bcast_h = IXGB_READ_REG(&adapter->hw, BPRCH);
J
Jesse Brandeburg 已提交
1633
		u64 bcast = ((u64)bcast_h << 32) | bcast_l;
1634 1635 1636

		multi |= ((u64)IXGB_READ_REG(&adapter->hw, MPRCH) << 32);
		/* fix up multicast stats by removing broadcasts */
1637
		if (multi >= bcast)
1638
			multi -= bcast;
J
Jesse Brandeburg 已提交
1639

1640 1641
		adapter->stats.mprcl += (multi & 0xFFFFFFFF);
		adapter->stats.mprch += (multi >> 32);
J
Jesse Brandeburg 已提交
1642
		adapter->stats.bprcl += bcast_l;
1643 1644 1645 1646 1647 1648 1649
		adapter->stats.bprch += bcast_h;
	} else {
		adapter->stats.mprcl += IXGB_READ_REG(&adapter->hw, MPRCL);
		adapter->stats.mprch += IXGB_READ_REG(&adapter->hw, MPRCH);
		adapter->stats.bprcl += IXGB_READ_REG(&adapter->hw, BPRCL);
		adapter->stats.bprch += IXGB_READ_REG(&adapter->hw, BPRCH);
	}
L
Linus Torvalds 已提交
1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708
	adapter->stats.tprl += IXGB_READ_REG(&adapter->hw, TPRL);
	adapter->stats.tprh += IXGB_READ_REG(&adapter->hw, TPRH);
	adapter->stats.gprcl += IXGB_READ_REG(&adapter->hw, GPRCL);
	adapter->stats.gprch += IXGB_READ_REG(&adapter->hw, GPRCH);
	adapter->stats.uprcl += IXGB_READ_REG(&adapter->hw, UPRCL);
	adapter->stats.uprch += IXGB_READ_REG(&adapter->hw, UPRCH);
	adapter->stats.vprcl += IXGB_READ_REG(&adapter->hw, VPRCL);
	adapter->stats.vprch += IXGB_READ_REG(&adapter->hw, VPRCH);
	adapter->stats.jprcl += IXGB_READ_REG(&adapter->hw, JPRCL);
	adapter->stats.jprch += IXGB_READ_REG(&adapter->hw, JPRCH);
	adapter->stats.gorcl += IXGB_READ_REG(&adapter->hw, GORCL);
	adapter->stats.gorch += IXGB_READ_REG(&adapter->hw, GORCH);
	adapter->stats.torl += IXGB_READ_REG(&adapter->hw, TORL);
	adapter->stats.torh += IXGB_READ_REG(&adapter->hw, TORH);
	adapter->stats.rnbc += IXGB_READ_REG(&adapter->hw, RNBC);
	adapter->stats.ruc += IXGB_READ_REG(&adapter->hw, RUC);
	adapter->stats.roc += IXGB_READ_REG(&adapter->hw, ROC);
	adapter->stats.rlec += IXGB_READ_REG(&adapter->hw, RLEC);
	adapter->stats.crcerrs += IXGB_READ_REG(&adapter->hw, CRCERRS);
	adapter->stats.icbc += IXGB_READ_REG(&adapter->hw, ICBC);
	adapter->stats.ecbc += IXGB_READ_REG(&adapter->hw, ECBC);
	adapter->stats.mpc += IXGB_READ_REG(&adapter->hw, MPC);
	adapter->stats.tptl += IXGB_READ_REG(&adapter->hw, TPTL);
	adapter->stats.tpth += IXGB_READ_REG(&adapter->hw, TPTH);
	adapter->stats.gptcl += IXGB_READ_REG(&adapter->hw, GPTCL);
	adapter->stats.gptch += IXGB_READ_REG(&adapter->hw, GPTCH);
	adapter->stats.bptcl += IXGB_READ_REG(&adapter->hw, BPTCL);
	adapter->stats.bptch += IXGB_READ_REG(&adapter->hw, BPTCH);
	adapter->stats.mptcl += IXGB_READ_REG(&adapter->hw, MPTCL);
	adapter->stats.mptch += IXGB_READ_REG(&adapter->hw, MPTCH);
	adapter->stats.uptcl += IXGB_READ_REG(&adapter->hw, UPTCL);
	adapter->stats.uptch += IXGB_READ_REG(&adapter->hw, UPTCH);
	adapter->stats.vptcl += IXGB_READ_REG(&adapter->hw, VPTCL);
	adapter->stats.vptch += IXGB_READ_REG(&adapter->hw, VPTCH);
	adapter->stats.jptcl += IXGB_READ_REG(&adapter->hw, JPTCL);
	adapter->stats.jptch += IXGB_READ_REG(&adapter->hw, JPTCH);
	adapter->stats.gotcl += IXGB_READ_REG(&adapter->hw, GOTCL);
	adapter->stats.gotch += IXGB_READ_REG(&adapter->hw, GOTCH);
	adapter->stats.totl += IXGB_READ_REG(&adapter->hw, TOTL);
	adapter->stats.toth += IXGB_READ_REG(&adapter->hw, TOTH);
	adapter->stats.dc += IXGB_READ_REG(&adapter->hw, DC);
	adapter->stats.plt64c += IXGB_READ_REG(&adapter->hw, PLT64C);
	adapter->stats.tsctc += IXGB_READ_REG(&adapter->hw, TSCTC);
	adapter->stats.tsctfc += IXGB_READ_REG(&adapter->hw, TSCTFC);
	adapter->stats.ibic += IXGB_READ_REG(&adapter->hw, IBIC);
	adapter->stats.rfc += IXGB_READ_REG(&adapter->hw, RFC);
	adapter->stats.lfc += IXGB_READ_REG(&adapter->hw, LFC);
	adapter->stats.pfrc += IXGB_READ_REG(&adapter->hw, PFRC);
	adapter->stats.pftc += IXGB_READ_REG(&adapter->hw, PFTC);
	adapter->stats.mcfrc += IXGB_READ_REG(&adapter->hw, MCFRC);
	adapter->stats.mcftc += IXGB_READ_REG(&adapter->hw, MCFTC);
	adapter->stats.xonrxc += IXGB_READ_REG(&adapter->hw, XONRXC);
	adapter->stats.xontxc += IXGB_READ_REG(&adapter->hw, XONTXC);
	adapter->stats.xoffrxc += IXGB_READ_REG(&adapter->hw, XOFFRXC);
	adapter->stats.xofftxc += IXGB_READ_REG(&adapter->hw, XOFFTXC);
	adapter->stats.rjc += IXGB_READ_REG(&adapter->hw, RJC);

	/* Fill out the OS statistics structure */

1709 1710 1711 1712 1713 1714
	netdev->stats.rx_packets = adapter->stats.gprcl;
	netdev->stats.tx_packets = adapter->stats.gptcl;
	netdev->stats.rx_bytes = adapter->stats.gorcl;
	netdev->stats.tx_bytes = adapter->stats.gotcl;
	netdev->stats.multicast = adapter->stats.mprcl;
	netdev->stats.collisions = 0;
L
Linus Torvalds 已提交
1715 1716 1717

	/* ignore RLEC as it reports errors for padded (<64bytes) frames
	 * with a length in the type/len field */
1718
	netdev->stats.rx_errors =
L
Linus Torvalds 已提交
1719 1720 1721 1722 1723 1724 1725
	    /* adapter->stats.rnbc + */ adapter->stats.crcerrs +
	    adapter->stats.ruc +
	    adapter->stats.roc /*+ adapter->stats.rlec */  +
	    adapter->stats.icbc +
	    adapter->stats.ecbc + adapter->stats.mpc;

	/* see above
1726
	 * netdev->stats.rx_length_errors = adapter->stats.rlec;
L
Linus Torvalds 已提交
1727 1728
	 */

1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740
	netdev->stats.rx_crc_errors = adapter->stats.crcerrs;
	netdev->stats.rx_fifo_errors = adapter->stats.mpc;
	netdev->stats.rx_missed_errors = adapter->stats.mpc;
	netdev->stats.rx_over_errors = adapter->stats.mpc;

	netdev->stats.tx_errors = 0;
	netdev->stats.rx_frame_errors = 0;
	netdev->stats.tx_aborted_errors = 0;
	netdev->stats.tx_carrier_errors = 0;
	netdev->stats.tx_fifo_errors = 0;
	netdev->stats.tx_heartbeat_errors = 0;
	netdev->stats.tx_window_errors = 0;
L
Linus Torvalds 已提交
1741 1742 1743 1744 1745 1746 1747 1748 1749 1750
}

#define IXGB_MAX_INTR 10
/**
 * ixgb_intr - Interrupt Handler
 * @irq: interrupt number
 * @data: pointer to a network interface device structure
 **/

static irqreturn_t
1751
ixgb_intr(int irq, void *data)
L
Linus Torvalds 已提交
1752 1753
{
	struct net_device *netdev = data;
1754
	struct ixgb_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
1755
	struct ixgb_hw *hw = &adapter->hw;
1756
	u32 icr = IXGB_READ_REG(hw, ICR);
L
Linus Torvalds 已提交
1757

1758
	if (unlikely(!icr))
L
Linus Torvalds 已提交
1759 1760
		return IRQ_NONE;  /* Not our interrupt */

1761 1762 1763
	if (unlikely(icr & (IXGB_INT_RXSEQ | IXGB_INT_LSC)))
		if (!test_bit(__IXGB_DOWN, &adapter->flags))
			mod_timer(&adapter->watchdog_timer, jiffies);
L
Linus Torvalds 已提交
1764

1765
	if (napi_schedule_prep(&adapter->napi)) {
L
Linus Torvalds 已提交
1766

J
Jesse Brandeburg 已提交
1767
		/* Disable interrupts and register for poll. The flush
L
Linus Torvalds 已提交
1768 1769 1770 1771
		  of the posted write is intentionally left out.
		*/

		IXGB_WRITE_REG(&adapter->hw, IMC, ~0);
1772
		__napi_schedule(&adapter->napi);
L
Linus Torvalds 已提交
1773 1774 1775 1776 1777 1778 1779 1780 1781 1782
	}
	return IRQ_HANDLED;
}

/**
 * ixgb_clean - NAPI Rx polling callback
 * @adapter: board private structure
 **/

static int
1783
ixgb_clean(struct napi_struct *napi, int budget)
L
Linus Torvalds 已提交
1784
{
1785
	struct ixgb_adapter *adapter = container_of(napi, struct ixgb_adapter, napi);
L
Linus Torvalds 已提交
1786 1787
	int work_done = 0;

1788
	ixgb_clean_tx_irq(adapter);
1789
	ixgb_clean_rx_irq(adapter, &work_done, budget);
L
Linus Torvalds 已提交
1790

1791 1792
	/* If budget not fully consumed, exit the polling mode */
	if (work_done < budget) {
1793
		napi_complete(napi);
1794 1795
		if (!test_bit(__IXGB_DOWN, &adapter->flags))
			ixgb_irq_enable(adapter);
L
Linus Torvalds 已提交
1796 1797
	}

1798
	return work_done;
L
Linus Torvalds 已提交
1799 1800 1801 1802 1803 1804 1805
}

/**
 * ixgb_clean_tx_irq - Reclaim resources after transmit completes
 * @adapter: board private structure
 **/

J
Joe Perches 已提交
1806
static bool
L
Linus Torvalds 已提交
1807 1808 1809 1810 1811 1812 1813
ixgb_clean_tx_irq(struct ixgb_adapter *adapter)
{
	struct ixgb_desc_ring *tx_ring = &adapter->tx_ring;
	struct net_device *netdev = adapter->netdev;
	struct ixgb_tx_desc *tx_desc, *eop_desc;
	struct ixgb_buffer *buffer_info;
	unsigned int i, eop;
J
Joe Perches 已提交
1814
	bool cleaned = false;
L
Linus Torvalds 已提交
1815 1816 1817 1818 1819

	i = tx_ring->next_to_clean;
	eop = tx_ring->buffer_info[i].next_to_watch;
	eop_desc = IXGB_TX_DESC(*tx_ring, eop);

1820
	while (eop_desc->status & IXGB_TX_DESC_STATUS_DD) {
L
Linus Torvalds 已提交
1821

1822
		rmb(); /* read buffer_info after eop_desc */
J
Joe Perches 已提交
1823
		for (cleaned = false; !cleaned; ) {
L
Linus Torvalds 已提交
1824 1825 1826
			tx_desc = IXGB_TX_DESC(*tx_ring, i);
			buffer_info = &tx_ring->buffer_info[i];

J
Jesse Brandeburg 已提交
1827 1828 1829
			if (tx_desc->popts &
			   (IXGB_TX_DESC_POPTS_TXSM |
			    IXGB_TX_DESC_POPTS_IXSM))
L
Linus Torvalds 已提交
1830 1831 1832 1833
				adapter->hw_csum_tx_good++;

			ixgb_unmap_and_free_tx_resource(adapter, buffer_info);

1834
			*(u32 *)&(tx_desc->status) = 0;
L
Linus Torvalds 已提交
1835 1836

			cleaned = (i == eop);
1837
			if (++i == tx_ring->count) i = 0;
L
Linus Torvalds 已提交
1838 1839 1840 1841 1842 1843 1844 1845
		}

		eop = tx_ring->buffer_info[i].next_to_watch;
		eop_desc = IXGB_TX_DESC(*tx_ring, eop);
	}

	tx_ring->next_to_clean = i;

1846 1847 1848 1849 1850 1851 1852 1853
	if (unlikely(cleaned && netif_carrier_ok(netdev) &&
		     IXGB_DESC_UNUSED(tx_ring) >= DESC_NEEDED)) {
		/* Make sure that anybody stopping the queue after this
		 * sees the new next_to_clean. */
		smp_mb();

		if (netif_queue_stopped(netdev) &&
		    !(test_bit(__IXGB_DOWN, &adapter->flags))) {
1854
			netif_wake_queue(netdev);
1855 1856
			++adapter->restart_queue;
		}
L
Linus Torvalds 已提交
1857 1858
	}

1859
	if (adapter->detect_tx_hung) {
L
Linus Torvalds 已提交
1860 1861
		/* detect a transmit hang in hardware, this serializes the
		 * check with the clearing of time_stamp and movement of i */
J
Joe Perches 已提交
1862
		adapter->detect_tx_hung = false;
1863
		if (tx_ring->buffer_info[eop].time_stamp &&
A
Auke Kok 已提交
1864
		   time_after(jiffies, tx_ring->buffer_info[eop].time_stamp + HZ)
L
Linus Torvalds 已提交
1865
		   && !(IXGB_READ_REG(&adapter->hw, STATUS) &
A
Auke Kok 已提交
1866 1867
		        IXGB_STATUS_TXOFF)) {
			/* detected Tx unit hang */
1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886
			netif_err(adapter, drv, adapter->netdev,
				  "Detected Tx Unit Hang\n"
				  "  TDH                  <%x>\n"
				  "  TDT                  <%x>\n"
				  "  next_to_use          <%x>\n"
				  "  next_to_clean        <%x>\n"
				  "buffer_info[next_to_clean]\n"
				  "  time_stamp           <%lx>\n"
				  "  next_to_watch        <%x>\n"
				  "  jiffies              <%lx>\n"
				  "  next_to_watch.status <%x>\n",
				  IXGB_READ_REG(&adapter->hw, TDH),
				  IXGB_READ_REG(&adapter->hw, TDT),
				  tx_ring->next_to_use,
				  tx_ring->next_to_clean,
				  tx_ring->buffer_info[eop].time_stamp,
				  eop,
				  jiffies,
				  eop_desc->status);
L
Linus Torvalds 已提交
1887
			netif_stop_queue(netdev);
A
Auke Kok 已提交
1888
		}
L
Linus Torvalds 已提交
1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900
	}

	return cleaned;
}

/**
 * ixgb_rx_checksum - Receive Checksum Offload for 82597.
 * @adapter: board private structure
 * @rx_desc: receive descriptor
 * @sk_buff: socket buffer with received data
 **/

1901
static void
L
Linus Torvalds 已提交
1902
ixgb_rx_checksum(struct ixgb_adapter *adapter,
J
Jesse Brandeburg 已提交
1903 1904
                 struct ixgb_rx_desc *rx_desc,
                 struct sk_buff *skb)
L
Linus Torvalds 已提交
1905 1906 1907 1908
{
	/* Ignore Checksum bit is set OR
	 * TCP Checksum has not been calculated
	 */
1909
	if ((rx_desc->status & IXGB_RX_DESC_STATUS_IXSM) ||
L
Linus Torvalds 已提交
1910
	   (!(rx_desc->status & IXGB_RX_DESC_STATUS_TCPCS))) {
1911
		skb_checksum_none_assert(skb);
L
Linus Torvalds 已提交
1912 1913 1914 1915 1916
		return;
	}

	/* At this point we know the hardware did the TCP checksum */
	/* now look at the TCP checksum error bit */
1917
	if (rx_desc->errors & IXGB_RX_DESC_ERRORS_TCPE) {
L
Linus Torvalds 已提交
1918
		/* let the stack verify checksum errors */
1919
		skb_checksum_none_assert(skb);
L
Linus Torvalds 已提交
1920 1921 1922 1923 1924 1925 1926 1927
		adapter->hw_csum_rx_error++;
	} else {
		/* TCP checksum is good */
		skb->ip_summed = CHECKSUM_UNNECESSARY;
		adapter->hw_csum_rx_good++;
	}
}

1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952
/*
 * this should improve performance for small packets with large amounts
 * of reassembly being done in the stack
 */
static void ixgb_check_copybreak(struct net_device *netdev,
				 struct ixgb_buffer *buffer_info,
				 u32 length, struct sk_buff **skb)
{
	struct sk_buff *new_skb;

	if (length > copybreak)
		return;

	new_skb = netdev_alloc_skb_ip_align(netdev, length);
	if (!new_skb)
		return;

	skb_copy_to_linear_data_offset(new_skb, -NET_IP_ALIGN,
				       (*skb)->data - NET_IP_ALIGN,
				       length + NET_IP_ALIGN);
	/* save the skb in buffer_info as good */
	buffer_info->skb = *skb;
	*skb = new_skb;
}

L
Linus Torvalds 已提交
1953 1954 1955 1956 1957
/**
 * ixgb_clean_rx_irq - Send received data up the network stack,
 * @adapter: board private structure
 **/

J
Joe Perches 已提交
1958
static bool
L
Linus Torvalds 已提交
1959 1960 1961 1962 1963 1964 1965
ixgb_clean_rx_irq(struct ixgb_adapter *adapter, int *work_done, int work_to_do)
{
	struct ixgb_desc_ring *rx_ring = &adapter->rx_ring;
	struct net_device *netdev = adapter->netdev;
	struct pci_dev *pdev = adapter->pdev;
	struct ixgb_rx_desc *rx_desc, *next_rxd;
	struct ixgb_buffer *buffer_info, *next_buffer, *next2_buffer;
1966
	u32 length;
L
Linus Torvalds 已提交
1967
	unsigned int i, j;
1968
	int cleaned_count = 0;
J
Joe Perches 已提交
1969
	bool cleaned = false;
L
Linus Torvalds 已提交
1970 1971 1972 1973 1974

	i = rx_ring->next_to_clean;
	rx_desc = IXGB_RX_DESC(*rx_ring, i);
	buffer_info = &rx_ring->buffer_info[i];

1975
	while (rx_desc->status & IXGB_RX_DESC_STATUS_DD) {
1976
		struct sk_buff *skb;
1977
		u8 status;
L
Linus Torvalds 已提交
1978

1979
		if (*work_done >= work_to_do)
L
Linus Torvalds 已提交
1980 1981 1982
			break;

		(*work_done)++;
1983
		rmb();	/* read descriptor and rx_buffer_info after status DD */
1984
		status = rx_desc->status;
L
Linus Torvalds 已提交
1985
		skb = buffer_info->skb;
1986
		buffer_info->skb = NULL;
1987

1988
		prefetch(skb->data - NET_IP_ALIGN);
L
Linus Torvalds 已提交
1989

1990 1991
		if (++i == rx_ring->count)
			i = 0;
L
Linus Torvalds 已提交
1992 1993 1994
		next_rxd = IXGB_RX_DESC(*rx_ring, i);
		prefetch(next_rxd);

1995 1996 1997
		j = i + 1;
		if (j == rx_ring->count)
			j = 0;
L
Linus Torvalds 已提交
1998 1999 2000 2001 2002
		next2_buffer = &rx_ring->buffer_info[j];
		prefetch(next2_buffer);

		next_buffer = &rx_ring->buffer_info[i];

J
Joe Perches 已提交
2003
		cleaned = true;
2004
		cleaned_count++;
L
Linus Torvalds 已提交
2005

2006
		dma_unmap_single(&pdev->dev,
L
Linus Torvalds 已提交
2007 2008
				 buffer_info->dma,
				 buffer_info->length,
2009
				 DMA_FROM_DEVICE);
2010
		buffer_info->dma = 0;
L
Linus Torvalds 已提交
2011 2012

		length = le16_to_cpu(rx_desc->length);
2013
		rx_desc->length = 0;
L
Linus Torvalds 已提交
2014

2015
		if (unlikely(!(status & IXGB_RX_DESC_STATUS_EOP))) {
L
Linus Torvalds 已提交
2016 2017 2018 2019 2020 2021 2022

			/* All receives must fit into a single buffer */

			IXGB_DBG("Receive packet consumed multiple buffers "
					 "length<%x>\n", length);

			dev_kfree_skb_irq(skb);
2023
			goto rxdesc_done;
L
Linus Torvalds 已提交
2024 2025
		}

J
Jesse Brandeburg 已提交
2026 2027 2028
		if (unlikely(rx_desc->errors &
		    (IXGB_RX_DESC_ERRORS_CE | IXGB_RX_DESC_ERRORS_SE |
		     IXGB_RX_DESC_ERRORS_P | IXGB_RX_DESC_ERRORS_RXE))) {
L
Linus Torvalds 已提交
2029
			dev_kfree_skb_irq(skb);
2030
			goto rxdesc_done;
L
Linus Torvalds 已提交
2031 2032
		}

2033
		ixgb_check_copybreak(netdev, buffer_info, length, &skb);
A
Auke Kok 已提交
2034

L
Linus Torvalds 已提交
2035 2036 2037 2038 2039 2040 2041
		/* Good Receive */
		skb_put(skb, length);

		/* Receive Checksum Offload */
		ixgb_rx_checksum(adapter, rx_desc, skb);

		skb->protocol = eth_type_trans(skb, netdev);
2042
		if (adapter->vlgrp && (status & IXGB_RX_DESC_STATUS_VP)) {
L
Linus Torvalds 已提交
2043
			vlan_hwaccel_receive_skb(skb, adapter->vlgrp,
J
Jesse Brandeburg 已提交
2044
			                        le16_to_cpu(rx_desc->special));
L
Linus Torvalds 已提交
2045 2046 2047 2048
		} else {
			netif_receive_skb(skb);
		}

2049 2050
rxdesc_done:
		/* clean up descriptor, might be written over by hw */
L
Linus Torvalds 已提交
2051 2052
		rx_desc->status = 0;

2053 2054 2055 2056 2057 2058
		/* return some buffers to hardware, one at a time is too slow */
		if (unlikely(cleaned_count >= IXGB_RX_BUFFER_WRITE)) {
			ixgb_alloc_rx_buffers(adapter, cleaned_count);
			cleaned_count = 0;
		}

2059
		/* use prefetched values */
L
Linus Torvalds 已提交
2060 2061 2062 2063 2064 2065
		rx_desc = next_rxd;
		buffer_info = next_buffer;
	}

	rx_ring->next_to_clean = i;

2066 2067 2068
	cleaned_count = IXGB_DESC_UNUSED(rx_ring);
	if (cleaned_count)
		ixgb_alloc_rx_buffers(adapter, cleaned_count);
L
Linus Torvalds 已提交
2069 2070 2071 2072 2073 2074 2075 2076 2077 2078

	return cleaned;
}

/**
 * ixgb_alloc_rx_buffers - Replace used receive buffers
 * @adapter: address of board private structure
 **/

static void
2079
ixgb_alloc_rx_buffers(struct ixgb_adapter *adapter, int cleaned_count)
L
Linus Torvalds 已提交
2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094
{
	struct ixgb_desc_ring *rx_ring = &adapter->rx_ring;
	struct net_device *netdev = adapter->netdev;
	struct pci_dev *pdev = adapter->pdev;
	struct ixgb_rx_desc *rx_desc;
	struct ixgb_buffer *buffer_info;
	struct sk_buff *skb;
	unsigned int i;
	long cleancount;

	i = rx_ring->next_to_use;
	buffer_info = &rx_ring->buffer_info[i];
	cleancount = IXGB_DESC_UNUSED(rx_ring);


2095
	/* leave three descriptors unused */
2096
	while (--cleancount > 2 && cleaned_count--) {
2097
		/* recycle! its good for you */
A
Auke Kok 已提交
2098 2099
		skb = buffer_info->skb;
		if (skb) {
2100 2101 2102
			skb_trim(skb, 0);
			goto map_skb;
		}
L
Linus Torvalds 已提交
2103

2104
		skb = netdev_alloc_skb_ip_align(netdev, adapter->rx_buffer_len);
2105
		if (unlikely(!skb)) {
L
Linus Torvalds 已提交
2106
			/* Better luck next round */
2107
			adapter->alloc_rx_buff_failed++;
L
Linus Torvalds 已提交
2108 2109 2110 2111 2112
			break;
		}

		buffer_info->skb = skb;
		buffer_info->length = adapter->rx_buffer_len;
2113
map_skb:
2114
		buffer_info->dma = dma_map_single(&pdev->dev,
2115 2116
		                                  skb->data,
		                                  adapter->rx_buffer_len,
2117
						  DMA_FROM_DEVICE);
L
Linus Torvalds 已提交
2118

2119
		rx_desc = IXGB_RX_DESC(*rx_ring, i);
L
Linus Torvalds 已提交
2120
		rx_desc->buff_addr = cpu_to_le64(buffer_info->dma);
2121
		/* guarantee DD bit not set now before h/w gets descriptor
J
Jesse Brandeburg 已提交
2122
		 * this is the rest of the workaround for h/w double
2123 2124
		 * writeback. */
		rx_desc->status = 0;
L
Linus Torvalds 已提交
2125 2126


2127
		if (++i == rx_ring->count) i = 0;
L
Linus Torvalds 已提交
2128 2129 2130
		buffer_info = &rx_ring->buffer_info[i];
	}

2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142
	if (likely(rx_ring->next_to_use != i)) {
		rx_ring->next_to_use = i;
		if (unlikely(i-- == 0))
			i = (rx_ring->count - 1);

		/* Force memory writes to complete before letting h/w
		 * know there are new descriptors to fetch.  (Only
		 * applicable for weak-ordered memory model archs, such
		 * as IA-64). */
		wmb();
		IXGB_WRITE_REG(&adapter->hw, RDT, i);
	}
L
Linus Torvalds 已提交
2143 2144 2145 2146
}

/**
 * ixgb_vlan_rx_register - enables or disables vlan tagging/stripping.
J
Jesse Brandeburg 已提交
2147
 *
L
Linus Torvalds 已提交
2148 2149 2150 2151 2152 2153
 * @param netdev network interface device structure
 * @param grp indicates to enable or disable tagging/stripping
 **/
static void
ixgb_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp)
{
2154
	struct ixgb_adapter *adapter = netdev_priv(netdev);
2155
	u32 ctrl, rctl;
L
Linus Torvalds 已提交
2156 2157 2158 2159

	ixgb_irq_disable(adapter);
	adapter->vlgrp = grp;

2160
	if (grp) {
L
Linus Torvalds 已提交
2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178
		/* enable VLAN tag insert/strip */
		ctrl = IXGB_READ_REG(&adapter->hw, CTRL0);
		ctrl |= IXGB_CTRL0_VME;
		IXGB_WRITE_REG(&adapter->hw, CTRL0, ctrl);

		/* enable VLAN receive filtering */

		rctl = IXGB_READ_REG(&adapter->hw, RCTL);
		rctl &= ~IXGB_RCTL_CFIEN;
		IXGB_WRITE_REG(&adapter->hw, RCTL, rctl);
	} else {
		/* disable VLAN tag insert/strip */

		ctrl = IXGB_READ_REG(&adapter->hw, CTRL0);
		ctrl &= ~IXGB_CTRL0_VME;
		IXGB_WRITE_REG(&adapter->hw, CTRL0, ctrl);
	}

2179 2180 2181
	/* don't enable interrupts unless we are UP */
	if (adapter->netdev->flags & IFF_UP)
		ixgb_irq_enable(adapter);
L
Linus Torvalds 已提交
2182 2183 2184
}

static void
2185
ixgb_vlan_rx_add_vid(struct net_device *netdev, u16 vid)
L
Linus Torvalds 已提交
2186
{
2187
	struct ixgb_adapter *adapter = netdev_priv(netdev);
2188
	u32 vfta, index;
L
Linus Torvalds 已提交
2189 2190 2191 2192 2193 2194 2195 2196 2197 2198

	/* add VID to filter table */

	index = (vid >> 5) & 0x7F;
	vfta = IXGB_READ_REG_ARRAY(&adapter->hw, VFTA, index);
	vfta |= (1 << (vid & 0x1F));
	ixgb_write_vfta(&adapter->hw, index, vfta);
}

static void
2199
ixgb_vlan_rx_kill_vid(struct net_device *netdev, u16 vid)
L
Linus Torvalds 已提交
2200
{
2201
	struct ixgb_adapter *adapter = netdev_priv(netdev);
2202
	u32 vfta, index;
L
Linus Torvalds 已提交
2203 2204 2205

	ixgb_irq_disable(adapter);

D
Dan Aloni 已提交
2206
	vlan_group_set_device(adapter->vlgrp, vid, NULL);
L
Linus Torvalds 已提交
2207

2208 2209 2210
	/* don't enable interrupts unless we are UP */
	if (adapter->netdev->flags & IFF_UP)
		ixgb_irq_enable(adapter);
L
Linus Torvalds 已提交
2211

2212
	/* remove VID from filter table */
L
Linus Torvalds 已提交
2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224

	index = (vid >> 5) & 0x7F;
	vfta = IXGB_READ_REG_ARRAY(&adapter->hw, VFTA, index);
	vfta &= ~(1 << (vid & 0x1F));
	ixgb_write_vfta(&adapter->hw, index, vfta);
}

static void
ixgb_restore_vlan(struct ixgb_adapter *adapter)
{
	ixgb_vlan_rx_register(adapter->netdev, adapter->vlgrp);

2225
	if (adapter->vlgrp) {
2226
		u16 vid;
2227
		for (vid = 0; vid < VLAN_N_VID; vid++) {
2228
			if (!vlan_group_get_device(adapter->vlgrp, vid))
L
Linus Torvalds 已提交
2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243
				continue;
			ixgb_vlan_rx_add_vid(adapter->netdev, vid);
		}
	}
}

#ifdef CONFIG_NET_POLL_CONTROLLER
/*
 * Polling 'interrupt' - used by things like netconsole to send skbs
 * without having to re-enable interrupts. It's not called while
 * the interrupt routine is executing.
 */

static void ixgb_netpoll(struct net_device *dev)
{
2244
	struct ixgb_adapter *adapter = netdev_priv(dev);
2245

L
Linus Torvalds 已提交
2246
	disable_irq(adapter->pdev->irq);
2247
	ixgb_intr(adapter->pdev->irq, dev);
L
Linus Torvalds 已提交
2248 2249 2250 2251
	enable_irq(adapter->pdev->irq);
}
#endif

2252 2253 2254 2255 2256 2257 2258 2259
/**
 * ixgb_io_error_detected() - called when PCI error is detected
 * @pdev    pointer to pci device with error
 * @state   pci channel state after error
 *
 * This callback is called by the PCI subsystem whenever
 * a PCI bus error is detected.
 */
J
Jesse Brandeburg 已提交
2260 2261
static pci_ers_result_t ixgb_io_error_detected(struct pci_dev *pdev,
                                               enum pci_channel_state state)
2262 2263
{
	struct net_device *netdev = pci_get_drvdata(pdev);
A
Auke Kok 已提交
2264
	struct ixgb_adapter *adapter = netdev_priv(netdev);
2265

2266 2267 2268 2269 2270
	netif_device_detach(netdev);

	if (state == pci_channel_io_perm_failure)
		return PCI_ERS_RESULT_DISCONNECT;

2271
	if (netif_running(netdev))
J
Joe Perches 已提交
2272
		ixgb_down(adapter, true);
2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283

	pci_disable_device(pdev);

	/* Request a slot reset. */
	return PCI_ERS_RESULT_NEED_RESET;
}

/**
 * ixgb_io_slot_reset - called after the pci bus has been reset.
 * @pdev    pointer to pci device with error
 *
J
Jesse Brandeburg 已提交
2284
 * This callback is called after the PCI bus has been reset.
2285 2286 2287 2288
 * Basically, this tries to restart the card from scratch.
 * This is a shortened version of the device probe/discovery code,
 * it resembles the first-half of the ixgb_probe() routine.
 */
J
Jesse Brandeburg 已提交
2289
static pci_ers_result_t ixgb_io_slot_reset(struct pci_dev *pdev)
2290 2291
{
	struct net_device *netdev = pci_get_drvdata(pdev);
A
Auke Kok 已提交
2292
	struct ixgb_adapter *adapter = netdev_priv(netdev);
2293

2294
	if (pci_enable_device(pdev)) {
2295 2296
		netif_err(adapter, probe, adapter->netdev,
			  "Cannot re-enable PCI device after reset\n");
2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310
		return PCI_ERS_RESULT_DISCONNECT;
	}

	/* Perform card reset only on one instance of the card */
	if (0 != PCI_FUNC (pdev->devfn))
		return PCI_ERS_RESULT_RECOVERED;

	pci_set_master(pdev);

	netif_carrier_off(netdev);
	netif_stop_queue(netdev);
	ixgb_reset(adapter);

	/* Make sure the EEPROM is good */
2311
	if (!ixgb_validate_eeprom_checksum(&adapter->hw)) {
2312 2313
		netif_err(adapter, probe, adapter->netdev,
			  "After reset, the EEPROM checksum is not valid\n");
2314 2315 2316 2317 2318
		return PCI_ERS_RESULT_DISCONNECT;
	}
	ixgb_get_ee_mac_addr(&adapter->hw, netdev->dev_addr);
	memcpy(netdev->perm_addr, netdev->dev_addr, netdev->addr_len);

2319
	if (!is_valid_ether_addr(netdev->perm_addr)) {
2320 2321
		netif_err(adapter, probe, adapter->netdev,
			  "After reset, invalid MAC address\n");
2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335
		return PCI_ERS_RESULT_DISCONNECT;
	}

	return PCI_ERS_RESULT_RECOVERED;
}

/**
 * ixgb_io_resume - called when its OK to resume normal operations
 * @pdev    pointer to pci device with error
 *
 * The error recovery driver tells us that its OK to resume
 * normal operation. Implementation resembles the second-half
 * of the ixgb_probe() routine.
 */
J
Jesse Brandeburg 已提交
2336
static void ixgb_io_resume(struct pci_dev *pdev)
2337 2338
{
	struct net_device *netdev = pci_get_drvdata(pdev);
A
Auke Kok 已提交
2339
	struct ixgb_adapter *adapter = netdev_priv(netdev);
2340 2341 2342

	pci_set_master(pdev);

2343 2344
	if (netif_running(netdev)) {
		if (ixgb_up(adapter)) {
2345
			pr_err("can't bring device back up after reset\n");
2346 2347 2348 2349 2350 2351 2352 2353
			return;
		}
	}

	netif_device_attach(netdev);
	mod_timer(&adapter->watchdog_timer, jiffies);
}

L
Linus Torvalds 已提交
2354
/* ixgb_main.c */