netdev.c 197.7 KB
Newer Older
1 2 3
/*******************************************************************************

  Intel PRO/1000 Linux driver
B
Bruce Allan 已提交
4
  Copyright(c) 1999 - 2013 Intel Corporation.
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

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

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

  You should have received a copy of the GNU General Public License along with
  this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.

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

  Contact Information:
  Linux NICS <linux.nics@intel.com>
  e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
  Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497

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

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

31 32 33 34 35 36 37 38
#include <linux/module.h>
#include <linux/types.h>
#include <linux/init.h>
#include <linux/pci.h>
#include <linux/vmalloc.h>
#include <linux/pagemap.h>
#include <linux/delay.h>
#include <linux/netdevice.h>
39
#include <linux/interrupt.h>
40 41
#include <linux/tcp.h>
#include <linux/ipv6.h>
42
#include <linux/slab.h>
43 44 45 46 47 48 49
#include <net/checksum.h>
#include <net/ip6_checksum.h>
#include <linux/mii.h>
#include <linux/ethtool.h>
#include <linux/if_vlan.h>
#include <linux/cpu.h>
#include <linux/smp.h>
50
#include <linux/pm_qos.h>
51
#include <linux/pm_runtime.h>
J
Jesse Brandeburg 已提交
52
#include <linux/aer.h>
53
#include <linux/prefetch.h>
54 55 56

#include "e1000.h"

B
Bruce Allan 已提交
57
#define DRV_EXTRAVERSION "-k"
58

59
#define DRV_VERSION "2.2.14" DRV_EXTRAVERSION
60 61 62
char e1000e_driver_name[] = "e1000e";
const char e1000e_driver_version[] = DRV_VERSION;

63 64 65 66 67
#define DEFAULT_MSG_ENABLE (NETIF_MSG_DRV|NETIF_MSG_PROBE|NETIF_MSG_LINK)
static int debug = -1;
module_param(debug, int, 0);
MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");

68 69
static void e1000e_disable_aspm(struct pci_dev *pdev, u16 state);

70 71 72 73
static const struct e1000_info *e1000_info_tbl[] = {
	[board_82571]		= &e1000_82571_info,
	[board_82572]		= &e1000_82572_info,
	[board_82573]		= &e1000_82573_info,
74
	[board_82574]		= &e1000_82574_info,
75
	[board_82583]		= &e1000_82583_info,
76 77 78
	[board_80003es2lan]	= &e1000_es2_info,
	[board_ich8lan]		= &e1000_ich8_info,
	[board_ich9lan]		= &e1000_ich9_info,
79
	[board_ich10lan]	= &e1000_ich10_info,
80
	[board_pchlan]		= &e1000_pch_info,
81
	[board_pch2lan]		= &e1000_pch2_info,
B
Bruce Allan 已提交
82
	[board_pch_lpt]		= &e1000_pch_lpt_info,
83 84
};

85 86 87 88 89
struct e1000_reg_info {
	u32 ofs;
	char *name;
};

90 91 92 93 94 95 96 97 98 99 100
#define E1000_RDFH	0x02410	/* Rx Data FIFO Head - RW */
#define E1000_RDFT	0x02418	/* Rx Data FIFO Tail - RW */
#define E1000_RDFHS	0x02420	/* Rx Data FIFO Head Saved - RW */
#define E1000_RDFTS	0x02428	/* Rx Data FIFO Tail Saved - RW */
#define E1000_RDFPC	0x02430	/* Rx Data FIFO Packet Count - RW */

#define E1000_TDFH	0x03410	/* Tx Data FIFO Head - RW */
#define E1000_TDFT	0x03418	/* Tx Data FIFO Tail - RW */
#define E1000_TDFHS	0x03420	/* Tx Data FIFO Head Saved - RW */
#define E1000_TDFTS	0x03428	/* Tx Data FIFO Tail Saved - RW */
#define E1000_TDFPC	0x03430	/* Tx Data FIFO Packet Count - RW */
101 102 103 104 105 106 107 108 109 110 111

static const struct e1000_reg_info e1000_reg_info_tbl[] = {

	/* General Registers */
	{E1000_CTRL, "CTRL"},
	{E1000_STATUS, "STATUS"},
	{E1000_CTRL_EXT, "CTRL_EXT"},

	/* Interrupt Registers */
	{E1000_ICR, "ICR"},

112
	/* Rx Registers */
113
	{E1000_RCTL, "RCTL"},
114 115 116
	{E1000_RDLEN(0), "RDLEN"},
	{E1000_RDH(0), "RDH"},
	{E1000_RDT(0), "RDT"},
117 118 119
	{E1000_RDTR, "RDTR"},
	{E1000_RXDCTL(0), "RXDCTL"},
	{E1000_ERT, "ERT"},
120 121
	{E1000_RDBAL(0), "RDBAL"},
	{E1000_RDBAH(0), "RDBAH"},
122 123 124 125 126 127
	{E1000_RDFH, "RDFH"},
	{E1000_RDFT, "RDFT"},
	{E1000_RDFHS, "RDFHS"},
	{E1000_RDFTS, "RDFTS"},
	{E1000_RDFPC, "RDFPC"},

128
	/* Tx Registers */
129
	{E1000_TCTL, "TCTL"},
130 131 132 133 134
	{E1000_TDBAL(0), "TDBAL"},
	{E1000_TDBAH(0), "TDBAH"},
	{E1000_TDLEN(0), "TDLEN"},
	{E1000_TDH(0), "TDH"},
	{E1000_TDT(0), "TDT"},
135 136 137 138 139 140 141 142 143 144 145
	{E1000_TIDV, "TIDV"},
	{E1000_TXDCTL(0), "TXDCTL"},
	{E1000_TADV, "TADV"},
	{E1000_TARC(0), "TARC"},
	{E1000_TDFH, "TDFH"},
	{E1000_TDFT, "TDFT"},
	{E1000_TDFHS, "TDFHS"},
	{E1000_TDFTS, "TDFTS"},
	{E1000_TDFPC, "TDFPC"},

	/* List Terminator */
146
	{0, NULL}
147 148
};

B
Bruce Allan 已提交
149
/**
150
 * e1000_regdump - register printout routine
B
Bruce Allan 已提交
151 152 153
 * @hw: pointer to the HW structure
 * @reginfo: pointer to the register info table
 **/
154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173
static void e1000_regdump(struct e1000_hw *hw, struct e1000_reg_info *reginfo)
{
	int n = 0;
	char rname[16];
	u32 regs[8];

	switch (reginfo->ofs) {
	case E1000_RXDCTL(0):
		for (n = 0; n < 2; n++)
			regs[n] = __er32(hw, E1000_RXDCTL(n));
		break;
	case E1000_TXDCTL(0):
		for (n = 0; n < 2; n++)
			regs[n] = __er32(hw, E1000_TXDCTL(n));
		break;
	case E1000_TARC(0):
		for (n = 0; n < 2; n++)
			regs[n] = __er32(hw, E1000_TARC(n));
		break;
	default:
174 175
		pr_info("%-15s %08x\n",
			reginfo->name, __er32(hw, reginfo->ofs));
176 177 178 179
		return;
	}

	snprintf(rname, 16, "%s%s", reginfo->name, "[0-1]");
180
	pr_info("%-15s %08x %08x\n", rname, regs[0], regs[1]);
181 182
}

183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200
static void e1000e_dump_ps_pages(struct e1000_adapter *adapter,
				 struct e1000_buffer *bi)
{
	int i;
	struct e1000_ps_page *ps_page;

	for (i = 0; i < adapter->rx_ps_pages; i++) {
		ps_page = &bi->ps_pages[i];

		if (ps_page->page) {
			pr_info("packet dump for ps_page %d:\n", i);
			print_hex_dump(KERN_INFO, "", DUMP_PREFIX_ADDRESS,
				       16, 1, page_address(ps_page->page),
				       PAGE_SIZE, true);
		}
	}
}

B
Bruce Allan 已提交
201
/**
202
 * e1000e_dump - Print registers, Tx-ring and Rx-ring
B
Bruce Allan 已提交
203 204
 * @adapter: board private structure
 **/
205 206 207 208 209 210 211
static void e1000e_dump(struct e1000_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;
	struct e1000_hw *hw = &adapter->hw;
	struct e1000_reg_info *reginfo;
	struct e1000_ring *tx_ring = adapter->tx_ring;
	struct e1000_tx_desc *tx_desc;
212
	struct my_u0 {
213 214
		__le64 a;
		__le64 b;
215
	} *u0;
216 217 218
	struct e1000_buffer *buffer_info;
	struct e1000_ring *rx_ring = adapter->rx_ring;
	union e1000_rx_desc_packet_split *rx_desc_ps;
219
	union e1000_rx_desc_extended *rx_desc;
220
	struct my_u1 {
221 222 223 224
		__le64 a;
		__le64 b;
		__le64 c;
		__le64 d;
225
	} *u1;
226 227 228 229 230 231 232 233 234
	u32 staterr;
	int i = 0;

	if (!netif_msg_hw(adapter))
		return;

	/* Print netdevice Info */
	if (netdev) {
		dev_info(&adapter->pdev->dev, "Net device Info\n");
235 236 237 238
		pr_info("Device Name     state            trans_start      last_rx\n");
		pr_info("%-15s %016lX %016lX %016lX\n",
			netdev->name, netdev->state, netdev->trans_start,
			netdev->last_rx);
239 240 241 242
	}

	/* Print Registers */
	dev_info(&adapter->pdev->dev, "Register Dump\n");
243
	pr_info(" Register Name   Value\n");
244 245 246 247 248
	for (reginfo = (struct e1000_reg_info *)e1000_reg_info_tbl;
	     reginfo->name; reginfo++) {
		e1000_regdump(hw, reginfo);
	}

249
	/* Print Tx Ring Summary */
250
	if (!netdev || !netif_running(netdev))
251
		return;
252

253
	dev_info(&adapter->pdev->dev, "Tx Ring Summary\n");
254
	pr_info("Queue [NTU] [NTC] [bi(ntc)->dma  ] leng ntw timestamp\n");
255
	buffer_info = &tx_ring->buffer_info[tx_ring->next_to_clean];
256 257 258 259 260 261
	pr_info(" %5d %5X %5X %016llX %04X %3X %016llX\n",
		0, tx_ring->next_to_use, tx_ring->next_to_clean,
		(unsigned long long)buffer_info->dma,
		buffer_info->length,
		buffer_info->next_to_watch,
		(unsigned long long)buffer_info->time_stamp);
262

263
	/* Print Tx Ring */
264 265 266
	if (!netif_msg_tx_done(adapter))
		goto rx_ring_summary;

267
	dev_info(&adapter->pdev->dev, "Tx Ring Dump\n");
268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295

	/* Transmit Descriptor Formats - DEXT[29] is 0 (Legacy) or 1 (Extended)
	 *
	 * Legacy Transmit Descriptor
	 *   +--------------------------------------------------------------+
	 * 0 |         Buffer Address [63:0] (Reserved on Write Back)       |
	 *   +--------------------------------------------------------------+
	 * 8 | Special  |    CSS     | Status |  CMD    |  CSO   |  Length  |
	 *   +--------------------------------------------------------------+
	 *   63       48 47        36 35    32 31     24 23    16 15        0
	 *
	 * Extended Context Descriptor (DTYP=0x0) for TSO or checksum offload
	 *   63      48 47    40 39       32 31             16 15    8 7      0
	 *   +----------------------------------------------------------------+
	 * 0 |  TUCSE  | TUCS0  |   TUCSS   |     IPCSE       | IPCS0 | IPCSS |
	 *   +----------------------------------------------------------------+
	 * 8 |   MSS   | HDRLEN | RSV | STA | TUCMD | DTYP |      PAYLEN      |
	 *   +----------------------------------------------------------------+
	 *   63      48 47    40 39 36 35 32 31   24 23  20 19                0
	 *
	 * Extended Data Descriptor (DTYP=0x1)
	 *   +----------------------------------------------------------------+
	 * 0 |                     Buffer Address [63:0]                      |
	 *   +----------------------------------------------------------------+
	 * 8 | VLAN tag |  POPTS  | Rsvd | Status | Command | DTYP |  DTALEN  |
	 *   +----------------------------------------------------------------+
	 *   63       48 47     40 39  36 35    32 31     24 23  20 19        0
	 */
296 297 298
	pr_info("Tl[desc]     [address 63:0  ] [SpeCssSCmCsLen] [bi->dma       ] leng  ntw timestamp        bi->skb <-- Legacy format\n");
	pr_info("Tc[desc]     [Ce CoCsIpceCoS] [MssHlRSCm0Plen] [bi->dma       ] leng  ntw timestamp        bi->skb <-- Ext Context format\n");
	pr_info("Td[desc]     [address 63:0  ] [VlaPoRSCm1Dlen] [bi->dma       ] leng  ntw timestamp        bi->skb <-- Ext Data format\n");
299
	for (i = 0; tx_ring->desc && (i < tx_ring->count); i++) {
300
		const char *next_desc;
301 302 303 304
		tx_desc = E1000_TX_DESC(*tx_ring, i);
		buffer_info = &tx_ring->buffer_info[i];
		u0 = (struct my_u0 *)tx_desc;
		if (i == tx_ring->next_to_use && i == tx_ring->next_to_clean)
305
			next_desc = " NTC/U";
306
		else if (i == tx_ring->next_to_use)
307
			next_desc = " NTU";
308
		else if (i == tx_ring->next_to_clean)
309
			next_desc = " NTC";
310
		else
311 312 313 314 315 316 317 318 319 320 321
			next_desc = "";
		pr_info("T%c[0x%03X]    %016llX %016llX %016llX %04X  %3X %016llX %p%s\n",
			(!(le64_to_cpu(u0->b) & (1 << 29)) ? 'l' :
			 ((le64_to_cpu(u0->b) & (1 << 20)) ? 'd' : 'c')),
			i,
			(unsigned long long)le64_to_cpu(u0->a),
			(unsigned long long)le64_to_cpu(u0->b),
			(unsigned long long)buffer_info->dma,
			buffer_info->length, buffer_info->next_to_watch,
			(unsigned long long)buffer_info->time_stamp,
			buffer_info->skb, next_desc);
322

323
		if (netif_msg_pktdata(adapter) && buffer_info->skb)
324
			print_hex_dump(KERN_INFO, "", DUMP_PREFIX_ADDRESS,
325 326
				       16, 1, buffer_info->skb->data,
				       buffer_info->skb->len, true);
327 328
	}

329
	/* Print Rx Ring Summary */
330
rx_ring_summary:
331
	dev_info(&adapter->pdev->dev, "Rx Ring Summary\n");
332 333 334
	pr_info("Queue [NTU] [NTC]\n");
	pr_info(" %5d %5X %5X\n",
		0, rx_ring->next_to_use, rx_ring->next_to_clean);
335

336
	/* Print Rx Ring */
337
	if (!netif_msg_rx_status(adapter))
338
		return;
339

340
	dev_info(&adapter->pdev->dev, "Rx Ring Dump\n");
341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356
	switch (adapter->rx_ps_pages) {
	case 1:
	case 2:
	case 3:
		/* [Extended] Packet Split Receive Descriptor Format
		 *
		 *    +-----------------------------------------------------+
		 *  0 |                Buffer Address 0 [63:0]              |
		 *    +-----------------------------------------------------+
		 *  8 |                Buffer Address 1 [63:0]              |
		 *    +-----------------------------------------------------+
		 * 16 |                Buffer Address 2 [63:0]              |
		 *    +-----------------------------------------------------+
		 * 24 |                Buffer Address 3 [63:0]              |
		 *    +-----------------------------------------------------+
		 */
357
		pr_info("R  [desc]      [buffer 0 63:0 ] [buffer 1 63:0 ] [buffer 2 63:0 ] [buffer 3 63:0 ] [bi->dma       ] [bi->skb] <-- Ext Pkt Split format\n");
358 359 360 361 362 363 364 365 366 367 368
		/* [Extended] Receive Descriptor (Write-Back) Format
		 *
		 *   63       48 47    32 31     13 12    8 7    4 3        0
		 *   +------------------------------------------------------+
		 * 0 | Packet   | IP     |  Rsvd   | MRQ   | Rsvd | MRQ RSS |
		 *   | Checksum | Ident  |         | Queue |      |  Type   |
		 *   +------------------------------------------------------+
		 * 8 | VLAN Tag | Length | Extended Error | Extended Status |
		 *   +------------------------------------------------------+
		 *   63       48 47    32 31            20 19               0
		 */
369
		pr_info("RWB[desc]      [ck ipid mrqhsh] [vl   l0 ee  es] [ l3  l2  l1 hs] [reserved      ] ---------------- [bi->skb] <-- Ext Rx Write-Back format\n");
370
		for (i = 0; i < rx_ring->count; i++) {
371
			const char *next_desc;
372 373 374 375
			buffer_info = &rx_ring->buffer_info[i];
			rx_desc_ps = E1000_RX_DESC_PS(*rx_ring, i);
			u1 = (struct my_u1 *)rx_desc_ps;
			staterr =
376
			    le32_to_cpu(rx_desc_ps->wb.middle.status_error);
377 378 379 380 381 382 383 384

			if (i == rx_ring->next_to_use)
				next_desc = " NTU";
			else if (i == rx_ring->next_to_clean)
				next_desc = " NTC";
			else
				next_desc = "";

385 386
			if (staterr & E1000_RXD_STAT_DD) {
				/* Descriptor Done */
387 388 389 390 391 392 393
				pr_info("%s[0x%03X]     %016llX %016llX %016llX %016llX ---------------- %p%s\n",
					"RWB", i,
					(unsigned long long)le64_to_cpu(u1->a),
					(unsigned long long)le64_to_cpu(u1->b),
					(unsigned long long)le64_to_cpu(u1->c),
					(unsigned long long)le64_to_cpu(u1->d),
					buffer_info->skb, next_desc);
394
			} else {
395 396 397 398 399 400 401 402
				pr_info("%s[0x%03X]     %016llX %016llX %016llX %016llX %016llX %p%s\n",
					"R  ", i,
					(unsigned long long)le64_to_cpu(u1->a),
					(unsigned long long)le64_to_cpu(u1->b),
					(unsigned long long)le64_to_cpu(u1->c),
					(unsigned long long)le64_to_cpu(u1->d),
					(unsigned long long)buffer_info->dma,
					buffer_info->skb, next_desc);
403 404

				if (netif_msg_pktdata(adapter))
405 406
					e1000e_dump_ps_pages(adapter,
							     buffer_info);
407 408 409 410 411
			}
		}
		break;
	default:
	case 0:
412
		/* Extended Receive Descriptor (Read) Format
413
		 *
414 415 416 417 418
		 *   +-----------------------------------------------------+
		 * 0 |                Buffer Address [63:0]                |
		 *   +-----------------------------------------------------+
		 * 8 |                      Reserved                       |
		 *   +-----------------------------------------------------+
419
		 */
420
		pr_info("R  [desc]      [buf addr 63:0 ] [reserved 63:0 ] [bi->dma       ] [bi->skb] <-- Ext (Read) format\n");
421 422 423 424 425 426 427 428 429 430 431 432 433
		/* Extended Receive Descriptor (Write-Back) Format
		 *
		 *   63       48 47    32 31    24 23            4 3        0
		 *   +------------------------------------------------------+
		 *   |     RSS Hash      |        |               |         |
		 * 0 +-------------------+  Rsvd  |   Reserved    | MRQ RSS |
		 *   | Packet   | IP     |        |               |  Type   |
		 *   | Checksum | Ident  |        |               |         |
		 *   +------------------------------------------------------+
		 * 8 | VLAN Tag | Length | Extended Error | Extended Status |
		 *   +------------------------------------------------------+
		 *   63       48 47    32 31            20 19               0
		 */
434
		pr_info("RWB[desc]      [cs ipid    mrq] [vt   ln xe  xs] [bi->skb] <-- Ext (Write-Back) format\n");
435 436

		for (i = 0; i < rx_ring->count; i++) {
437 438
			const char *next_desc;

439
			buffer_info = &rx_ring->buffer_info[i];
440 441 442
			rx_desc = E1000_RX_DESC_EXT(*rx_ring, i);
			u1 = (struct my_u1 *)rx_desc;
			staterr = le32_to_cpu(rx_desc->wb.upper.status_error);
443 444 445 446 447 448 449 450

			if (i == rx_ring->next_to_use)
				next_desc = " NTU";
			else if (i == rx_ring->next_to_clean)
				next_desc = " NTC";
			else
				next_desc = "";

451 452
			if (staterr & E1000_RXD_STAT_DD) {
				/* Descriptor Done */
453 454 455 456 457
				pr_info("%s[0x%03X]     %016llX %016llX ---------------- %p%s\n",
					"RWB", i,
					(unsigned long long)le64_to_cpu(u1->a),
					(unsigned long long)le64_to_cpu(u1->b),
					buffer_info->skb, next_desc);
458
			} else {
459 460 461 462 463 464
				pr_info("%s[0x%03X]     %016llX %016llX %016llX %p%s\n",
					"R  ", i,
					(unsigned long long)le64_to_cpu(u1->a),
					(unsigned long long)le64_to_cpu(u1->b),
					(unsigned long long)buffer_info->dma,
					buffer_info->skb, next_desc);
465

466 467
				if (netif_msg_pktdata(adapter) &&
				    buffer_info->skb)
468 469 470
					print_hex_dump(KERN_INFO, "",
						       DUMP_PREFIX_ADDRESS, 16,
						       1,
471
						       buffer_info->skb->data,
472 473 474
						       adapter->rx_buffer_len,
						       true);
			}
475 476 477 478
		}
	}
}

479 480 481 482 483 484 485 486 487 488 489
/**
 * e1000_desc_unused - calculate if we have unused descriptors
 **/
static int e1000_desc_unused(struct e1000_ring *ring)
{
	if (ring->next_to_clean > ring->next_to_use)
		return ring->next_to_clean - ring->next_to_use - 1;

	return ring->count + ring->next_to_clean - ring->next_to_use - 1;
}

490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553
/**
 * e1000e_systim_to_hwtstamp - convert system time value to hw time stamp
 * @adapter: board private structure
 * @hwtstamps: time stamp structure to update
 * @systim: unsigned 64bit system time value.
 *
 * Convert the system time value stored in the RX/TXSTMP registers into a
 * hwtstamp which can be used by the upper level time stamping functions.
 *
 * The 'systim_lock' spinlock is used to protect the consistency of the
 * system time value. This is needed because reading the 64 bit time
 * value involves reading two 32 bit registers. The first read latches the
 * value.
 **/
static void e1000e_systim_to_hwtstamp(struct e1000_adapter *adapter,
				      struct skb_shared_hwtstamps *hwtstamps,
				      u64 systim)
{
	u64 ns;
	unsigned long flags;

	spin_lock_irqsave(&adapter->systim_lock, flags);
	ns = timecounter_cyc2time(&adapter->tc, systim);
	spin_unlock_irqrestore(&adapter->systim_lock, flags);

	memset(hwtstamps, 0, sizeof(*hwtstamps));
	hwtstamps->hwtstamp = ns_to_ktime(ns);
}

/**
 * e1000e_rx_hwtstamp - utility function which checks for Rx time stamp
 * @adapter: board private structure
 * @status: descriptor extended error and status field
 * @skb: particular skb to include time stamp
 *
 * If the time stamp is valid, convert it into the timecounter ns value
 * and store that result into the shhwtstamps structure which is passed
 * up the network stack.
 **/
static void e1000e_rx_hwtstamp(struct e1000_adapter *adapter, u32 status,
			       struct sk_buff *skb)
{
	struct e1000_hw *hw = &adapter->hw;
	u64 rxstmp;

	if (!(adapter->flags & FLAG_HAS_HW_TIMESTAMP) ||
	    !(status & E1000_RXDEXT_STATERR_TST) ||
	    !(er32(TSYNCRXCTL) & E1000_TSYNCRXCTL_VALID))
		return;

	/* The Rx time stamp registers contain the time stamp.  No other
	 * received packet will be time stamped until the Rx time stamp
	 * registers are read.  Because only one packet can be time stamped
	 * at a time, the register values must belong to this packet and
	 * therefore none of the other additional attributes need to be
	 * compared.
	 */
	rxstmp = (u64)er32(RXSTMPL);
	rxstmp |= (u64)er32(RXSTMPH) << 32;
	e1000e_systim_to_hwtstamp(adapter, skb_hwtstamps(skb), rxstmp);

	adapter->flags2 &= ~FLAG2_CHECK_RX_HWTSTAMP;
}

554
/**
555
 * e1000_receive_skb - helper function to handle Rx indications
556
 * @adapter: board private structure
557
 * @staterr: descriptor extended error and status field as written by hardware
558 559 560 561
 * @vlan: descriptor vlan field as written by hardware (no le/be conversion)
 * @skb: pointer to sk_buff to be indicated to stack
 **/
static void e1000_receive_skb(struct e1000_adapter *adapter,
562
			      struct net_device *netdev, struct sk_buff *skb,
563
			      u32 staterr, __le16 vlan)
564
{
J
Jeff Kirsher 已提交
565
	u16 tag = le16_to_cpu(vlan);
566 567 568

	e1000e_rx_hwtstamp(adapter, staterr, skb);

569 570
	skb->protocol = eth_type_trans(skb, netdev);

571
	if (staterr & E1000_RXD_STAT_VP)
J
Jeff Kirsher 已提交
572 573 574
		__vlan_hwaccel_put_tag(skb, tag);

	napi_gro_receive(&adapter->napi, skb);
575 576 577
}

/**
578
 * e1000_rx_checksum - Receive Checksum Offload
579 580 581 582
 * @adapter: board private structure
 * @status_err: receive descriptor status and error fields
 * @csum: receive descriptor csum field
 * @sk_buff: socket buffer with received data
583 584
 **/
static void e1000_rx_checksum(struct e1000_adapter *adapter, u32 status_err,
585
			      struct sk_buff *skb)
586 587 588
{
	u16 status = (u16)status_err;
	u8 errors = (u8)(status_err >> 24);
589 590

	skb_checksum_none_assert(skb);
591

592 593 594 595
	/* Rx checksum disabled */
	if (!(adapter->netdev->features & NETIF_F_RXCSUM))
		return;

596 597 598
	/* Ignore Checksum bit is set */
	if (status & E1000_RXD_STAT_IXSM)
		return;
599

600 601
	/* TCP/UDP checksum error bit or IP checksum error bit is set */
	if (errors & (E1000_RXD_ERR_TCPE | E1000_RXD_ERR_IPE)) {
602 603 604 605 606 607 608 609 610 611
		/* let the stack verify checksum errors */
		adapter->hw_csum_err++;
		return;
	}

	/* TCP/UDP Checksum has not been calculated */
	if (!(status & (E1000_RXD_STAT_TCPCS | E1000_RXD_STAT_UDPCS)))
		return;

	/* It must be a TCP or UDP packet with a valid checksum */
612
	skb->ip_summed = CHECKSUM_UNNECESSARY;
613 614 615
	adapter->hw_csum_good++;
}

616
static void e1000e_update_rdt_wa(struct e1000_ring *rx_ring, unsigned int i)
617
{
618
	struct e1000_adapter *adapter = rx_ring->adapter;
619
	struct e1000_hw *hw = &adapter->hw;
620 621 622
	s32 ret_val = __ew32_prepare(hw);

	writel(i, rx_ring->tail);
623

624
	if (unlikely(!ret_val && (i != readl(rx_ring->tail)))) {
625 626 627 628 629 630 631
		u32 rctl = er32(RCTL);
		ew32(RCTL, rctl & ~E1000_RCTL_EN);
		e_err("ME firmware caused invalid RDT - resetting\n");
		schedule_work(&adapter->reset_task);
	}
}

632
static void e1000e_update_tdt_wa(struct e1000_ring *tx_ring, unsigned int i)
633
{
634
	struct e1000_adapter *adapter = tx_ring->adapter;
635
	struct e1000_hw *hw = &adapter->hw;
636
	s32 ret_val = __ew32_prepare(hw);
637

638 639 640
	writel(i, tx_ring->tail);

	if (unlikely(!ret_val && (i != readl(tx_ring->tail)))) {
641 642 643 644 645 646 647
		u32 tctl = er32(TCTL);
		ew32(TCTL, tctl & ~E1000_TCTL_EN);
		e_err("ME firmware caused invalid TDT - resetting\n");
		schedule_work(&adapter->reset_task);
	}
}

648
/**
649
 * e1000_alloc_rx_buffers - Replace used receive buffers
650
 * @rx_ring: Rx descriptor ring
651
 **/
652
static void e1000_alloc_rx_buffers(struct e1000_ring *rx_ring,
653
				   int cleaned_count, gfp_t gfp)
654
{
655
	struct e1000_adapter *adapter = rx_ring->adapter;
656 657
	struct net_device *netdev = adapter->netdev;
	struct pci_dev *pdev = adapter->pdev;
658
	union e1000_rx_desc_extended *rx_desc;
659 660 661
	struct e1000_buffer *buffer_info;
	struct sk_buff *skb;
	unsigned int i;
662
	unsigned int bufsz = adapter->rx_buffer_len;
663 664 665 666 667 668 669 670 671 672 673

	i = rx_ring->next_to_use;
	buffer_info = &rx_ring->buffer_info[i];

	while (cleaned_count--) {
		skb = buffer_info->skb;
		if (skb) {
			skb_trim(skb, 0);
			goto map_skb;
		}

674
		skb = __netdev_alloc_skb_ip_align(netdev, bufsz, gfp);
675 676 677 678 679 680 681 682
		if (!skb) {
			/* Better luck next round */
			adapter->alloc_rx_buff_failed++;
			break;
		}

		buffer_info->skb = skb;
map_skb:
683
		buffer_info->dma = dma_map_single(&pdev->dev, skb->data,
684
						  adapter->rx_buffer_len,
685 686
						  DMA_FROM_DEVICE);
		if (dma_mapping_error(&pdev->dev, buffer_info->dma)) {
687
			dev_err(&pdev->dev, "Rx DMA map failed\n");
688 689 690 691
			adapter->rx_dma_failed++;
			break;
		}

692 693
		rx_desc = E1000_RX_DESC_EXT(*rx_ring, i);
		rx_desc->read.buffer_addr = cpu_to_le64(buffer_info->dma);
694

695
		if (unlikely(!(i & (E1000_RX_BUFFER_WRITE - 1)))) {
B
Bruce Allan 已提交
696
			/* Force memory writes to complete before letting h/w
697 698 699 700 701
			 * know there are new descriptors to fetch.  (Only
			 * applicable for weak-ordered memory model archs,
			 * such as IA-64).
			 */
			wmb();
702
			if (adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
703
				e1000e_update_rdt_wa(rx_ring, i);
704
			else
705
				writel(i, rx_ring->tail);
706
		}
707 708 709 710 711 712
		i++;
		if (i == rx_ring->count)
			i = 0;
		buffer_info = &rx_ring->buffer_info[i];
	}

713
	rx_ring->next_to_use = i;
714 715 716 717
}

/**
 * e1000_alloc_rx_buffers_ps - Replace used receive buffers; packet split
718
 * @rx_ring: Rx descriptor ring
719
 **/
720
static void e1000_alloc_rx_buffers_ps(struct e1000_ring *rx_ring,
721
				      int cleaned_count, gfp_t gfp)
722
{
723
	struct e1000_adapter *adapter = rx_ring->adapter;
724 725 726 727 728 729 730 731 732 733 734 735 736 737 738
	struct net_device *netdev = adapter->netdev;
	struct pci_dev *pdev = adapter->pdev;
	union e1000_rx_desc_packet_split *rx_desc;
	struct e1000_buffer *buffer_info;
	struct e1000_ps_page *ps_page;
	struct sk_buff *skb;
	unsigned int i, j;

	i = rx_ring->next_to_use;
	buffer_info = &rx_ring->buffer_info[i];

	while (cleaned_count--) {
		rx_desc = E1000_RX_DESC_PS(*rx_ring, i);

		for (j = 0; j < PS_PAGE_BUFFERS; j++) {
A
Auke Kok 已提交
739 740 741
			ps_page = &buffer_info->ps_pages[j];
			if (j >= adapter->rx_ps_pages) {
				/* all unused desc entries get hw null ptr */
742 743
				rx_desc->read.buffer_addr[j + 1] =
				    ~cpu_to_le64(0);
A
Auke Kok 已提交
744 745 746
				continue;
			}
			if (!ps_page->page) {
747
				ps_page->page = alloc_page(gfp);
748
				if (!ps_page->page) {
A
Auke Kok 已提交
749 750 751
					adapter->alloc_rx_buff_failed++;
					goto no_buffers;
				}
752 753 754 755 756 757
				ps_page->dma = dma_map_page(&pdev->dev,
							    ps_page->page,
							    0, PAGE_SIZE,
							    DMA_FROM_DEVICE);
				if (dma_mapping_error(&pdev->dev,
						      ps_page->dma)) {
A
Auke Kok 已提交
758
					dev_err(&adapter->pdev->dev,
759
						"Rx DMA page map failed\n");
A
Auke Kok 已提交
760 761
					adapter->rx_dma_failed++;
					goto no_buffers;
762 763
				}
			}
B
Bruce Allan 已提交
764
			/* Refresh the desc even if buffer_addrs
A
Auke Kok 已提交
765 766 767
			 * didn't change because each write-back
			 * erases this info.
			 */
768 769
			rx_desc->read.buffer_addr[j + 1] =
			    cpu_to_le64(ps_page->dma);
770 771
		}

772 773 774
		skb = __netdev_alloc_skb_ip_align(netdev,
						  adapter->rx_ps_bsize0,
						  gfp);
775 776 777 778 779 780 781

		if (!skb) {
			adapter->alloc_rx_buff_failed++;
			break;
		}

		buffer_info->skb = skb;
782
		buffer_info->dma = dma_map_single(&pdev->dev, skb->data,
783
						  adapter->rx_ps_bsize0,
784 785
						  DMA_FROM_DEVICE);
		if (dma_mapping_error(&pdev->dev, buffer_info->dma)) {
786
			dev_err(&pdev->dev, "Rx DMA map failed\n");
787 788 789 790 791 792 793 794 795
			adapter->rx_dma_failed++;
			/* cleanup skb */
			dev_kfree_skb_any(skb);
			buffer_info->skb = NULL;
			break;
		}

		rx_desc->read.buffer_addr[0] = cpu_to_le64(buffer_info->dma);

796
		if (unlikely(!(i & (E1000_RX_BUFFER_WRITE - 1)))) {
B
Bruce Allan 已提交
797
			/* Force memory writes to complete before letting h/w
798 799 800 801 802
			 * know there are new descriptors to fetch.  (Only
			 * applicable for weak-ordered memory model archs,
			 * such as IA-64).
			 */
			wmb();
803
			if (adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
804
				e1000e_update_rdt_wa(rx_ring, i << 1);
805
			else
806
				writel(i << 1, rx_ring->tail);
807 808
		}

809 810 811 812 813 814 815
		i++;
		if (i == rx_ring->count)
			i = 0;
		buffer_info = &rx_ring->buffer_info[i];
	}

no_buffers:
816
	rx_ring->next_to_use = i;
817 818
}

819 820
/**
 * e1000_alloc_jumbo_rx_buffers - Replace used jumbo receive buffers
821
 * @rx_ring: Rx descriptor ring
822 823 824
 * @cleaned_count: number of buffers to allocate this pass
 **/

825
static void e1000_alloc_jumbo_rx_buffers(struct e1000_ring *rx_ring,
826
					 int cleaned_count, gfp_t gfp)
827
{
828
	struct e1000_adapter *adapter = rx_ring->adapter;
829 830
	struct net_device *netdev = adapter->netdev;
	struct pci_dev *pdev = adapter->pdev;
831
	union e1000_rx_desc_extended *rx_desc;
832 833 834
	struct e1000_buffer *buffer_info;
	struct sk_buff *skb;
	unsigned int i;
835
	unsigned int bufsz = 256 - 16;	/* for skb_reserve */
836 837 838 839 840 841 842 843 844 845 846

	i = rx_ring->next_to_use;
	buffer_info = &rx_ring->buffer_info[i];

	while (cleaned_count--) {
		skb = buffer_info->skb;
		if (skb) {
			skb_trim(skb, 0);
			goto check_page;
		}

847
		skb = __netdev_alloc_skb_ip_align(netdev, bufsz, gfp);
848 849 850 851 852 853 854 855 856 857
		if (unlikely(!skb)) {
			/* Better luck next round */
			adapter->alloc_rx_buff_failed++;
			break;
		}

		buffer_info->skb = skb;
check_page:
		/* allocate a new page if necessary */
		if (!buffer_info->page) {
858
			buffer_info->page = alloc_page(gfp);
859 860 861 862 863 864 865
			if (unlikely(!buffer_info->page)) {
				adapter->alloc_rx_buff_failed++;
				break;
			}
		}

		if (!buffer_info->dma)
866
			buffer_info->dma = dma_map_page(&pdev->dev,
867 868
			                                buffer_info->page, 0,
			                                PAGE_SIZE,
869
							DMA_FROM_DEVICE);
870

871 872
		rx_desc = E1000_RX_DESC_EXT(*rx_ring, i);
		rx_desc->read.buffer_addr = cpu_to_le64(buffer_info->dma);
873 874 875 876 877 878 879 880 881 882 883 884 885 886

		if (unlikely(++i == rx_ring->count))
			i = 0;
		buffer_info = &rx_ring->buffer_info[i];
	}

	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,
B
Bruce Allan 已提交
887 888
		 * such as IA-64).
		 */
889
		wmb();
890
		if (adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
891
			e1000e_update_rdt_wa(rx_ring, i);
892
		else
893
			writel(i, rx_ring->tail);
894 895 896
	}
}

897 898 899 900 901 902 903
static inline void e1000_rx_hash(struct net_device *netdev, __le32 rss,
				 struct sk_buff *skb)
{
	if (netdev->features & NETIF_F_RXHASH)
		skb->rxhash = le32_to_cpu(rss);
}

904
/**
905 906
 * e1000_clean_rx_irq - Send received data up the network stack
 * @rx_ring: Rx descriptor ring
907 908 909 910
 *
 * the return value indicates whether actual cleaning was done, there
 * is no guarantee that everything was cleaned
 **/
911 912
static bool e1000_clean_rx_irq(struct e1000_ring *rx_ring, int *work_done,
			       int work_to_do)
913
{
914
	struct e1000_adapter *adapter = rx_ring->adapter;
915 916
	struct net_device *netdev = adapter->netdev;
	struct pci_dev *pdev = adapter->pdev;
917
	struct e1000_hw *hw = &adapter->hw;
918
	union e1000_rx_desc_extended *rx_desc, *next_rxd;
919
	struct e1000_buffer *buffer_info, *next_buffer;
920
	u32 length, staterr;
921 922
	unsigned int i;
	int cleaned_count = 0;
923
	bool cleaned = false;
924 925 926
	unsigned int total_rx_bytes = 0, total_rx_packets = 0;

	i = rx_ring->next_to_clean;
927 928
	rx_desc = E1000_RX_DESC_EXT(*rx_ring, i);
	staterr = le32_to_cpu(rx_desc->wb.upper.status_error);
929 930
	buffer_info = &rx_ring->buffer_info[i];

931
	while (staterr & E1000_RXD_STAT_DD) {
932 933 934 935 936
		struct sk_buff *skb;

		if (*work_done >= work_to_do)
			break;
		(*work_done)++;
937
		rmb();	/* read descriptor and rx_buffer_info after status DD */
938 939 940 941 942 943 944 945 946

		skb = buffer_info->skb;
		buffer_info->skb = NULL;

		prefetch(skb->data - NET_IP_ALIGN);

		i++;
		if (i == rx_ring->count)
			i = 0;
947
		next_rxd = E1000_RX_DESC_EXT(*rx_ring, i);
948 949 950 951
		prefetch(next_rxd);

		next_buffer = &rx_ring->buffer_info[i];

952
		cleaned = true;
953
		cleaned_count++;
954
		dma_unmap_single(&pdev->dev,
955 956
				 buffer_info->dma,
				 adapter->rx_buffer_len,
957
				 DMA_FROM_DEVICE);
958 959
		buffer_info->dma = 0;

960
		length = le16_to_cpu(rx_desc->wb.upper.length);
961

B
Bruce Allan 已提交
962
		/* !EOP means multiple descriptors were used to store a single
963 964 965 966 967
		 * packet, if that's the case we need to toss it.  In fact, we
		 * need to toss every packet with the EOP bit clear and the
		 * next frame that _does_ have the EOP bit set, as it is by
		 * definition only a frame fragment
		 */
968
		if (unlikely(!(staterr & E1000_RXD_STAT_EOP)))
969 970 971
			adapter->flags2 |= FLAG2_IS_DISCARDING;

		if (adapter->flags2 & FLAG2_IS_DISCARDING) {
972
			/* All receives must fit into a single buffer */
973
			e_dbg("Receive packet consumed multiple buffers\n");
974 975
			/* recycle */
			buffer_info->skb = skb;
976
			if (staterr & E1000_RXD_STAT_EOP)
977
				adapter->flags2 &= ~FLAG2_IS_DISCARDING;
978 979 980
			goto next_desc;
		}

B
Ben Greear 已提交
981 982
		if (unlikely((staterr & E1000_RXDEXT_ERR_FRAME_ERR_MASK) &&
			     !(netdev->features & NETIF_F_RXALL))) {
983 984 985 986 987
			/* recycle */
			buffer_info->skb = skb;
			goto next_desc;
		}

J
Jeff Kirsher 已提交
988
		/* adjust length to remove Ethernet CRC */
B
Ben Greear 已提交
989 990 991 992 993 994 995 996 997 998
		if (!(adapter->flags2 & FLAG2_CRC_STRIPPING)) {
			/* If configured to store CRC, don't subtract FCS,
			 * but keep the FCS bytes out of the total_rx_bytes
			 * counter
			 */
			if (netdev->features & NETIF_F_RXFCS)
				total_rx_bytes -= 4;
			else
				length -= 4;
		}
J
Jeff Kirsher 已提交
999

1000 1001 1002
		total_rx_bytes += length;
		total_rx_packets++;

B
Bruce Allan 已提交
1003
		/* code added for copybreak, this should improve
1004
		 * performance for small packets with large amounts
1005 1006
		 * of reassembly being done in the stack
		 */
1007 1008
		if (length < copybreak) {
			struct sk_buff *new_skb =
1009
			    netdev_alloc_skb_ip_align(netdev, length);
1010
			if (new_skb) {
1011 1012 1013 1014 1015 1016
				skb_copy_to_linear_data_offset(new_skb,
							       -NET_IP_ALIGN,
							       (skb->data -
								NET_IP_ALIGN),
							       (length +
								NET_IP_ALIGN));
1017 1018 1019 1020 1021 1022 1023 1024 1025 1026
				/* save the skb in buffer_info as good */
				buffer_info->skb = skb;
				skb = new_skb;
			}
			/* else just continue with the old one */
		}
		/* end copybreak code */
		skb_put(skb, length);

		/* Receive Checksum Offload */
1027
		e1000_rx_checksum(adapter, staterr, skb);
1028

1029 1030
		e1000_rx_hash(netdev, rx_desc->wb.lower.hi_dword.rss, skb);

1031 1032
		e1000_receive_skb(adapter, netdev, skb, staterr,
				  rx_desc->wb.upper.vlan);
1033 1034

next_desc:
1035
		rx_desc->wb.upper.status_error &= cpu_to_le32(~0xFF);
1036 1037 1038

		/* return some buffers to hardware, one at a time is too slow */
		if (cleaned_count >= E1000_RX_BUFFER_WRITE) {
1039
			adapter->alloc_rx_buf(rx_ring, cleaned_count,
1040
					      GFP_ATOMIC);
1041 1042 1043 1044 1045 1046
			cleaned_count = 0;
		}

		/* use prefetched values */
		rx_desc = next_rxd;
		buffer_info = next_buffer;
1047 1048

		staterr = le32_to_cpu(rx_desc->wb.upper.status_error);
1049 1050 1051 1052 1053
	}
	rx_ring->next_to_clean = i;

	cleaned_count = e1000_desc_unused(rx_ring);
	if (cleaned_count)
1054
		adapter->alloc_rx_buf(rx_ring, cleaned_count, GFP_ATOMIC);
1055 1056

	adapter->total_rx_bytes += total_rx_bytes;
1057
	adapter->total_rx_packets += total_rx_packets;
1058 1059 1060
	return cleaned;
}

1061 1062
static void e1000_put_txbuf(struct e1000_ring *tx_ring,
			    struct e1000_buffer *buffer_info)
1063
{
1064 1065
	struct e1000_adapter *adapter = tx_ring->adapter;

1066 1067
	if (buffer_info->dma) {
		if (buffer_info->mapped_as_page)
1068 1069
			dma_unmap_page(&adapter->pdev->dev, buffer_info->dma,
				       buffer_info->length, DMA_TO_DEVICE);
1070
		else
1071 1072
			dma_unmap_single(&adapter->pdev->dev, buffer_info->dma,
					 buffer_info->length, DMA_TO_DEVICE);
1073 1074
		buffer_info->dma = 0;
	}
1075 1076 1077 1078
	if (buffer_info->skb) {
		dev_kfree_skb_any(buffer_info->skb);
		buffer_info->skb = NULL;
	}
1079
	buffer_info->time_stamp = 0;
1080 1081
}

1082
static void e1000_print_hw_hang(struct work_struct *work)
1083
{
1084 1085 1086
	struct e1000_adapter *adapter = container_of(work,
	                                             struct e1000_adapter,
	                                             print_hang_task);
1087
	struct net_device *netdev = adapter->netdev;
1088 1089 1090 1091
	struct e1000_ring *tx_ring = adapter->tx_ring;
	unsigned int i = tx_ring->next_to_clean;
	unsigned int eop = tx_ring->buffer_info[i].next_to_watch;
	struct e1000_tx_desc *eop_desc = E1000_TX_DESC(*tx_ring, eop);
1092 1093 1094 1095
	struct e1000_hw *hw = &adapter->hw;
	u16 phy_status, phy_1000t_status, phy_ext_status;
	u16 pci_status;

1096 1097 1098
	if (test_bit(__E1000_DOWN, &adapter->state))
		return;

1099 1100
	if (!adapter->tx_hang_recheck &&
	    (adapter->flags2 & FLAG2_DMA_BURST)) {
B
Bruce Allan 已提交
1101
		/* May be block on write-back, flush and detect again
1102 1103 1104 1105 1106
		 * flush pending descriptor writebacks to memory
		 */
		ew32(TIDV, adapter->tx_int_delay | E1000_TIDV_FPD);
		/* execute the writes immediately */
		e1e_flush();
B
Bruce Allan 已提交
1107
		/* Due to rare timing issues, write to TIDV again to ensure
1108 1109 1110 1111 1112
		 * the write is successful
		 */
		ew32(TIDV, adapter->tx_int_delay | E1000_TIDV_FPD);
		/* execute the writes immediately */
		e1e_flush();
1113 1114 1115 1116 1117 1118 1119
		adapter->tx_hang_recheck = true;
		return;
	}
	/* Real hang detected */
	adapter->tx_hang_recheck = false;
	netif_stop_queue(netdev);

1120 1121 1122
	e1e_rphy(hw, PHY_STATUS, &phy_status);
	e1e_rphy(hw, PHY_1000T_STATUS, &phy_1000t_status);
	e1e_rphy(hw, PHY_EXT_STATUS, &phy_ext_status);
1123

1124 1125 1126 1127
	pci_read_config_word(adapter->pdev, PCI_STATUS, &pci_status);

	/* detected Hardware unit hang */
	e_err("Detected Hardware Unit Hang:\n"
1128 1129 1130 1131 1132 1133 1134 1135
	      "  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"
1136 1137 1138 1139 1140 1141
	      "  next_to_watch.status <%x>\n"
	      "MAC Status             <%x>\n"
	      "PHY Status             <%x>\n"
	      "PHY 1000BASE-T Status  <%x>\n"
	      "PHY Extended Status    <%x>\n"
	      "PCI Status             <%x>\n",
1142 1143
	      readl(tx_ring->head),
	      readl(tx_ring->tail),
1144 1145 1146 1147 1148
	      tx_ring->next_to_use,
	      tx_ring->next_to_clean,
	      tx_ring->buffer_info[eop].time_stamp,
	      eop,
	      jiffies,
1149 1150 1151 1152 1153 1154
	      eop_desc->upper.fields.status,
	      er32(STATUS),
	      phy_status,
	      phy_1000t_status,
	      phy_ext_status,
	      pci_status);
1155 1156 1157 1158

	/* Suggest workaround for known h/w issue */
	if ((hw->mac.type == e1000_pchlan) && (er32(CTRL) & E1000_CTRL_TFCE))
		e_err("Try turning off Tx pause (flow control) via ethtool\n");
1159 1160
}

1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195
/**
 * e1000e_tx_hwtstamp_work - check for Tx time stamp
 * @work: pointer to work struct
 *
 * This work function polls the TSYNCTXCTL valid bit to determine when a
 * timestamp has been taken for the current stored skb.  The timestamp must
 * be for this skb because only one such packet is allowed in the queue.
 */
static void e1000e_tx_hwtstamp_work(struct work_struct *work)
{
	struct e1000_adapter *adapter = container_of(work, struct e1000_adapter,
						     tx_hwtstamp_work);
	struct e1000_hw *hw = &adapter->hw;

	if (!adapter->tx_hwtstamp_skb)
		return;

	if (er32(TSYNCTXCTL) & E1000_TSYNCTXCTL_VALID) {
		struct skb_shared_hwtstamps shhwtstamps;
		u64 txstmp;

		txstmp = er32(TXSTMPL);
		txstmp |= (u64)er32(TXSTMPH) << 32;

		e1000e_systim_to_hwtstamp(adapter, &shhwtstamps, txstmp);

		skb_tstamp_tx(adapter->tx_hwtstamp_skb, &shhwtstamps);
		dev_kfree_skb_any(adapter->tx_hwtstamp_skb);
		adapter->tx_hwtstamp_skb = NULL;
	} else {
		/* reschedule to check later */
		schedule_work(&adapter->tx_hwtstamp_work);
	}
}

1196 1197
/**
 * e1000_clean_tx_irq - Reclaim resources after transmit completes
1198
 * @tx_ring: Tx descriptor ring
1199 1200 1201 1202
 *
 * the return value indicates whether actual cleaning was done, there
 * is no guarantee that everything was cleaned
 **/
1203
static bool e1000_clean_tx_irq(struct e1000_ring *tx_ring)
1204
{
1205
	struct e1000_adapter *adapter = tx_ring->adapter;
1206 1207 1208 1209 1210 1211 1212
	struct net_device *netdev = adapter->netdev;
	struct e1000_hw *hw = &adapter->hw;
	struct e1000_tx_desc *tx_desc, *eop_desc;
	struct e1000_buffer *buffer_info;
	unsigned int i, eop;
	unsigned int count = 0;
	unsigned int total_tx_bytes = 0, total_tx_packets = 0;
1213
	unsigned int bytes_compl = 0, pkts_compl = 0;
1214 1215 1216 1217 1218

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

1219 1220
	while ((eop_desc->upper.data & cpu_to_le32(E1000_TXD_STAT_DD)) &&
	       (count < tx_ring->count)) {
1221
		bool cleaned = false;
1222
		rmb(); /* read buffer_info after eop_desc */
1223
		for (; !cleaned; count++) {
1224 1225 1226 1227 1228
			tx_desc = E1000_TX_DESC(*tx_ring, i);
			buffer_info = &tx_ring->buffer_info[i];
			cleaned = (i == eop);

			if (cleaned) {
1229 1230
				total_tx_packets += buffer_info->segs;
				total_tx_bytes += buffer_info->bytecount;
1231 1232 1233 1234
				if (buffer_info->skb) {
					bytes_compl += buffer_info->skb->len;
					pkts_compl++;
				}
1235 1236
			}

1237
			e1000_put_txbuf(tx_ring, buffer_info);
1238 1239 1240 1241 1242 1243 1244
			tx_desc->upper.data = 0;

			i++;
			if (i == tx_ring->count)
				i = 0;
		}

1245 1246
		if (i == tx_ring->next_to_use)
			break;
1247 1248 1249 1250 1251 1252
		eop = tx_ring->buffer_info[i].next_to_watch;
		eop_desc = E1000_TX_DESC(*tx_ring, eop);
	}

	tx_ring->next_to_clean = i;

1253 1254
	netdev_completed_queue(netdev, pkts_compl, bytes_compl);

1255
#define TX_WAKE_THRESHOLD 32
1256 1257
	if (count && netif_carrier_ok(netdev) &&
	    e1000_desc_unused(tx_ring) >= TX_WAKE_THRESHOLD) {
1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270
		/* Make sure that anybody stopping the queue after this
		 * sees the new next_to_clean.
		 */
		smp_mb();

		if (netif_queue_stopped(netdev) &&
		    !(test_bit(__E1000_DOWN, &adapter->state))) {
			netif_wake_queue(netdev);
			++adapter->restart_queue;
		}
	}

	if (adapter->detect_tx_hung) {
B
Bruce Allan 已提交
1271
		/* Detect a transmit hang in hardware, this serializes the
1272 1273
		 * check with the clearing of time_stamp and movement of i
		 */
1274
		adapter->detect_tx_hung = false;
1275 1276
		if (tx_ring->buffer_info[i].time_stamp &&
		    time_after(jiffies, tx_ring->buffer_info[i].time_stamp
1277
			       + (adapter->tx_timeout_factor * HZ)) &&
1278
		    !(er32(STATUS) & E1000_STATUS_TXOFF))
1279
			schedule_work(&adapter->print_hang_task);
1280 1281
		else
			adapter->tx_hang_recheck = false;
1282 1283 1284
	}
	adapter->total_tx_bytes += total_tx_bytes;
	adapter->total_tx_packets += total_tx_packets;
1285
	return count < tx_ring->count;
1286 1287 1288 1289
}

/**
 * e1000_clean_rx_irq_ps - Send received data up the network stack; packet split
1290
 * @rx_ring: Rx descriptor ring
1291 1292 1293 1294
 *
 * the return value indicates whether actual cleaning was done, there
 * is no guarantee that everything was cleaned
 **/
1295 1296
static bool e1000_clean_rx_irq_ps(struct e1000_ring *rx_ring, int *work_done,
				  int work_to_do)
1297
{
1298
	struct e1000_adapter *adapter = rx_ring->adapter;
1299
	struct e1000_hw *hw = &adapter->hw;
1300 1301 1302 1303 1304 1305 1306 1307 1308
	union e1000_rx_desc_packet_split *rx_desc, *next_rxd;
	struct net_device *netdev = adapter->netdev;
	struct pci_dev *pdev = adapter->pdev;
	struct e1000_buffer *buffer_info, *next_buffer;
	struct e1000_ps_page *ps_page;
	struct sk_buff *skb;
	unsigned int i, j;
	u32 length, staterr;
	int cleaned_count = 0;
1309
	bool cleaned = false;
1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321
	unsigned int total_rx_bytes = 0, total_rx_packets = 0;

	i = rx_ring->next_to_clean;
	rx_desc = E1000_RX_DESC_PS(*rx_ring, i);
	staterr = le32_to_cpu(rx_desc->wb.middle.status_error);
	buffer_info = &rx_ring->buffer_info[i];

	while (staterr & E1000_RXD_STAT_DD) {
		if (*work_done >= work_to_do)
			break;
		(*work_done)++;
		skb = buffer_info->skb;
1322
		rmb();	/* read descriptor and rx_buffer_info after status DD */
1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334

		/* in the packet split case this is header only */
		prefetch(skb->data - NET_IP_ALIGN);

		i++;
		if (i == rx_ring->count)
			i = 0;
		next_rxd = E1000_RX_DESC_PS(*rx_ring, i);
		prefetch(next_rxd);

		next_buffer = &rx_ring->buffer_info[i];

1335
		cleaned = true;
1336
		cleaned_count++;
1337
		dma_unmap_single(&pdev->dev, buffer_info->dma,
1338
				 adapter->rx_ps_bsize0, DMA_FROM_DEVICE);
1339 1340
		buffer_info->dma = 0;

1341
		/* see !EOP comment in other Rx routine */
1342 1343 1344 1345
		if (!(staterr & E1000_RXD_STAT_EOP))
			adapter->flags2 |= FLAG2_IS_DISCARDING;

		if (adapter->flags2 & FLAG2_IS_DISCARDING) {
1346
			e_dbg("Packet Split buffers didn't pick up the full packet\n");
1347
			dev_kfree_skb_irq(skb);
1348 1349
			if (staterr & E1000_RXD_STAT_EOP)
				adapter->flags2 &= ~FLAG2_IS_DISCARDING;
1350 1351 1352
			goto next_desc;
		}

B
Ben Greear 已提交
1353 1354
		if (unlikely((staterr & E1000_RXDEXT_ERR_FRAME_ERR_MASK) &&
			     !(netdev->features & NETIF_F_RXALL))) {
1355 1356 1357 1358 1359 1360 1361
			dev_kfree_skb_irq(skb);
			goto next_desc;
		}

		length = le16_to_cpu(rx_desc->wb.middle.length0);

		if (!length) {
1362
			e_dbg("Last part of the packet spanning multiple descriptors\n");
1363 1364 1365 1366 1367 1368 1369 1370
			dev_kfree_skb_irq(skb);
			goto next_desc;
		}

		/* Good Receive */
		skb_put(skb, length);

		{
B
Bruce Allan 已提交
1371
			/* this looks ugly, but it seems compiler issues make
1372 1373 1374
			 * it more efficient than reusing j
			 */
			int l1 = le16_to_cpu(rx_desc->wb.upper.length[0]);
1375

B
Bruce Allan 已提交
1376
			/* page alloc/put takes too long and effects small
1377 1378 1379
			 * packet throughput, so unsplit small packets and
			 * save the alloc/put only valid in softirq (napi)
			 * context to call kmap_*
1380
			 */
1381 1382 1383 1384 1385 1386
			if (l1 && (l1 <= copybreak) &&
			    ((length + l1) <= adapter->rx_ps_bsize0)) {
				u8 *vaddr;

				ps_page = &buffer_info->ps_pages[0];

B
Bruce Allan 已提交
1387
				/* there is no documentation about how to call
1388 1389 1390 1391 1392 1393 1394
				 * kmap_atomic, so we can't hold the mapping
				 * very long
				 */
				dma_sync_single_for_cpu(&pdev->dev,
							ps_page->dma,
							PAGE_SIZE,
							DMA_FROM_DEVICE);
1395
				vaddr = kmap_atomic(ps_page->page);
1396
				memcpy(skb_tail_pointer(skb), vaddr, l1);
1397
				kunmap_atomic(vaddr);
1398 1399 1400 1401 1402 1403
				dma_sync_single_for_device(&pdev->dev,
							   ps_page->dma,
							   PAGE_SIZE,
							   DMA_FROM_DEVICE);

				/* remove the CRC */
B
Ben Greear 已提交
1404 1405 1406 1407
				if (!(adapter->flags2 & FLAG2_CRC_STRIPPING)) {
					if (!(netdev->features & NETIF_F_RXFCS))
						l1 -= 4;
				}
1408 1409 1410 1411

				skb_put(skb, l1);
				goto copydone;
			} /* if */
1412 1413 1414 1415 1416 1417 1418
		}

		for (j = 0; j < PS_PAGE_BUFFERS; j++) {
			length = le16_to_cpu(rx_desc->wb.upper.length[j]);
			if (!length)
				break;

A
Auke Kok 已提交
1419
			ps_page = &buffer_info->ps_pages[j];
1420 1421
			dma_unmap_page(&pdev->dev, ps_page->dma, PAGE_SIZE,
				       DMA_FROM_DEVICE);
1422 1423 1424 1425 1426
			ps_page->dma = 0;
			skb_fill_page_desc(skb, j, ps_page->page, 0, length);
			ps_page->page = NULL;
			skb->len += length;
			skb->data_len += length;
1427
			skb->truesize += PAGE_SIZE;
1428 1429
		}

J
Jeff Kirsher 已提交
1430 1431 1432
		/* strip the ethernet crc, problem is we're using pages now so
		 * this whole operation can get a little cpu intensive
		 */
B
Ben Greear 已提交
1433 1434 1435 1436
		if (!(adapter->flags2 & FLAG2_CRC_STRIPPING)) {
			if (!(netdev->features & NETIF_F_RXFCS))
				pskb_trim(skb, skb->len - 4);
		}
J
Jeff Kirsher 已提交
1437

1438 1439 1440 1441
copydone:
		total_rx_bytes += skb->len;
		total_rx_packets++;

1442
		e1000_rx_checksum(adapter, staterr, skb);
1443

1444 1445
		e1000_rx_hash(netdev, rx_desc->wb.lower.hi_dword.rss, skb);

1446 1447 1448 1449
		if (rx_desc->wb.upper.header_status &
			   cpu_to_le16(E1000_RXDPS_HDRSTAT_HDRSP))
			adapter->rx_hdr_split++;

1450 1451
		e1000_receive_skb(adapter, netdev, skb, staterr,
				  rx_desc->wb.middle.vlan);
1452 1453 1454 1455 1456 1457 1458

next_desc:
		rx_desc->wb.middle.status_error &= cpu_to_le32(~0xFF);
		buffer_info->skb = NULL;

		/* return some buffers to hardware, one at a time is too slow */
		if (cleaned_count >= E1000_RX_BUFFER_WRITE) {
1459
			adapter->alloc_rx_buf(rx_ring, cleaned_count,
1460
					      GFP_ATOMIC);
1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473
			cleaned_count = 0;
		}

		/* use prefetched values */
		rx_desc = next_rxd;
		buffer_info = next_buffer;

		staterr = le32_to_cpu(rx_desc->wb.middle.status_error);
	}
	rx_ring->next_to_clean = i;

	cleaned_count = e1000_desc_unused(rx_ring);
	if (cleaned_count)
1474
		adapter->alloc_rx_buf(rx_ring, cleaned_count, GFP_ATOMIC);
1475 1476

	adapter->total_rx_bytes += total_rx_bytes;
1477
	adapter->total_rx_packets += total_rx_packets;
1478 1479 1480
	return cleaned;
}

1481 1482 1483 1484 1485 1486 1487 1488 1489
/**
 * e1000_consume_page - helper function
 **/
static void e1000_consume_page(struct e1000_buffer *bi, struct sk_buff *skb,
                               u16 length)
{
	bi->page = NULL;
	skb->len += length;
	skb->data_len += length;
1490
	skb->truesize += PAGE_SIZE;
1491 1492 1493 1494 1495 1496 1497 1498 1499
}

/**
 * e1000_clean_jumbo_rx_irq - Send received data up the network stack; legacy
 * @adapter: board private structure
 *
 * the return value indicates whether actual cleaning was done, there
 * is no guarantee that everything was cleaned
 **/
1500 1501
static bool e1000_clean_jumbo_rx_irq(struct e1000_ring *rx_ring, int *work_done,
				     int work_to_do)
1502
{
1503
	struct e1000_adapter *adapter = rx_ring->adapter;
1504 1505
	struct net_device *netdev = adapter->netdev;
	struct pci_dev *pdev = adapter->pdev;
1506
	union e1000_rx_desc_extended *rx_desc, *next_rxd;
1507
	struct e1000_buffer *buffer_info, *next_buffer;
1508
	u32 length, staterr;
1509 1510 1511 1512 1513 1514
	unsigned int i;
	int cleaned_count = 0;
	bool cleaned = false;
	unsigned int total_rx_bytes=0, total_rx_packets=0;

	i = rx_ring->next_to_clean;
1515 1516
	rx_desc = E1000_RX_DESC_EXT(*rx_ring, i);
	staterr = le32_to_cpu(rx_desc->wb.upper.status_error);
1517 1518
	buffer_info = &rx_ring->buffer_info[i];

1519
	while (staterr & E1000_RXD_STAT_DD) {
1520 1521 1522 1523 1524
		struct sk_buff *skb;

		if (*work_done >= work_to_do)
			break;
		(*work_done)++;
1525
		rmb();	/* read descriptor and rx_buffer_info after status DD */
1526 1527 1528 1529 1530 1531 1532

		skb = buffer_info->skb;
		buffer_info->skb = NULL;

		++i;
		if (i == rx_ring->count)
			i = 0;
1533
		next_rxd = E1000_RX_DESC_EXT(*rx_ring, i);
1534 1535 1536 1537 1538 1539
		prefetch(next_rxd);

		next_buffer = &rx_ring->buffer_info[i];

		cleaned = true;
		cleaned_count++;
1540 1541
		dma_unmap_page(&pdev->dev, buffer_info->dma, PAGE_SIZE,
			       DMA_FROM_DEVICE);
1542 1543
		buffer_info->dma = 0;

1544
		length = le16_to_cpu(rx_desc->wb.upper.length);
1545 1546

		/* errors is only valid for DD + EOP descriptors */
1547
		if (unlikely((staterr & E1000_RXD_STAT_EOP) &&
B
Ben Greear 已提交
1548 1549
			     ((staterr & E1000_RXDEXT_ERR_FRAME_ERR_MASK) &&
			      !(netdev->features & NETIF_F_RXALL)))) {
1550 1551 1552 1553 1554 1555 1556
			/* recycle both page and skb */
			buffer_info->skb = skb;
			/* an error means any chain goes out the window too */
			if (rx_ring->rx_skb_top)
				dev_kfree_skb_irq(rx_ring->rx_skb_top);
			rx_ring->rx_skb_top = NULL;
			goto next_desc;
1557 1558
		}

1559
#define rxtop (rx_ring->rx_skb_top)
1560
		if (!(staterr & E1000_RXD_STAT_EOP)) {
1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583
			/* this descriptor is only the beginning (or middle) */
			if (!rxtop) {
				/* this is the beginning of a chain */
				rxtop = skb;
				skb_fill_page_desc(rxtop, 0, buffer_info->page,
				                   0, length);
			} else {
				/* this is the middle of a chain */
				skb_fill_page_desc(rxtop,
				    skb_shinfo(rxtop)->nr_frags,
				    buffer_info->page, 0, length);
				/* re-use the skb, only consumed the page */
				buffer_info->skb = skb;
			}
			e1000_consume_page(buffer_info, rxtop, length);
			goto next_desc;
		} else {
			if (rxtop) {
				/* end of the chain */
				skb_fill_page_desc(rxtop,
				    skb_shinfo(rxtop)->nr_frags,
				    buffer_info->page, 0, length);
				/* re-use the current skb, we only consumed the
B
Bruce Allan 已提交
1584 1585
				 * page
				 */
1586 1587 1588 1589 1590 1591
				buffer_info->skb = skb;
				skb = rxtop;
				rxtop = NULL;
				e1000_consume_page(buffer_info, skb, length);
			} else {
				/* no chain, got EOP, this buf is the packet
B
Bruce Allan 已提交
1592 1593
				 * copybreak to save the put_page/alloc_page
				 */
1594 1595 1596
				if (length <= copybreak &&
				    skb_tailroom(skb) >= length) {
					u8 *vaddr;
1597
					vaddr = kmap_atomic(buffer_info->page);
1598 1599
					memcpy(skb_tail_pointer(skb), vaddr,
					       length);
1600
					kunmap_atomic(vaddr);
1601
					/* re-use the page, so don't erase
B
Bruce Allan 已提交
1602 1603
					 * buffer_info->page
					 */
1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614
					skb_put(skb, length);
				} else {
					skb_fill_page_desc(skb, 0,
					                   buffer_info->page, 0,
				                           length);
					e1000_consume_page(buffer_info, skb,
					                   length);
				}
			}
		}

1615 1616
		/* Receive Checksum Offload */
		e1000_rx_checksum(adapter, staterr, skb);
1617

1618 1619
		e1000_rx_hash(netdev, rx_desc->wb.lower.hi_dword.rss, skb);

1620 1621 1622 1623 1624 1625
		/* probably a little skewed due to removing CRC */
		total_rx_bytes += skb->len;
		total_rx_packets++;

		/* eth type trans needs skb->data to point to something */
		if (!pskb_may_pull(skb, ETH_HLEN)) {
1626
			e_err("pskb_may_pull failed.\n");
1627
			dev_kfree_skb_irq(skb);
1628 1629 1630
			goto next_desc;
		}

1631 1632
		e1000_receive_skb(adapter, netdev, skb, staterr,
				  rx_desc->wb.upper.vlan);
1633 1634

next_desc:
1635
		rx_desc->wb.upper.status_error &= cpu_to_le32(~0xFF);
1636 1637 1638

		/* return some buffers to hardware, one at a time is too slow */
		if (unlikely(cleaned_count >= E1000_RX_BUFFER_WRITE)) {
1639
			adapter->alloc_rx_buf(rx_ring, cleaned_count,
1640
					      GFP_ATOMIC);
1641 1642 1643 1644 1645 1646
			cleaned_count = 0;
		}

		/* use prefetched values */
		rx_desc = next_rxd;
		buffer_info = next_buffer;
1647 1648

		staterr = le32_to_cpu(rx_desc->wb.upper.status_error);
1649 1650 1651 1652 1653
	}
	rx_ring->next_to_clean = i;

	cleaned_count = e1000_desc_unused(rx_ring);
	if (cleaned_count)
1654
		adapter->alloc_rx_buf(rx_ring, cleaned_count, GFP_ATOMIC);
1655 1656 1657 1658 1659 1660

	adapter->total_rx_bytes += total_rx_bytes;
	adapter->total_rx_packets += total_rx_packets;
	return cleaned;
}

1661 1662
/**
 * e1000_clean_rx_ring - Free Rx Buffers per Queue
1663
 * @rx_ring: Rx descriptor ring
1664
 **/
1665
static void e1000_clean_rx_ring(struct e1000_ring *rx_ring)
1666
{
1667
	struct e1000_adapter *adapter = rx_ring->adapter;
1668 1669 1670 1671 1672 1673 1674 1675 1676 1677
	struct e1000_buffer *buffer_info;
	struct e1000_ps_page *ps_page;
	struct pci_dev *pdev = adapter->pdev;
	unsigned int i, j;

	/* Free all the Rx ring sk_buffs */
	for (i = 0; i < rx_ring->count; i++) {
		buffer_info = &rx_ring->buffer_info[i];
		if (buffer_info->dma) {
			if (adapter->clean_rx == e1000_clean_rx_irq)
1678
				dma_unmap_single(&pdev->dev, buffer_info->dma,
1679
						 adapter->rx_buffer_len,
1680
						 DMA_FROM_DEVICE);
1681
			else if (adapter->clean_rx == e1000_clean_jumbo_rx_irq)
1682
				dma_unmap_page(&pdev->dev, buffer_info->dma,
1683
				               PAGE_SIZE,
1684
					       DMA_FROM_DEVICE);
1685
			else if (adapter->clean_rx == e1000_clean_rx_irq_ps)
1686
				dma_unmap_single(&pdev->dev, buffer_info->dma,
1687
						 adapter->rx_ps_bsize0,
1688
						 DMA_FROM_DEVICE);
1689 1690 1691
			buffer_info->dma = 0;
		}

1692 1693 1694 1695 1696
		if (buffer_info->page) {
			put_page(buffer_info->page);
			buffer_info->page = NULL;
		}

1697 1698 1699 1700 1701 1702
		if (buffer_info->skb) {
			dev_kfree_skb(buffer_info->skb);
			buffer_info->skb = NULL;
		}

		for (j = 0; j < PS_PAGE_BUFFERS; j++) {
A
Auke Kok 已提交
1703
			ps_page = &buffer_info->ps_pages[j];
1704 1705
			if (!ps_page->page)
				break;
1706 1707
			dma_unmap_page(&pdev->dev, ps_page->dma, PAGE_SIZE,
				       DMA_FROM_DEVICE);
1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724
			ps_page->dma = 0;
			put_page(ps_page->page);
			ps_page->page = NULL;
		}
	}

	/* there also may be some cached data from a chained receive */
	if (rx_ring->rx_skb_top) {
		dev_kfree_skb(rx_ring->rx_skb_top);
		rx_ring->rx_skb_top = NULL;
	}

	/* 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;
1725
	adapter->flags2 &= ~FLAG2_IS_DISCARDING;
1726

1727
	writel(0, rx_ring->head);
1728 1729 1730 1731
	if (rx_ring->adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
		e1000e_update_rdt_wa(rx_ring, 0);
	else
		writel(0, rx_ring->tail);
1732 1733
}

1734 1735 1736 1737 1738
static void e1000e_downshift_workaround(struct work_struct *work)
{
	struct e1000_adapter *adapter = container_of(work,
					struct e1000_adapter, downshift_task);

1739 1740 1741
	if (test_bit(__E1000_DOWN, &adapter->state))
		return;

1742 1743 1744
	e1000e_gig_downshift_workaround_ich8lan(&adapter->hw);
}

1745 1746 1747 1748 1749
/**
 * e1000_intr_msi - Interrupt Handler
 * @irq: interrupt number
 * @data: pointer to a network interface device structure
 **/
1750
static irqreturn_t e1000_intr_msi(int __always_unused irq, void *data)
1751 1752 1753 1754 1755 1756
{
	struct net_device *netdev = data;
	struct e1000_adapter *adapter = netdev_priv(netdev);
	struct e1000_hw *hw = &adapter->hw;
	u32 icr = er32(ICR);

B
Bruce Allan 已提交
1757
	/* read ICR disables interrupts using IAM */
1758
	if (icr & E1000_ICR_LSC) {
1759
		hw->mac.get_link_status = true;
B
Bruce Allan 已提交
1760
		/* ICH8 workaround-- Call gig speed drop workaround on cable
1761 1762
		 * disconnect (LSC) before accessing any PHY registers
		 */
1763 1764
		if ((adapter->flags & FLAG_LSC_GIG_SPEED_DROP) &&
		    (!(er32(STATUS) & E1000_STATUS_LU)))
1765
			schedule_work(&adapter->downshift_task);
1766

B
Bruce Allan 已提交
1767
		/* 80003ES2LAN workaround-- For packet buffer work-around on
1768
		 * link down event; disable receives here in the ISR and reset
1769 1770
		 * adapter in watchdog
		 */
1771 1772 1773 1774 1775
		if (netif_carrier_ok(netdev) &&
		    adapter->flags & FLAG_RX_NEEDS_RESTART) {
			/* disable receives */
			u32 rctl = er32(RCTL);
			ew32(RCTL, rctl & ~E1000_RCTL_EN);
1776
			adapter->flags |= FLAG_RESTART_NOW;
1777 1778 1779 1780 1781 1782
		}
		/* guard against interrupt when we're going down */
		if (!test_bit(__E1000_DOWN, &adapter->state))
			mod_timer(&adapter->watchdog_timer, jiffies + 1);
	}

1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799
	/* Reset on uncorrectable ECC error */
	if ((icr & E1000_ICR_ECCER) && (hw->mac.type == e1000_pch_lpt)) {
		u32 pbeccsts = er32(PBECCSTS);

		adapter->corr_errors +=
		    pbeccsts & E1000_PBECCSTS_CORR_ERR_CNT_MASK;
		adapter->uncorr_errors +=
		    (pbeccsts & E1000_PBECCSTS_UNCORR_ERR_CNT_MASK) >>
		    E1000_PBECCSTS_UNCORR_ERR_CNT_SHIFT;

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

		/* return immediately since reset is imminent */
		return IRQ_HANDLED;
	}

1800
	if (napi_schedule_prep(&adapter->napi)) {
1801 1802 1803 1804
		adapter->total_tx_bytes = 0;
		adapter->total_tx_packets = 0;
		adapter->total_rx_bytes = 0;
		adapter->total_rx_packets = 0;
1805
		__napi_schedule(&adapter->napi);
1806 1807 1808 1809 1810 1811 1812 1813 1814 1815
	}

	return IRQ_HANDLED;
}

/**
 * e1000_intr - Interrupt Handler
 * @irq: interrupt number
 * @data: pointer to a network interface device structure
 **/
1816
static irqreturn_t e1000_intr(int __always_unused irq, void *data)
1817 1818 1819 1820 1821
{
	struct net_device *netdev = data;
	struct e1000_adapter *adapter = netdev_priv(netdev);
	struct e1000_hw *hw = &adapter->hw;
	u32 rctl, icr = er32(ICR);
1822

1823
	if (!icr || test_bit(__E1000_DOWN, &adapter->state))
1824 1825
		return IRQ_NONE;  /* Not our interrupt */

B
Bruce Allan 已提交
1826
	/* IMS will not auto-mask if INT_ASSERTED is not set, and if it is
1827 1828
	 * not set, then the adapter didn't send an interrupt
	 */
1829 1830 1831
	if (!(icr & E1000_ICR_INT_ASSERTED))
		return IRQ_NONE;

B
Bruce Allan 已提交
1832
	/* Interrupt Auto-Mask...upon reading ICR,
1833 1834 1835
	 * interrupts are masked.  No need for the
	 * IMC write
	 */
1836

1837
	if (icr & E1000_ICR_LSC) {
1838
		hw->mac.get_link_status = true;
B
Bruce Allan 已提交
1839
		/* ICH8 workaround-- Call gig speed drop workaround on cable
1840 1841
		 * disconnect (LSC) before accessing any PHY registers
		 */
1842 1843
		if ((adapter->flags & FLAG_LSC_GIG_SPEED_DROP) &&
		    (!(er32(STATUS) & E1000_STATUS_LU)))
1844
			schedule_work(&adapter->downshift_task);
1845

B
Bruce Allan 已提交
1846
		/* 80003ES2LAN workaround--
1847 1848 1849 1850 1851 1852 1853 1854 1855
		 * For packet buffer work-around on link down event;
		 * disable receives here in the ISR and
		 * reset adapter in watchdog
		 */
		if (netif_carrier_ok(netdev) &&
		    (adapter->flags & FLAG_RX_NEEDS_RESTART)) {
			/* disable receives */
			rctl = er32(RCTL);
			ew32(RCTL, rctl & ~E1000_RCTL_EN);
1856
			adapter->flags |= FLAG_RESTART_NOW;
1857 1858 1859 1860 1861 1862
		}
		/* guard against interrupt when we're going down */
		if (!test_bit(__E1000_DOWN, &adapter->state))
			mod_timer(&adapter->watchdog_timer, jiffies + 1);
	}

1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879
	/* Reset on uncorrectable ECC error */
	if ((icr & E1000_ICR_ECCER) && (hw->mac.type == e1000_pch_lpt)) {
		u32 pbeccsts = er32(PBECCSTS);

		adapter->corr_errors +=
		    pbeccsts & E1000_PBECCSTS_CORR_ERR_CNT_MASK;
		adapter->uncorr_errors +=
		    (pbeccsts & E1000_PBECCSTS_UNCORR_ERR_CNT_MASK) >>
		    E1000_PBECCSTS_UNCORR_ERR_CNT_SHIFT;

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

		/* return immediately since reset is imminent */
		return IRQ_HANDLED;
	}

1880
	if (napi_schedule_prep(&adapter->napi)) {
1881 1882 1883 1884
		adapter->total_tx_bytes = 0;
		adapter->total_tx_packets = 0;
		adapter->total_rx_bytes = 0;
		adapter->total_rx_packets = 0;
1885
		__napi_schedule(&adapter->napi);
1886 1887 1888 1889 1890
	}

	return IRQ_HANDLED;
}

1891
static irqreturn_t e1000_msix_other(int __always_unused irq, void *data)
1892 1893 1894 1895 1896 1897 1898
{
	struct net_device *netdev = data;
	struct e1000_adapter *adapter = netdev_priv(netdev);
	struct e1000_hw *hw = &adapter->hw;
	u32 icr = er32(ICR);

	if (!(icr & E1000_ICR_INT_ASSERTED)) {
1899 1900
		if (!test_bit(__E1000_DOWN, &adapter->state))
			ew32(IMS, E1000_IMS_OTHER);
1901 1902 1903 1904 1905 1906 1907 1908 1909
		return IRQ_NONE;
	}

	if (icr & adapter->eiac_mask)
		ew32(ICS, (icr & adapter->eiac_mask));

	if (icr & E1000_ICR_OTHER) {
		if (!(icr & E1000_ICR_LSC))
			goto no_link_interrupt;
1910
		hw->mac.get_link_status = true;
1911 1912 1913 1914 1915 1916
		/* guard against interrupt when we're going down */
		if (!test_bit(__E1000_DOWN, &adapter->state))
			mod_timer(&adapter->watchdog_timer, jiffies + 1);
	}

no_link_interrupt:
1917 1918
	if (!test_bit(__E1000_DOWN, &adapter->state))
		ew32(IMS, E1000_IMS_LSC | E1000_IMS_OTHER);
1919 1920 1921 1922

	return IRQ_HANDLED;
}

1923
static irqreturn_t e1000_intr_msix_tx(int __always_unused irq, void *data)
1924 1925 1926 1927 1928 1929 1930 1931 1932 1933
{
	struct net_device *netdev = data;
	struct e1000_adapter *adapter = netdev_priv(netdev);
	struct e1000_hw *hw = &adapter->hw;
	struct e1000_ring *tx_ring = adapter->tx_ring;


	adapter->total_tx_bytes = 0;
	adapter->total_tx_packets = 0;

1934
	if (!e1000_clean_tx_irq(tx_ring))
1935 1936 1937 1938 1939 1940
		/* Ring was not completely cleaned, so fire another interrupt */
		ew32(ICS, tx_ring->ims_val);

	return IRQ_HANDLED;
}

1941
static irqreturn_t e1000_intr_msix_rx(int __always_unused irq, void *data)
1942 1943 1944
{
	struct net_device *netdev = data;
	struct e1000_adapter *adapter = netdev_priv(netdev);
1945
	struct e1000_ring *rx_ring = adapter->rx_ring;
1946 1947 1948 1949

	/* Write the ITR value calculated at the end of the
	 * previous interrupt.
	 */
1950 1951 1952 1953
	if (rx_ring->set_itr) {
		writel(1000000000 / (rx_ring->itr_val * 256),
		       rx_ring->itr_register);
		rx_ring->set_itr = 0;
1954 1955
	}

1956
	if (napi_schedule_prep(&adapter->napi)) {
1957 1958
		adapter->total_rx_bytes = 0;
		adapter->total_rx_packets = 0;
1959
		__napi_schedule(&adapter->napi);
1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992
	}
	return IRQ_HANDLED;
}

/**
 * e1000_configure_msix - Configure MSI-X hardware
 *
 * e1000_configure_msix sets up the hardware to properly
 * generate MSI-X interrupts.
 **/
static void e1000_configure_msix(struct e1000_adapter *adapter)
{
	struct e1000_hw *hw = &adapter->hw;
	struct e1000_ring *rx_ring = adapter->rx_ring;
	struct e1000_ring *tx_ring = adapter->tx_ring;
	int vector = 0;
	u32 ctrl_ext, ivar = 0;

	adapter->eiac_mask = 0;

	/* Workaround issue with spurious interrupts on 82574 in MSI-X mode */
	if (hw->mac.type == e1000_82574) {
		u32 rfctl = er32(RFCTL);
		rfctl |= E1000_RFCTL_ACK_DIS;
		ew32(RFCTL, rfctl);
	}

#define E1000_IVAR_INT_ALLOC_VALID	0x8
	/* Configure Rx vector */
	rx_ring->ims_val = E1000_IMS_RXQ0;
	adapter->eiac_mask |= rx_ring->ims_val;
	if (rx_ring->itr_val)
		writel(1000000000 / (rx_ring->itr_val * 256),
1993
		       rx_ring->itr_register);
1994
	else
1995
		writel(1, rx_ring->itr_register);
1996 1997 1998 1999 2000 2001 2002
	ivar = E1000_IVAR_INT_ALLOC_VALID | vector;

	/* Configure Tx vector */
	tx_ring->ims_val = E1000_IMS_TXQ0;
	vector++;
	if (tx_ring->itr_val)
		writel(1000000000 / (tx_ring->itr_val * 256),
2003
		       tx_ring->itr_register);
2004
	else
2005
		writel(1, tx_ring->itr_register);
2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055
	adapter->eiac_mask |= tx_ring->ims_val;
	ivar |= ((E1000_IVAR_INT_ALLOC_VALID | vector) << 8);

	/* set vector for Other Causes, e.g. link changes */
	vector++;
	ivar |= ((E1000_IVAR_INT_ALLOC_VALID | vector) << 16);
	if (rx_ring->itr_val)
		writel(1000000000 / (rx_ring->itr_val * 256),
		       hw->hw_addr + E1000_EITR_82574(vector));
	else
		writel(1, hw->hw_addr + E1000_EITR_82574(vector));

	/* Cause Tx interrupts on every write back */
	ivar |= (1 << 31);

	ew32(IVAR, ivar);

	/* enable MSI-X PBA support */
	ctrl_ext = er32(CTRL_EXT);
	ctrl_ext |= E1000_CTRL_EXT_PBA_CLR;

	/* Auto-Mask Other interrupts upon ICR read */
#define E1000_EIAC_MASK_82574   0x01F00000
	ew32(IAM, ~E1000_EIAC_MASK_82574 | E1000_IMS_OTHER);
	ctrl_ext |= E1000_CTRL_EXT_EIAME;
	ew32(CTRL_EXT, ctrl_ext);
	e1e_flush();
}

void e1000e_reset_interrupt_capability(struct e1000_adapter *adapter)
{
	if (adapter->msix_entries) {
		pci_disable_msix(adapter->pdev);
		kfree(adapter->msix_entries);
		adapter->msix_entries = NULL;
	} else if (adapter->flags & FLAG_MSI_ENABLED) {
		pci_disable_msi(adapter->pdev);
		adapter->flags &= ~FLAG_MSI_ENABLED;
	}
}

/**
 * e1000e_set_interrupt_capability - set MSI or MSI-X if supported
 *
 * Attempt to configure interrupts using the best available
 * capabilities of the hardware and kernel.
 **/
void e1000e_set_interrupt_capability(struct e1000_adapter *adapter)
{
	int err;
2056
	int i;
2057 2058 2059 2060

	switch (adapter->int_mode) {
	case E1000E_INT_MODE_MSIX:
		if (adapter->flags & FLAG_HAS_MSIX) {
2061 2062
			adapter->num_vectors = 3; /* RxQ0, TxQ0 and other */
			adapter->msix_entries = kcalloc(adapter->num_vectors,
2063 2064 2065
						      sizeof(struct msix_entry),
						      GFP_KERNEL);
			if (adapter->msix_entries) {
2066
				for (i = 0; i < adapter->num_vectors; i++)
2067 2068 2069 2070
					adapter->msix_entries[i].entry = i;

				err = pci_enable_msix(adapter->pdev,
						      adapter->msix_entries,
2071
						      adapter->num_vectors);
B
Bruce Allan 已提交
2072
				if (err == 0)
2073 2074 2075
					return;
			}
			/* MSI-X failed, so fall through and try MSI */
2076
			e_err("Failed to initialize MSI-X interrupts.  Falling back to MSI interrupts.\n");
2077 2078 2079 2080 2081 2082 2083 2084 2085
			e1000e_reset_interrupt_capability(adapter);
		}
		adapter->int_mode = E1000E_INT_MODE_MSI;
		/* Fall through */
	case E1000E_INT_MODE_MSI:
		if (!pci_enable_msi(adapter->pdev)) {
			adapter->flags |= FLAG_MSI_ENABLED;
		} else {
			adapter->int_mode = E1000E_INT_MODE_LEGACY;
2086
			e_err("Failed to initialize MSI interrupts.  Falling back to legacy interrupts.\n");
2087 2088 2089 2090 2091 2092
		}
		/* Fall through */
	case E1000E_INT_MODE_LEGACY:
		/* Don't do anything; this is the system default */
		break;
	}
2093 2094 2095

	/* store the number of vectors being used */
	adapter->num_vectors = 1;
2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109
}

/**
 * e1000_request_msix - Initialize MSI-X interrupts
 *
 * e1000_request_msix allocates MSI-X vectors and requests interrupts from the
 * kernel.
 **/
static int e1000_request_msix(struct e1000_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;
	int err = 0, vector = 0;

	if (strlen(netdev->name) < (IFNAMSIZ - 5))
2110 2111 2112
		snprintf(adapter->rx_ring->name,
			 sizeof(adapter->rx_ring->name) - 1,
			 "%s-rx-0", netdev->name);
2113 2114 2115
	else
		memcpy(adapter->rx_ring->name, netdev->name, IFNAMSIZ);
	err = request_irq(adapter->msix_entries[vector].vector,
2116
			  e1000_intr_msix_rx, 0, adapter->rx_ring->name,
2117 2118
			  netdev);
	if (err)
2119
		return err;
2120 2121
	adapter->rx_ring->itr_register = adapter->hw.hw_addr +
	    E1000_EITR_82574(vector);
2122 2123 2124 2125
	adapter->rx_ring->itr_val = adapter->itr;
	vector++;

	if (strlen(netdev->name) < (IFNAMSIZ - 5))
2126 2127 2128
		snprintf(adapter->tx_ring->name,
			 sizeof(adapter->tx_ring->name) - 1,
			 "%s-tx-0", netdev->name);
2129 2130 2131
	else
		memcpy(adapter->tx_ring->name, netdev->name, IFNAMSIZ);
	err = request_irq(adapter->msix_entries[vector].vector,
2132
			  e1000_intr_msix_tx, 0, adapter->tx_ring->name,
2133 2134
			  netdev);
	if (err)
2135
		return err;
2136 2137
	adapter->tx_ring->itr_register = adapter->hw.hw_addr +
	    E1000_EITR_82574(vector);
2138 2139 2140 2141
	adapter->tx_ring->itr_val = adapter->itr;
	vector++;

	err = request_irq(adapter->msix_entries[vector].vector,
2142
			  e1000_msix_other, 0, netdev->name, netdev);
2143
	if (err)
2144
		return err;
2145 2146

	e1000_configure_msix(adapter);
2147

2148 2149 2150
	return 0;
}

2151 2152 2153 2154 2155 2156
/**
 * e1000_request_irq - initialize interrupts
 *
 * Attempts to configure interrupts using the best available
 * capabilities of the hardware and kernel.
 **/
2157 2158 2159 2160 2161
static int e1000_request_irq(struct e1000_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;
	int err;

2162 2163 2164 2165 2166 2167 2168 2169
	if (adapter->msix_entries) {
		err = e1000_request_msix(adapter);
		if (!err)
			return err;
		/* fall back to MSI */
		e1000e_reset_interrupt_capability(adapter);
		adapter->int_mode = E1000E_INT_MODE_MSI;
		e1000e_set_interrupt_capability(adapter);
2170
	}
2171
	if (adapter->flags & FLAG_MSI_ENABLED) {
2172
		err = request_irq(adapter->pdev->irq, e1000_intr_msi, 0,
2173 2174 2175
				  netdev->name, netdev);
		if (!err)
			return err;
2176

2177 2178 2179
		/* fall back to legacy interrupt */
		e1000e_reset_interrupt_capability(adapter);
		adapter->int_mode = E1000E_INT_MODE_LEGACY;
2180 2181
	}

2182
	err = request_irq(adapter->pdev->irq, e1000_intr, IRQF_SHARED,
2183 2184 2185 2186
			  netdev->name, netdev);
	if (err)
		e_err("Unable to allocate interrupt, Error: %d\n", err);

2187 2188 2189 2190 2191 2192 2193
	return err;
}

static void e1000_free_irq(struct e1000_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;

2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205
	if (adapter->msix_entries) {
		int vector = 0;

		free_irq(adapter->msix_entries[vector].vector, netdev);
		vector++;

		free_irq(adapter->msix_entries[vector].vector, netdev);
		vector++;

		/* Other Causes interrupt vector */
		free_irq(adapter->msix_entries[vector].vector, netdev);
		return;
2206
	}
2207 2208

	free_irq(adapter->pdev->irq, netdev);
2209 2210 2211 2212 2213 2214 2215 2216 2217 2218
}

/**
 * e1000_irq_disable - Mask off interrupt generation on the NIC
 **/
static void e1000_irq_disable(struct e1000_adapter *adapter)
{
	struct e1000_hw *hw = &adapter->hw;

	ew32(IMC, ~0);
2219 2220
	if (adapter->msix_entries)
		ew32(EIAC_82574, 0);
2221
	e1e_flush();
2222 2223 2224 2225 2226 2227 2228 2229

	if (adapter->msix_entries) {
		int i;
		for (i = 0; i < adapter->num_vectors; i++)
			synchronize_irq(adapter->msix_entries[i].vector);
	} else {
		synchronize_irq(adapter->pdev->irq);
	}
2230 2231 2232 2233 2234 2235 2236 2237 2238
}

/**
 * e1000_irq_enable - Enable default interrupt generation settings
 **/
static void e1000_irq_enable(struct e1000_adapter *adapter)
{
	struct e1000_hw *hw = &adapter->hw;

2239 2240 2241
	if (adapter->msix_entries) {
		ew32(EIAC_82574, adapter->eiac_mask & E1000_EIAC_MASK_82574);
		ew32(IMS, adapter->eiac_mask | E1000_IMS_OTHER | E1000_IMS_LSC);
2242 2243
	} else if (hw->mac.type == e1000_pch_lpt) {
		ew32(IMS, IMS_ENABLE_MASK | E1000_IMS_ECCER);
2244 2245 2246
	} else {
		ew32(IMS, IMS_ENABLE_MASK);
	}
J
Jesse Brandeburg 已提交
2247
	e1e_flush();
2248 2249 2250
}

/**
2251
 * e1000e_get_hw_control - get control of the h/w from f/w
2252 2253
 * @adapter: address of board private structure
 *
2254
 * e1000e_get_hw_control sets {CTRL_EXT|SWSM}:DRV_LOAD bit.
2255 2256 2257 2258
 * For ASF and Pass Through versions of f/w this means that
 * the driver is loaded. For AMT version (only with 82573)
 * of the f/w this means that the network i/f is open.
 **/
2259
void e1000e_get_hw_control(struct e1000_adapter *adapter)
2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270
{
	struct e1000_hw *hw = &adapter->hw;
	u32 ctrl_ext;
	u32 swsm;

	/* Let firmware know the driver has taken over */
	if (adapter->flags & FLAG_HAS_SWSM_ON_LOAD) {
		swsm = er32(SWSM);
		ew32(SWSM, swsm | E1000_SWSM_DRV_LOAD);
	} else if (adapter->flags & FLAG_HAS_CTRLEXT_ON_LOAD) {
		ctrl_ext = er32(CTRL_EXT);
2271
		ew32(CTRL_EXT, ctrl_ext | E1000_CTRL_EXT_DRV_LOAD);
2272 2273 2274 2275
	}
}

/**
2276
 * e1000e_release_hw_control - release control of the h/w to f/w
2277 2278
 * @adapter: address of board private structure
 *
2279
 * e1000e_release_hw_control resets {CTRL_EXT|SWSM}:DRV_LOAD bit.
2280 2281 2282 2283 2284
 * For ASF and Pass Through versions of f/w this means that the
 * driver is no longer loaded. For AMT version (only with 82573) i
 * of the f/w this means that the network i/f is closed.
 *
 **/
2285
void e1000e_release_hw_control(struct e1000_adapter *adapter)
2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296
{
	struct e1000_hw *hw = &adapter->hw;
	u32 ctrl_ext;
	u32 swsm;

	/* Let firmware taken over control of h/w */
	if (adapter->flags & FLAG_HAS_SWSM_ON_LOAD) {
		swsm = er32(SWSM);
		ew32(SWSM, swsm & ~E1000_SWSM_DRV_LOAD);
	} else if (adapter->flags & FLAG_HAS_CTRLEXT_ON_LOAD) {
		ctrl_ext = er32(CTRL_EXT);
2297
		ew32(CTRL_EXT, ctrl_ext & ~E1000_CTRL_EXT_DRV_LOAD);
2298 2299 2300 2301
	}
}

/**
2302
 * e1000_alloc_ring_dma - allocate memory for a ring structure
2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318
 **/
static int e1000_alloc_ring_dma(struct e1000_adapter *adapter,
				struct e1000_ring *ring)
{
	struct pci_dev *pdev = adapter->pdev;

	ring->desc = dma_alloc_coherent(&pdev->dev, ring->size, &ring->dma,
					GFP_KERNEL);
	if (!ring->desc)
		return -ENOMEM;

	return 0;
}

/**
 * e1000e_setup_tx_resources - allocate Tx resources (Descriptors)
2319
 * @tx_ring: Tx descriptor ring
2320 2321 2322
 *
 * Return 0 on success, negative on failure
 **/
2323
int e1000e_setup_tx_resources(struct e1000_ring *tx_ring)
2324
{
2325
	struct e1000_adapter *adapter = tx_ring->adapter;
2326 2327 2328
	int err = -ENOMEM, size;

	size = sizeof(struct e1000_buffer) * tx_ring->count;
E
Eric Dumazet 已提交
2329
	tx_ring->buffer_info = vzalloc(size);
2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346
	if (!tx_ring->buffer_info)
		goto err;

	/* round up to nearest 4K */
	tx_ring->size = tx_ring->count * sizeof(struct e1000_tx_desc);
	tx_ring->size = ALIGN(tx_ring->size, 4096);

	err = e1000_alloc_ring_dma(adapter, tx_ring);
	if (err)
		goto err;

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

	return 0;
err:
	vfree(tx_ring->buffer_info);
2347
	e_err("Unable to allocate memory for the transmit descriptor ring\n");
2348 2349 2350 2351 2352
	return err;
}

/**
 * e1000e_setup_rx_resources - allocate Rx resources (Descriptors)
2353
 * @rx_ring: Rx descriptor ring
2354 2355 2356
 *
 * Returns 0 on success, negative on failure
 **/
2357
int e1000e_setup_rx_resources(struct e1000_ring *rx_ring)
2358
{
2359
	struct e1000_adapter *adapter = rx_ring->adapter;
A
Auke Kok 已提交
2360 2361
	struct e1000_buffer *buffer_info;
	int i, size, desc_len, err = -ENOMEM;
2362 2363

	size = sizeof(struct e1000_buffer) * rx_ring->count;
E
Eric Dumazet 已提交
2364
	rx_ring->buffer_info = vzalloc(size);
2365 2366 2367
	if (!rx_ring->buffer_info)
		goto err;

A
Auke Kok 已提交
2368 2369 2370 2371 2372 2373 2374 2375
	for (i = 0; i < rx_ring->count; i++) {
		buffer_info = &rx_ring->buffer_info[i];
		buffer_info->ps_pages = kcalloc(PS_PAGE_BUFFERS,
						sizeof(struct e1000_ps_page),
						GFP_KERNEL);
		if (!buffer_info->ps_pages)
			goto err_pages;
	}
2376 2377 2378 2379 2380 2381 2382 2383 2384

	desc_len = sizeof(union e1000_rx_desc_packet_split);

	/* Round up to nearest 4K */
	rx_ring->size = rx_ring->count * desc_len;
	rx_ring->size = ALIGN(rx_ring->size, 4096);

	err = e1000_alloc_ring_dma(adapter, rx_ring);
	if (err)
A
Auke Kok 已提交
2385
		goto err_pages;
2386 2387 2388 2389 2390 2391

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

	return 0;
A
Auke Kok 已提交
2392 2393 2394 2395 2396 2397

err_pages:
	for (i = 0; i < rx_ring->count; i++) {
		buffer_info = &rx_ring->buffer_info[i];
		kfree(buffer_info->ps_pages);
	}
2398 2399
err:
	vfree(rx_ring->buffer_info);
2400
	e_err("Unable to allocate memory for the receive descriptor ring\n");
2401 2402 2403 2404 2405
	return err;
}

/**
 * e1000_clean_tx_ring - Free Tx Buffers
2406
 * @tx_ring: Tx descriptor ring
2407
 **/
2408
static void e1000_clean_tx_ring(struct e1000_ring *tx_ring)
2409
{
2410
	struct e1000_adapter *adapter = tx_ring->adapter;
2411 2412 2413 2414 2415 2416
	struct e1000_buffer *buffer_info;
	unsigned long size;
	unsigned int i;

	for (i = 0; i < tx_ring->count; i++) {
		buffer_info = &tx_ring->buffer_info[i];
2417
		e1000_put_txbuf(tx_ring, buffer_info);
2418 2419
	}

2420
	netdev_reset_queue(adapter->netdev);
2421 2422 2423 2424 2425 2426 2427 2428
	size = sizeof(struct e1000_buffer) * tx_ring->count;
	memset(tx_ring->buffer_info, 0, size);

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

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

2429
	writel(0, tx_ring->head);
2430 2431 2432 2433
	if (tx_ring->adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
		e1000e_update_tdt_wa(tx_ring, 0);
	else
		writel(0, tx_ring->tail);
2434 2435 2436 2437
}

/**
 * e1000e_free_tx_resources - Free Tx Resources per Queue
2438
 * @tx_ring: Tx descriptor ring
2439 2440 2441
 *
 * Free all transmit software resources
 **/
2442
void e1000e_free_tx_resources(struct e1000_ring *tx_ring)
2443
{
2444
	struct e1000_adapter *adapter = tx_ring->adapter;
2445 2446
	struct pci_dev *pdev = adapter->pdev;

2447
	e1000_clean_tx_ring(tx_ring);
2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458

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

	dma_free_coherent(&pdev->dev, tx_ring->size, tx_ring->desc,
			  tx_ring->dma);
	tx_ring->desc = NULL;
}

/**
 * e1000e_free_rx_resources - Free Rx Resources
2459
 * @rx_ring: Rx descriptor ring
2460 2461 2462
 *
 * Free all receive software resources
 **/
2463
void e1000e_free_rx_resources(struct e1000_ring *rx_ring)
2464
{
2465
	struct e1000_adapter *adapter = rx_ring->adapter;
2466
	struct pci_dev *pdev = adapter->pdev;
A
Auke Kok 已提交
2467
	int i;
2468

2469
	e1000_clean_rx_ring(rx_ring);
2470

B
Bruce Allan 已提交
2471
	for (i = 0; i < rx_ring->count; i++)
A
Auke Kok 已提交
2472 2473
		kfree(rx_ring->buffer_info[i].ps_pages);

2474 2475 2476 2477 2478 2479 2480 2481 2482 2483
	vfree(rx_ring->buffer_info);
	rx_ring->buffer_info = NULL;

	dma_free_coherent(&pdev->dev, rx_ring->size, rx_ring->desc,
			  rx_ring->dma);
	rx_ring->desc = NULL;
}

/**
 * e1000_update_itr - update the dynamic ITR value based on statistics
2484 2485 2486 2487 2488
 * @adapter: pointer to adapter
 * @itr_setting: current adapter->itr
 * @packets: the number of packets during this measurement interval
 * @bytes: the number of bytes during this measurement interval
 *
2489 2490 2491 2492 2493 2494
 *      Stores a new ITR value based on packets and byte
 *      counts during the last interrupt.  The advantage of per interrupt
 *      computation is faster updates and more accurate ITR for the current
 *      traffic pattern.  Constants in this function were computed
 *      based on theoretical maximum wire speed and thresholds were set based
 *      on testing data as well as attempting to minimize response time
2495 2496
 *      while increasing bulk throughput.  This functionality is controlled
 *      by the InterruptThrottleRate module parameter.
2497
 **/
2498
static unsigned int e1000_update_itr(u16 itr_setting, int packets, int bytes)
2499 2500 2501 2502
{
	unsigned int retval = itr_setting;

	if (packets == 0)
2503
		return itr_setting;
2504 2505 2506 2507 2508 2509

	switch (itr_setting) {
	case lowest_latency:
		/* handle TSO and jumbo frames */
		if (bytes/packets > 8000)
			retval = bulk_latency;
B
Bruce Allan 已提交
2510
		else if ((packets < 5) && (bytes > 512))
2511 2512 2513 2514 2515
			retval = low_latency;
		break;
	case low_latency:  /* 50 usec aka 20000 ints/s */
		if (bytes > 10000) {
			/* this if handles the TSO accounting */
B
Bruce Allan 已提交
2516
			if (bytes/packets > 8000)
2517
				retval = bulk_latency;
B
Bruce Allan 已提交
2518
			else if ((packets < 10) || ((bytes/packets) > 1200))
2519
				retval = bulk_latency;
B
Bruce Allan 已提交
2520
			else if ((packets > 35))
2521 2522 2523 2524 2525 2526 2527 2528 2529
				retval = lowest_latency;
		} else if (bytes/packets > 2000) {
			retval = bulk_latency;
		} else if (packets <= 2 && bytes < 512) {
			retval = lowest_latency;
		}
		break;
	case bulk_latency: /* 250 usec aka 4000 ints/s */
		if (bytes > 25000) {
B
Bruce Allan 已提交
2530
			if (packets > 35)
2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552
				retval = low_latency;
		} else if (bytes < 6000) {
			retval = low_latency;
		}
		break;
	}

	return retval;
}

static void e1000_set_itr(struct e1000_adapter *adapter)
{
	u16 current_itr;
	u32 new_itr = adapter->itr;

	/* for non-gigabit speeds, just fix the interrupt rate at 4000 */
	if (adapter->link_speed != SPEED_1000) {
		current_itr = 0;
		new_itr = 4000;
		goto set_itr_now;
	}

2553 2554 2555 2556 2557
	if (adapter->flags2 & FLAG2_DISABLE_AIM) {
		new_itr = 0;
		goto set_itr_now;
	}

2558 2559 2560
	adapter->tx_itr = e1000_update_itr(adapter->tx_itr,
					   adapter->total_tx_packets,
					   adapter->total_tx_bytes);
2561 2562 2563 2564
	/* conservative mode (itr 3) eliminates the lowest_latency setting */
	if (adapter->itr_setting == 3 && adapter->tx_itr == lowest_latency)
		adapter->tx_itr = low_latency;

2565 2566 2567
	adapter->rx_itr = e1000_update_itr(adapter->rx_itr,
					   adapter->total_rx_packets,
					   adapter->total_rx_bytes);
2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590
	/* conservative mode (itr 3) eliminates the lowest_latency setting */
	if (adapter->itr_setting == 3 && adapter->rx_itr == lowest_latency)
		adapter->rx_itr = low_latency;

	current_itr = max(adapter->rx_itr, adapter->tx_itr);

	switch (current_itr) {
	/* counts and packets in update_itr are dependent on these numbers */
	case lowest_latency:
		new_itr = 70000;
		break;
	case low_latency:
		new_itr = 20000; /* aka hwitr = ~200 */
		break;
	case bulk_latency:
		new_itr = 4000;
		break;
	default:
		break;
	}

set_itr_now:
	if (new_itr != adapter->itr) {
B
Bruce Allan 已提交
2591
		/* this attempts to bias the interrupt rate towards Bulk
2592
		 * by adding intermediate steps when interrupt rate is
2593 2594
		 * increasing
		 */
2595 2596 2597 2598
		new_itr = new_itr > adapter->itr ?
			     min(adapter->itr + (new_itr >> 2), new_itr) :
			     new_itr;
		adapter->itr = new_itr;
2599 2600 2601 2602
		adapter->rx_ring->itr_val = new_itr;
		if (adapter->msix_entries)
			adapter->rx_ring->set_itr = 1;
		else
B
Bruce Allan 已提交
2603
			e1000e_write_itr(adapter, new_itr);
2604 2605 2606
	}
}

2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630
/**
 * e1000e_write_itr - write the ITR value to the appropriate registers
 * @adapter: address of board private structure
 * @itr: new ITR value to program
 *
 * e1000e_write_itr determines if the adapter is in MSI-X mode
 * and, if so, writes the EITR registers with the ITR value.
 * Otherwise, it writes the ITR value into the ITR register.
 **/
void e1000e_write_itr(struct e1000_adapter *adapter, u32 itr)
{
	struct e1000_hw *hw = &adapter->hw;
	u32 new_itr = itr ? 1000000000 / (itr * 256) : 0;

	if (adapter->msix_entries) {
		int vector;

		for (vector = 0; vector < adapter->num_vectors; vector++)
			writel(new_itr, hw->hw_addr + E1000_EITR_82574(vector));
	} else {
		ew32(ITR, new_itr);
	}
}

2631 2632 2633 2634
/**
 * e1000_alloc_queues - Allocate memory for all rings
 * @adapter: board private structure to initialize
 **/
2635
static int e1000_alloc_queues(struct e1000_adapter *adapter)
2636
{
2637 2638 2639
	int size = sizeof(struct e1000_ring);

	adapter->tx_ring = kzalloc(size, GFP_KERNEL);
2640 2641
	if (!adapter->tx_ring)
		goto err;
2642 2643
	adapter->tx_ring->count = adapter->tx_ring_count;
	adapter->tx_ring->adapter = adapter;
2644

2645
	adapter->rx_ring = kzalloc(size, GFP_KERNEL);
2646 2647
	if (!adapter->rx_ring)
		goto err;
2648 2649
	adapter->rx_ring->count = adapter->rx_ring_count;
	adapter->rx_ring->adapter = adapter;
2650 2651 2652 2653 2654 2655 2656 2657 2658

	return 0;
err:
	e_err("Unable to allocate memory for queues\n");
	kfree(adapter->rx_ring);
	kfree(adapter->tx_ring);
	return -ENOMEM;
}

2659
/**
B
Bruce Allan 已提交
2660
 * e1000e_poll - NAPI Rx polling callback
2661
 * @napi: struct associated with this polling callback
B
Bruce Allan 已提交
2662
 * @weight: number of packets driver is allowed to process this poll
2663
 **/
B
Bruce Allan 已提交
2664
static int e1000e_poll(struct napi_struct *napi, int weight)
2665
{
B
Bruce Allan 已提交
2666 2667
	struct e1000_adapter *adapter = container_of(napi, struct e1000_adapter,
						     napi);
2668
	struct e1000_hw *hw = &adapter->hw;
2669
	struct net_device *poll_dev = adapter->netdev;
2670
	int tx_cleaned = 1, work_done = 0;
2671

2672
	adapter = netdev_priv(poll_dev);
2673

B
Bruce Allan 已提交
2674 2675 2676
	if (!adapter->msix_entries ||
	    (adapter->rx_ring->ims_val & adapter->tx_ring->ims_val))
		tx_cleaned = e1000_clean_tx_irq(adapter->tx_ring);
2677

B
Bruce Allan 已提交
2678
	adapter->clean_rx(adapter->rx_ring, &work_done, weight);
2679

2680
	if (!tx_cleaned)
B
Bruce Allan 已提交
2681
		work_done = weight;
2682

B
Bruce Allan 已提交
2683 2684
	/* If weight not fully consumed, exit the polling mode */
	if (work_done < weight) {
2685 2686
		if (adapter->itr_setting & 3)
			e1000_set_itr(adapter);
2687
		napi_complete(napi);
2688 2689 2690 2691 2692 2693
		if (!test_bit(__E1000_DOWN, &adapter->state)) {
			if (adapter->msix_entries)
				ew32(IMS, adapter->rx_ring->ims_val);
			else
				e1000_irq_enable(adapter);
		}
2694 2695 2696 2697 2698
	}

	return work_done;
}

2699
static int e1000_vlan_rx_add_vid(struct net_device *netdev, u16 vid)
2700 2701 2702 2703 2704 2705 2706 2707 2708
{
	struct e1000_adapter *adapter = netdev_priv(netdev);
	struct e1000_hw *hw = &adapter->hw;
	u32 vfta, index;

	/* don't update vlan cookie if already programmed */
	if ((adapter->hw.mng_cookie.status &
	     E1000_MNG_DHCP_COOKIE_STATUS_VLAN) &&
	    (vid == adapter->mng_vlan_id))
2709
		return 0;
2710

2711
	/* add VID to filter table */
2712 2713 2714 2715 2716 2717
	if (adapter->flags & FLAG_HAS_HW_VLAN_FILTER) {
		index = (vid >> 5) & 0x7F;
		vfta = E1000_READ_REG_ARRAY(hw, E1000_VFTA, index);
		vfta |= (1 << (vid & 0x1F));
		hw->mac.ops.write_vfta(hw, index, vfta);
	}
J
Jeff Kirsher 已提交
2718 2719

	set_bit(vid, adapter->active_vlans);
2720 2721

	return 0;
2722 2723
}

2724
static int e1000_vlan_rx_kill_vid(struct net_device *netdev, u16 vid)
2725 2726 2727 2728 2729 2730 2731 2732 2733
{
	struct e1000_adapter *adapter = netdev_priv(netdev);
	struct e1000_hw *hw = &adapter->hw;
	u32 vfta, index;

	if ((adapter->hw.mng_cookie.status &
	     E1000_MNG_DHCP_COOKIE_STATUS_VLAN) &&
	    (vid == adapter->mng_vlan_id)) {
		/* release control to f/w */
2734
		e1000e_release_hw_control(adapter);
2735
		return 0;
2736 2737 2738
	}

	/* remove VID from filter table */
2739 2740 2741 2742 2743 2744
	if (adapter->flags & FLAG_HAS_HW_VLAN_FILTER) {
		index = (vid >> 5) & 0x7F;
		vfta = E1000_READ_REG_ARRAY(hw, E1000_VFTA, index);
		vfta &= ~(1 << (vid & 0x1F));
		hw->mac.ops.write_vfta(hw, index, vfta);
	}
J
Jeff Kirsher 已提交
2745 2746

	clear_bit(vid, adapter->active_vlans);
2747 2748

	return 0;
2749 2750
}

J
Jeff Kirsher 已提交
2751 2752 2753 2754 2755
/**
 * e1000e_vlan_filter_disable - helper to disable hw VLAN filtering
 * @adapter: board private structure to initialize
 **/
static void e1000e_vlan_filter_disable(struct e1000_adapter *adapter)
2756 2757
{
	struct net_device *netdev = adapter->netdev;
J
Jeff Kirsher 已提交
2758 2759
	struct e1000_hw *hw = &adapter->hw;
	u32 rctl;
2760

J
Jeff Kirsher 已提交
2761 2762 2763 2764 2765 2766 2767 2768 2769
	if (adapter->flags & FLAG_HAS_HW_VLAN_FILTER) {
		/* disable VLAN receive filtering */
		rctl = er32(RCTL);
		rctl &= ~(E1000_RCTL_VFE | E1000_RCTL_CFIEN);
		ew32(RCTL, rctl);

		if (adapter->mng_vlan_id != (u16)E1000_MNG_VLAN_NONE) {
			e1000_vlan_rx_kill_vid(netdev, adapter->mng_vlan_id);
			adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
2770 2771 2772 2773
		}
	}
}

J
Jeff Kirsher 已提交
2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790
/**
 * e1000e_vlan_filter_enable - helper to enable HW VLAN filtering
 * @adapter: board private structure to initialize
 **/
static void e1000e_vlan_filter_enable(struct e1000_adapter *adapter)
{
	struct e1000_hw *hw = &adapter->hw;
	u32 rctl;

	if (adapter->flags & FLAG_HAS_HW_VLAN_FILTER) {
		/* enable VLAN receive filtering */
		rctl = er32(RCTL);
		rctl |= E1000_RCTL_VFE;
		rctl &= ~E1000_RCTL_CFIEN;
		ew32(RCTL, rctl);
	}
}
2791

J
Jeff Kirsher 已提交
2792 2793 2794 2795 2796
/**
 * e1000e_vlan_strip_enable - helper to disable HW VLAN stripping
 * @adapter: board private structure to initialize
 **/
static void e1000e_vlan_strip_disable(struct e1000_adapter *adapter)
2797 2798
{
	struct e1000_hw *hw = &adapter->hw;
J
Jeff Kirsher 已提交
2799
	u32 ctrl;
2800

J
Jeff Kirsher 已提交
2801 2802 2803 2804 2805
	/* disable VLAN tag insert/strip */
	ctrl = er32(CTRL);
	ctrl &= ~E1000_CTRL_VME;
	ew32(CTRL, ctrl);
}
2806

J
Jeff Kirsher 已提交
2807 2808 2809 2810 2811 2812 2813 2814
/**
 * e1000e_vlan_strip_enable - helper to enable HW VLAN stripping
 * @adapter: board private structure to initialize
 **/
static void e1000e_vlan_strip_enable(struct e1000_adapter *adapter)
{
	struct e1000_hw *hw = &adapter->hw;
	u32 ctrl;
2815

J
Jeff Kirsher 已提交
2816 2817 2818 2819 2820
	/* enable VLAN tag insert/strip */
	ctrl = er32(CTRL);
	ctrl |= E1000_CTRL_VME;
	ew32(CTRL, ctrl);
}
2821

J
Jeff Kirsher 已提交
2822 2823 2824 2825 2826 2827 2828 2829 2830 2831
static void e1000_update_mng_vlan(struct e1000_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;
	u16 vid = adapter->hw.mng_cookie.vlan_id;
	u16 old_vid = adapter->mng_vlan_id;

	if (adapter->hw.mng_cookie.status &
	    E1000_MNG_DHCP_COOKIE_STATUS_VLAN) {
		e1000_vlan_rx_add_vid(netdev, vid);
		adapter->mng_vlan_id = vid;
2832 2833
	}

J
Jeff Kirsher 已提交
2834 2835
	if ((old_vid != (u16)E1000_MNG_VLAN_NONE) && (vid != old_vid))
		e1000_vlan_rx_kill_vid(netdev, old_vid);
2836 2837 2838 2839 2840 2841
}

static void e1000_restore_vlan(struct e1000_adapter *adapter)
{
	u16 vid;

J
Jeff Kirsher 已提交
2842
	e1000_vlan_rx_add_vid(adapter->netdev, 0);
2843

J
Jeff Kirsher 已提交
2844
	for_each_set_bit(vid, adapter->active_vlans, VLAN_N_VID)
2845 2846 2847
		e1000_vlan_rx_add_vid(adapter->netdev, vid);
}

2848
static void e1000_init_manageability_pt(struct e1000_adapter *adapter)
2849 2850
{
	struct e1000_hw *hw = &adapter->hw;
2851
	u32 manc, manc2h, mdef, i, j;
2852 2853 2854 2855 2856 2857

	if (!(adapter->flags & FLAG_MNG_PT_ENABLED))
		return;

	manc = er32(MANC);

B
Bruce Allan 已提交
2858
	/* enable receiving management packets to the host. this will probably
2859
	 * generate destination unreachable messages from the host OS, but
2860 2861
	 * the packets will be handled on SMBUS
	 */
2862 2863
	manc |= E1000_MANC_EN_MNG2HOST;
	manc2h = er32(MANC2H);
2864 2865 2866 2867 2868 2869 2870

	switch (hw->mac.type) {
	default:
		manc2h |= (E1000_MANC2H_PORT_623 | E1000_MANC2H_PORT_664);
		break;
	case e1000_82574:
	case e1000_82583:
B
Bruce Allan 已提交
2871
		/* Check if IPMI pass-through decision filter already exists;
2872 2873 2874 2875 2876 2877
		 * if so, enable it.
		 */
		for (i = 0, j = 0; i < 8; i++) {
			mdef = er32(MDEF(i));

			/* Ignore filters with anything other than IPMI ports */
2878
			if (mdef & ~(E1000_MDEF_PORT_623 | E1000_MDEF_PORT_664))
2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905
				continue;

			/* Enable this decision filter in MANC2H */
			if (mdef)
				manc2h |= (1 << i);

			j |= mdef;
		}

		if (j == (E1000_MDEF_PORT_623 | E1000_MDEF_PORT_664))
			break;

		/* Create new decision filter in an empty filter */
		for (i = 0, j = 0; i < 8; i++)
			if (er32(MDEF(i)) == 0) {
				ew32(MDEF(i), (E1000_MDEF_PORT_623 |
					       E1000_MDEF_PORT_664));
				manc2h |= (1 << 1);
				j++;
				break;
			}

		if (!j)
			e_warn("Unable to create IPMI pass-through filter\n");
		break;
	}

2906 2907 2908 2909 2910
	ew32(MANC2H, manc2h);
	ew32(MANC, manc);
}

/**
2911
 * e1000_configure_tx - Configure Transmit Unit after Reset
2912 2913 2914 2915 2916 2917 2918 2919 2920
 * @adapter: board private structure
 *
 * Configure the Tx unit of the MAC after a reset.
 **/
static void e1000_configure_tx(struct e1000_adapter *adapter)
{
	struct e1000_hw *hw = &adapter->hw;
	struct e1000_ring *tx_ring = adapter->tx_ring;
	u64 tdba;
2921
	u32 tdlen, tarc;
2922 2923 2924 2925

	/* Setup the HW Tx Head and Tail descriptor pointers */
	tdba = tx_ring->dma;
	tdlen = tx_ring->count * sizeof(struct e1000_tx_desc);
2926 2927 2928 2929 2930 2931 2932
	ew32(TDBAL(0), (tdba & DMA_BIT_MASK(32)));
	ew32(TDBAH(0), (tdba >> 32));
	ew32(TDLEN(0), tdlen);
	ew32(TDH(0), 0);
	ew32(TDT(0), 0);
	tx_ring->head = adapter->hw.hw_addr + E1000_TDH(0);
	tx_ring->tail = adapter->hw.hw_addr + E1000_TDT(0);
2933 2934 2935

	/* Set the Tx Interrupt Delay register */
	ew32(TIDV, adapter->tx_int_delay);
2936
	/* Tx irq moderation */
2937 2938
	ew32(TADV, adapter->tx_abs_int_delay);

2939 2940 2941 2942
	if (adapter->flags2 & FLAG2_DMA_BURST) {
		u32 txdctl = er32(TXDCTL(0));
		txdctl &= ~(E1000_TXDCTL_PTHRESH | E1000_TXDCTL_HTHRESH |
			    E1000_TXDCTL_WTHRESH);
B
Bruce Allan 已提交
2943
		/* set up some performance related parameters to encourage the
2944 2945
		 * hardware to use the bus more efficiently in bursts, depends
		 * on the tx_int_delay to be enabled,
2946
		 * wthresh = 1 ==> burst write is disabled to avoid Tx stalls
2947 2948 2949
		 * hthresh = 1 ==> prefetch when one or more available
		 * pthresh = 0x1f ==> prefetch if internal cache 31 or less
		 * BEWARE: this seems to work but should be considered first if
2950
		 * there are Tx hangs or other Tx related bugs
2951 2952 2953 2954
		 */
		txdctl |= E1000_TXDCTL_DMA_BURST_ENABLE;
		ew32(TXDCTL(0), txdctl);
	}
2955 2956
	/* erratum work around: set txdctl the same for both queues */
	ew32(TXDCTL(1), er32(TXDCTL(0)));
2957

2958
	if (adapter->flags & FLAG_TARC_SPEED_MODE_BIT) {
2959
		tarc = er32(TARC(0));
B
Bruce Allan 已提交
2960
		/* set the speed mode bit, we'll clear it if we're not at
2961 2962
		 * gigabit link later
		 */
2963 2964
#define SPEED_MODE_BIT (1 << 21)
		tarc |= SPEED_MODE_BIT;
2965
		ew32(TARC(0), tarc);
2966 2967 2968 2969
	}

	/* errata: program both queues to unweighted RR */
	if (adapter->flags & FLAG_TARC_SET_BIT_ZERO) {
2970
		tarc = er32(TARC(0));
2971
		tarc |= 1;
2972 2973
		ew32(TARC(0), tarc);
		tarc = er32(TARC(1));
2974
		tarc |= 1;
2975
		ew32(TARC(1), tarc);
2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987
	}

	/* Setup Transmit Descriptor Settings for eop descriptor */
	adapter->txd_cmd = E1000_TXD_CMD_EOP | E1000_TXD_CMD_IFCS;

	/* only set IDE if we are delaying interrupts using the timers */
	if (adapter->tx_int_delay)
		adapter->txd_cmd |= E1000_TXD_CMD_IDE;

	/* enable Report Status bit */
	adapter->txd_cmd |= E1000_TXD_CMD_RS;

2988
	hw->mac.ops.config_collision_dist(hw);
2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002
}

/**
 * e1000_setup_rctl - configure the receive control registers
 * @adapter: Board private structure
 **/
#define PAGE_USE_COUNT(S) (((S) >> PAGE_SHIFT) + \
			   (((S) & (PAGE_SIZE - 1)) ? 1 : 0))
static void e1000_setup_rctl(struct e1000_adapter *adapter)
{
	struct e1000_hw *hw = &adapter->hw;
	u32 rctl, rfctl;
	u32 pages = 0;

B
Bruce Allan 已提交
3003 3004
	/* Workaround Si errata on PCHx - configure jumbo frame flow */
	if (hw->mac.type >= e1000_pch2lan) {
3005 3006 3007 3008 3009 3010
		s32 ret_val;

		if (adapter->netdev->mtu > ETH_DATA_LEN)
			ret_val = e1000_lv_jumbo_workaround_ich8lan(hw, true);
		else
			ret_val = e1000_lv_jumbo_workaround_ich8lan(hw, false);
3011 3012 3013

		if (ret_val)
			e_dbg("failed to enable jumbo frame workaround mode\n");
3014 3015
	}

3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031
	/* Program MC offset vector base */
	rctl = er32(RCTL);
	rctl &= ~(3 << E1000_RCTL_MO_SHIFT);
	rctl |= E1000_RCTL_EN | E1000_RCTL_BAM |
		E1000_RCTL_LBM_NO | E1000_RCTL_RDMTS_HALF |
		(adapter->hw.mac.mc_filter_type << E1000_RCTL_MO_SHIFT);

	/* Do not Store bad packets */
	rctl &= ~E1000_RCTL_SBP;

	/* Enable Long Packet receive */
	if (adapter->netdev->mtu <= ETH_DATA_LEN)
		rctl &= ~E1000_RCTL_LPE;
	else
		rctl |= E1000_RCTL_LPE;

J
Jeff Kirsher 已提交
3032 3033 3034 3035 3036 3037
	/* Some systems expect that the CRC is included in SMBUS traffic. The
	 * hardware strips the CRC before sending to both SMBUS (BMC) and to
	 * host memory when this is enabled
	 */
	if (adapter->flags2 & FLAG2_CRC_STRIPPING)
		rctl |= E1000_RCTL_SECRC;
3038

3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055
	/* Workaround Si errata on 82577 PHY - configure IPG for jumbos */
	if ((hw->phy.type == e1000_phy_82577) && (rctl & E1000_RCTL_LPE)) {
		u16 phy_data;

		e1e_rphy(hw, PHY_REG(770, 26), &phy_data);
		phy_data &= 0xfff8;
		phy_data |= (1 << 2);
		e1e_wphy(hw, PHY_REG(770, 26), phy_data);

		e1e_rphy(hw, 22, &phy_data);
		phy_data &= 0x0fff;
		phy_data |= (1 << 14);
		e1e_wphy(hw, 0x10, 0x2823);
		e1e_wphy(hw, 0x11, 0x0003);
		e1e_wphy(hw, 22, phy_data);
	}

3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075
	/* Setup buffer sizes */
	rctl &= ~E1000_RCTL_SZ_4096;
	rctl |= E1000_RCTL_BSEX;
	switch (adapter->rx_buffer_len) {
	case 2048:
	default:
		rctl |= E1000_RCTL_SZ_2048;
		rctl &= ~E1000_RCTL_BSEX;
		break;
	case 4096:
		rctl |= E1000_RCTL_SZ_4096;
		break;
	case 8192:
		rctl |= E1000_RCTL_SZ_8192;
		break;
	case 16384:
		rctl |= E1000_RCTL_SZ_16384;
		break;
	}

3076 3077 3078
	/* Enable Extended Status in all Receive Descriptors */
	rfctl = er32(RFCTL);
	rfctl |= E1000_RFCTL_EXTEN;
3079
	ew32(RFCTL, rfctl);
3080

B
Bruce Allan 已提交
3081
	/* 82571 and greater support packet-split where the protocol
3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095
	 * header is placed in skb->data and the packet data is
	 * placed in pages hanging off of skb_shinfo(skb)->nr_frags.
	 * In the case of a non-split, skb->data is linearly filled,
	 * followed by the page buffers.  Therefore, skb->data is
	 * sized to hold the largest protocol header.
	 *
	 * allocations using alloc_page take too long for regular MTU
	 * so only enable packet split for jumbo frames
	 *
	 * Using pages when the page size is greater than 16k wastes
	 * a lot of memory, since we allocate 3 pages at all times
	 * per packet.
	 */
	pages = PAGE_USE_COUNT(adapter->netdev->mtu);
3096
	if ((pages <= 3) && (PAGE_SIZE <= 16384) && (rctl & E1000_RCTL_LPE))
3097
		adapter->rx_ps_pages = pages;
3098 3099
	else
		adapter->rx_ps_pages = 0;
3100 3101

	if (adapter->rx_ps_pages) {
3102 3103
		u32 psrctl = 0;

A
Auke Kok 已提交
3104 3105
		/* Enable Packet split descriptors */
		rctl |= E1000_RCTL_DTYP_PS;
3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125

		psrctl |= adapter->rx_ps_bsize0 >>
			E1000_PSRCTL_BSIZE0_SHIFT;

		switch (adapter->rx_ps_pages) {
		case 3:
			psrctl |= PAGE_SIZE <<
				E1000_PSRCTL_BSIZE3_SHIFT;
		case 2:
			psrctl |= PAGE_SIZE <<
				E1000_PSRCTL_BSIZE2_SHIFT;
		case 1:
			psrctl |= PAGE_SIZE >>
				E1000_PSRCTL_BSIZE1_SHIFT;
			break;
		}

		ew32(PSRCTL, psrctl);
	}

B
Ben Greear 已提交
3126 3127 3128
	/* This is useful for sniffing bad packets. */
	if (adapter->netdev->features & NETIF_F_RXALL) {
		/* UPE and MPE will be handled by normal PROMISC logic
B
Bruce Allan 已提交
3129 3130
		 * in e1000e_set_rx_mode
		 */
B
Ben Greear 已提交
3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142
		rctl |= (E1000_RCTL_SBP | /* Receive bad packets */
			 E1000_RCTL_BAM | /* RX All Bcast Pkts */
			 E1000_RCTL_PMCF); /* RX All MAC Ctrl Pkts */

		rctl &= ~(E1000_RCTL_VFE | /* Disable VLAN filter */
			  E1000_RCTL_DPF | /* Allow filtered pause */
			  E1000_RCTL_CFIEN); /* Dis VLAN CFIEN Filter */
		/* Do not mess with E1000_CTRL_VME, it affects transmit as well,
		 * and that breaks VLANs.
		 */
	}

3143
	ew32(RCTL, rctl);
3144
	/* just started the receive unit, no need to restart */
3145
	adapter->flags &= ~FLAG_RESTART_NOW;
3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163
}

/**
 * e1000_configure_rx - Configure Receive Unit after Reset
 * @adapter: board private structure
 *
 * Configure the Rx unit of the MAC after a reset.
 **/
static void e1000_configure_rx(struct e1000_adapter *adapter)
{
	struct e1000_hw *hw = &adapter->hw;
	struct e1000_ring *rx_ring = adapter->rx_ring;
	u64 rdba;
	u32 rdlen, rctl, rxcsum, ctrl_ext;

	if (adapter->rx_ps_pages) {
		/* this is a 32 byte descriptor */
		rdlen = rx_ring->count *
3164
		    sizeof(union e1000_rx_desc_packet_split);
3165 3166
		adapter->clean_rx = e1000_clean_rx_irq_ps;
		adapter->alloc_rx_buf = e1000_alloc_rx_buffers_ps;
3167
	} else if (adapter->netdev->mtu > ETH_FRAME_LEN + ETH_FCS_LEN) {
3168
		rdlen = rx_ring->count * sizeof(union e1000_rx_desc_extended);
3169 3170
		adapter->clean_rx = e1000_clean_jumbo_rx_irq;
		adapter->alloc_rx_buf = e1000_alloc_jumbo_rx_buffers;
3171
	} else {
3172
		rdlen = rx_ring->count * sizeof(union e1000_rx_desc_extended);
3173 3174 3175 3176 3177 3178
		adapter->clean_rx = e1000_clean_rx_irq;
		adapter->alloc_rx_buf = e1000_alloc_rx_buffers;
	}

	/* disable receives while setting up the descriptors */
	rctl = er32(RCTL);
3179 3180
	if (!(adapter->flags2 & FLAG2_NO_DISABLE_RX))
		ew32(RCTL, rctl & ~E1000_RCTL_EN);
3181
	e1e_flush();
3182
	usleep_range(10000, 20000);
3183

3184
	if (adapter->flags2 & FLAG2_DMA_BURST) {
B
Bruce Allan 已提交
3185
		/* set the writeback threshold (only takes effect if the RDTR
3186
		 * is set). set GRAN=1 and write back up to 0x4 worth, and
3187
		 * enable prefetching of 0x20 Rx descriptors
3188 3189 3190 3191 3192 3193 3194 3195
		 * granularity = 01
		 * wthresh = 04,
		 * hthresh = 04,
		 * pthresh = 0x20
		 */
		ew32(RXDCTL(0), E1000_RXDCTL_DMA_BURST_ENABLE);
		ew32(RXDCTL(1), E1000_RXDCTL_DMA_BURST_ENABLE);

B
Bruce Allan 已提交
3196
		/* override the delay timers for enabling bursting, only if
3197 3198 3199 3200 3201 3202 3203 3204
		 * the value was not set by the user via module options
		 */
		if (adapter->rx_int_delay == DEFAULT_RDTR)
			adapter->rx_int_delay = BURST_RDTR;
		if (adapter->rx_abs_int_delay == DEFAULT_RADV)
			adapter->rx_abs_int_delay = BURST_RADV;
	}

3205 3206 3207 3208 3209
	/* set the Receive Delay Timer Register */
	ew32(RDTR, adapter->rx_int_delay);

	/* irq moderation */
	ew32(RADV, adapter->rx_abs_int_delay);
3210
	if ((adapter->itr_setting != 0) && (adapter->itr != 0))
3211
		e1000e_write_itr(adapter, adapter->itr);
3212 3213 3214 3215 3216 3217 3218 3219

	ctrl_ext = er32(CTRL_EXT);
	/* Auto-Mask interrupts upon ICR access */
	ctrl_ext |= E1000_CTRL_EXT_IAME;
	ew32(IAM, 0xffffffff);
	ew32(CTRL_EXT, ctrl_ext);
	e1e_flush();

B
Bruce Allan 已提交
3220
	/* Setup the HW Rx Head and Tail Descriptor Pointers and
3221 3222
	 * the Base and Length of the Rx Descriptor Ring
	 */
3223
	rdba = rx_ring->dma;
3224 3225 3226 3227 3228 3229 3230
	ew32(RDBAL(0), (rdba & DMA_BIT_MASK(32)));
	ew32(RDBAH(0), (rdba >> 32));
	ew32(RDLEN(0), rdlen);
	ew32(RDH(0), 0);
	ew32(RDT(0), 0);
	rx_ring->head = adapter->hw.hw_addr + E1000_RDH(0);
	rx_ring->tail = adapter->hw.hw_addr + E1000_RDT(0);
3231 3232 3233

	/* Enable Receive Checksum Offload for TCP and UDP */
	rxcsum = er32(RXCSUM);
3234
	if (adapter->netdev->features & NETIF_F_RXCSUM)
3235
		rxcsum |= E1000_RXCSUM_TUOFL;
3236
	else
3237 3238 3239
		rxcsum &= ~E1000_RXCSUM_TUOFL;
	ew32(RXCSUM, rxcsum);

B
Bruce Allan 已提交
3240 3241 3242 3243 3244 3245 3246 3247 3248
	/* With jumbo frames, excessive C-state transition latencies result
	 * in dropped transactions.
	 */
	if (adapter->netdev->mtu > ETH_DATA_LEN) {
		u32 lat =
		    ((er32(PBA) & E1000_PBA_RXA_MASK) * 1024 -
		     adapter->max_frame_size) * 8 / 1000;

		if (adapter->flags & FLAG_IS_ICH) {
3249 3250 3251
			u32 rxdctl = er32(RXDCTL(0));
			ew32(RXDCTL(0), rxdctl | 0x3);
		}
B
Bruce Allan 已提交
3252 3253 3254 3255 3256

		pm_qos_update_request(&adapter->netdev->pm_qos_req, lat);
	} else {
		pm_qos_update_request(&adapter->netdev->pm_qos_req,
				      PM_QOS_DEFAULT_VALUE);
3257
	}
3258 3259 3260 3261 3262 3263

	/* Enable Receives */
	ew32(RCTL, rctl);
}

/**
3264 3265
 * e1000e_write_mc_addr_list - write multicast addresses to MTA
 * @netdev: network interface device structure
3266
 *
3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303
 * Writes multicast address list to the MTA hash table.
 * Returns: -ENOMEM on failure
 *                0 on no addresses written
 *                X on writing X addresses to MTA
 */
static int e1000e_write_mc_addr_list(struct net_device *netdev)
{
	struct e1000_adapter *adapter = netdev_priv(netdev);
	struct e1000_hw *hw = &adapter->hw;
	struct netdev_hw_addr *ha;
	u8 *mta_list;
	int i;

	if (netdev_mc_empty(netdev)) {
		/* nothing to program, so clear mc list */
		hw->mac.ops.update_mc_addr_list(hw, NULL, 0);
		return 0;
	}

	mta_list = kzalloc(netdev_mc_count(netdev) * ETH_ALEN, GFP_ATOMIC);
	if (!mta_list)
		return -ENOMEM;

	/* update_mc_addr_list expects a packed array of only addresses. */
	i = 0;
	netdev_for_each_mc_addr(ha, netdev)
		memcpy(mta_list + (i++ * ETH_ALEN), ha->addr, ETH_ALEN);

	hw->mac.ops.update_mc_addr_list(hw, mta_list, i);
	kfree(mta_list);

	return netdev_mc_count(netdev);
}

/**
 * e1000e_write_uc_addr_list - write unicast addresses to RAR table
 * @netdev: network interface device structure
3304
 *
3305 3306 3307 3308
 * Writes unicast address list to the RAR table.
 * Returns: -ENOMEM on failure/insufficient address space
 *                0 on no addresses written
 *                X on writing X addresses to the RAR table
3309
 **/
3310
static int e1000e_write_uc_addr_list(struct net_device *netdev)
3311
{
3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330
	struct e1000_adapter *adapter = netdev_priv(netdev);
	struct e1000_hw *hw = &adapter->hw;
	unsigned int rar_entries = hw->mac.rar_entry_count;
	int count = 0;

	/* save a rar entry for our hardware address */
	rar_entries--;

	/* save a rar entry for the LAA workaround */
	if (adapter->flags & FLAG_RESET_OVERWRITES_LAA)
		rar_entries--;

	/* return ENOMEM indicating insufficient memory for addresses */
	if (netdev_uc_count(netdev) > rar_entries)
		return -ENOMEM;

	if (!netdev_uc_empty(netdev) && rar_entries) {
		struct netdev_hw_addr *ha;

B
Bruce Allan 已提交
3331
		/* write the addresses in reverse order to avoid write
3332 3333 3334 3335 3336
		 * combining
		 */
		netdev_for_each_uc_addr(ha, netdev) {
			if (!rar_entries)
				break;
3337
			hw->mac.ops.rar_set(hw, ha->addr, rar_entries--);
3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349
			count++;
		}
	}

	/* zero out the remaining RAR entries not used above */
	for (; rar_entries > 0; rar_entries--) {
		ew32(RAH(rar_entries), 0);
		ew32(RAL(rar_entries), 0);
	}
	e1e_flush();

	return count;
3350 3351 3352
}

/**
3353
 * e1000e_set_rx_mode - secondary unicast, Multicast and Promiscuous mode set
3354 3355
 * @netdev: network interface device structure
 *
3356 3357 3358
 * The ndo_set_rx_mode entry point is called whenever the unicast or multicast
 * address list or the network interface flags are updated.  This routine is
 * responsible for configuring the hardware for proper unicast, multicast,
3359 3360
 * promiscuous mode, and all-multi behavior.
 **/
3361
static void e1000e_set_rx_mode(struct net_device *netdev)
3362 3363 3364 3365 3366 3367 3368 3369
{
	struct e1000_adapter *adapter = netdev_priv(netdev);
	struct e1000_hw *hw = &adapter->hw;
	u32 rctl;

	/* Check for Promiscuous and All Multicast modes */
	rctl = er32(RCTL);

3370 3371 3372
	/* clear the affected bits */
	rctl &= ~(E1000_RCTL_UPE | E1000_RCTL_MPE);

3373 3374
	if (netdev->flags & IFF_PROMISC) {
		rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE);
J
Jeff Kirsher 已提交
3375 3376
		/* Do not hardware filter VLANs in promisc mode */
		e1000e_vlan_filter_disable(adapter);
3377
	} else {
3378
		int count;
3379

3380 3381 3382
		if (netdev->flags & IFF_ALLMULTI) {
			rctl |= E1000_RCTL_MPE;
		} else {
B
Bruce Allan 已提交
3383
			/* Write addresses to the MTA, if the attempt fails
3384 3385 3386 3387 3388 3389
			 * then we should just turn on promiscuous mode so
			 * that we can at least receive multicast traffic
			 */
			count = e1000e_write_mc_addr_list(netdev);
			if (count < 0)
				rctl |= E1000_RCTL_MPE;
3390
		}
J
Jeff Kirsher 已提交
3391
		e1000e_vlan_filter_enable(adapter);
B
Bruce Allan 已提交
3392
		/* Write addresses to available RAR registers, if there is not
3393 3394
		 * sufficient space to store all the addresses then enable
		 * unicast promiscuous mode
3395
		 */
3396 3397 3398
		count = e1000e_write_uc_addr_list(netdev);
		if (count < 0)
			rctl |= E1000_RCTL_UPE;
3399
	}
J
Jeff Kirsher 已提交
3400

3401 3402
	ew32(RCTL, rctl);

J
Jeff Kirsher 已提交
3403 3404 3405 3406
	if (netdev->features & NETIF_F_HW_VLAN_RX)
		e1000e_vlan_strip_enable(adapter);
	else
		e1000e_vlan_strip_disable(adapter);
3407 3408
}

3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426
static void e1000e_setup_rss_hash(struct e1000_adapter *adapter)
{
	struct e1000_hw *hw = &adapter->hw;
	u32 mrqc, rxcsum;
	int i;
	static const u32 rsskey[10] = {
		0xda565a6d, 0xc20e5b25, 0x3d256741, 0xb08fa343, 0xcb2bcad0,
		0xb4307bae, 0xa32dcb77, 0x0cf23080, 0x3bb7426a, 0xfa01acbe
	};

	/* Fill out hash function seed */
	for (i = 0; i < 10; i++)
		ew32(RSSRK(i), rsskey[i]);

	/* Direct all traffic to queue 0 */
	for (i = 0; i < 32; i++)
		ew32(RETA(i), 0);

B
Bruce Allan 已提交
3427
	/* Disable raw packet checksumming so that RSS hash is placed in
3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443
	 * descriptor on writeback.
	 */
	rxcsum = er32(RXCSUM);
	rxcsum |= E1000_RXCSUM_PCSD;

	ew32(RXCSUM, rxcsum);

	mrqc = (E1000_MRQC_RSS_FIELD_IPV4 |
		E1000_MRQC_RSS_FIELD_IPV4_TCP |
		E1000_MRQC_RSS_FIELD_IPV6 |
		E1000_MRQC_RSS_FIELD_IPV6_TCP |
		E1000_MRQC_RSS_FIELD_IPV6_TCP_EX);

	ew32(MRQC, mrqc);
}

3444 3445 3446 3447 3448 3449 3450 3451
/**
 * e1000e_get_base_timinca - get default SYSTIM time increment attributes
 * @adapter: board private structure
 * @timinca: pointer to returned time increment attributes
 *
 * Get attributes for incrementing the System Time Register SYSTIML/H at
 * the default base frequency, and set the cyclecounter shift value.
 **/
3452
s32 e1000e_get_base_timinca(struct e1000_adapter *adapter, u32 *timinca)
3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523
{
	struct e1000_hw *hw = &adapter->hw;
	u32 incvalue, incperiod, shift;

	/* Make sure clock is enabled on I217 before checking the frequency */
	if ((hw->mac.type == e1000_pch_lpt) &&
	    !(er32(TSYNCTXCTL) & E1000_TSYNCTXCTL_ENABLED) &&
	    !(er32(TSYNCRXCTL) & E1000_TSYNCRXCTL_ENABLED)) {
		u32 fextnvm7 = er32(FEXTNVM7);

		if (!(fextnvm7 & (1 << 0))) {
			ew32(FEXTNVM7, fextnvm7 | (1 << 0));
			e1e_flush();
		}
	}

	switch (hw->mac.type) {
	case e1000_pch2lan:
	case e1000_pch_lpt:
		/* On I217, the clock frequency is 25MHz or 96MHz as
		 * indicated by the System Clock Frequency Indication
		 */
		if ((hw->mac.type != e1000_pch_lpt) ||
		    (er32(TSYNCRXCTL) & E1000_TSYNCRXCTL_SYSCFI)) {
			/* Stable 96MHz frequency */
			incperiod = INCPERIOD_96MHz;
			incvalue = INCVALUE_96MHz;
			shift = INCVALUE_SHIFT_96MHz;
			adapter->cc.shift = shift + INCPERIOD_SHIFT_96MHz;
			break;
		}
		/* fall-through */
	case e1000_82574:
	case e1000_82583:
		/* Stable 25MHz frequency */
		incperiod = INCPERIOD_25MHz;
		incvalue = INCVALUE_25MHz;
		shift = INCVALUE_SHIFT_25MHz;
		adapter->cc.shift = shift;
		break;
	default:
		return -EINVAL;
	}

	*timinca = ((incperiod << E1000_TIMINCA_INCPERIOD_SHIFT) |
		    ((incvalue << shift) & E1000_TIMINCA_INCVALUE_MASK));

	return 0;
}

/**
 * e1000e_config_hwtstamp - configure the hwtstamp registers and enable/disable
 * @adapter: board private structure
 *
 * Outgoing time stamping can be enabled and disabled. Play nice and
 * disable it when requested, although it shouldn't cause any overhead
 * when no packet needs it. At most one packet in the queue may be
 * marked for time stamping, otherwise it would be impossible to tell
 * for sure to which packet the hardware time stamp belongs.
 *
 * Incoming time stamping has to be configured via the hardware filters.
 * Not all combinations are supported, in particular event type has to be
 * specified. Matching the kind of event packet is not supported, with the
 * exception of "all V2 events regardless of level 2 or 4".
 **/
static int e1000e_config_hwtstamp(struct e1000_adapter *adapter)
{
	struct e1000_hw *hw = &adapter->hw;
	struct hwtstamp_config *config = &adapter->hwtstamp_config;
	u32 tsync_tx_ctl = E1000_TSYNCTXCTL_ENABLED;
	u32 tsync_rx_ctl = E1000_TSYNCRXCTL_ENABLED;
3524 3525 3526 3527
	u32 rxmtrl = 0;
	u16 rxudp = 0;
	bool is_l4 = false;
	bool is_l2 = false;
3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551
	u32 regval;
	s32 ret_val;

	if (!(adapter->flags & FLAG_HAS_HW_TIMESTAMP))
		return -EINVAL;

	/* flags reserved for future extensions - must be zero */
	if (config->flags)
		return -EINVAL;

	switch (config->tx_type) {
	case HWTSTAMP_TX_OFF:
		tsync_tx_ctl = 0;
		break;
	case HWTSTAMP_TX_ON:
		break;
	default:
		return -ERANGE;
	}

	switch (config->rx_filter) {
	case HWTSTAMP_FILTER_NONE:
		tsync_rx_ctl = 0;
		break;
3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611
	case HWTSTAMP_FILTER_PTP_V1_L4_SYNC:
		tsync_rx_ctl |= E1000_TSYNCRXCTL_TYPE_L4_V1;
		rxmtrl = E1000_RXMTRL_PTP_V1_SYNC_MESSAGE;
		is_l4 = true;
		break;
	case HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ:
		tsync_rx_ctl |= E1000_TSYNCRXCTL_TYPE_L4_V1;
		rxmtrl = E1000_RXMTRL_PTP_V1_DELAY_REQ_MESSAGE;
		is_l4 = true;
		break;
	case HWTSTAMP_FILTER_PTP_V2_L2_SYNC:
		/* Also time stamps V2 L2 Path Delay Request/Response */
		tsync_rx_ctl |= E1000_TSYNCRXCTL_TYPE_L2_V2;
		rxmtrl = E1000_RXMTRL_PTP_V2_SYNC_MESSAGE;
		is_l2 = true;
		break;
	case HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ:
		/* Also time stamps V2 L2 Path Delay Request/Response. */
		tsync_rx_ctl |= E1000_TSYNCRXCTL_TYPE_L2_V2;
		rxmtrl = E1000_RXMTRL_PTP_V2_DELAY_REQ_MESSAGE;
		is_l2 = true;
		break;
	case HWTSTAMP_FILTER_PTP_V2_L4_SYNC:
		/* Hardware cannot filter just V2 L4 Sync messages;
		 * fall-through to V2 (both L2 and L4) Sync.
		 */
	case HWTSTAMP_FILTER_PTP_V2_SYNC:
		/* Also time stamps V2 Path Delay Request/Response. */
		tsync_rx_ctl |= E1000_TSYNCRXCTL_TYPE_L2_L4_V2;
		rxmtrl = E1000_RXMTRL_PTP_V2_SYNC_MESSAGE;
		is_l2 = true;
		is_l4 = true;
		break;
	case HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ:
		/* Hardware cannot filter just V2 L4 Delay Request messages;
		 * fall-through to V2 (both L2 and L4) Delay Request.
		 */
	case HWTSTAMP_FILTER_PTP_V2_DELAY_REQ:
		/* Also time stamps V2 Path Delay Request/Response. */
		tsync_rx_ctl |= E1000_TSYNCRXCTL_TYPE_L2_L4_V2;
		rxmtrl = E1000_RXMTRL_PTP_V2_DELAY_REQ_MESSAGE;
		is_l2 = true;
		is_l4 = true;
		break;
	case HWTSTAMP_FILTER_PTP_V2_L4_EVENT:
	case HWTSTAMP_FILTER_PTP_V2_L2_EVENT:
		/* Hardware cannot filter just V2 L4 or L2 Event messages;
		 * fall-through to all V2 (both L2 and L4) Events.
		 */
	case HWTSTAMP_FILTER_PTP_V2_EVENT:
		tsync_rx_ctl |= E1000_TSYNCRXCTL_TYPE_EVENT_V2;
		config->rx_filter = HWTSTAMP_FILTER_PTP_V2_EVENT;
		is_l2 = true;
		is_l4 = true;
		break;
	case HWTSTAMP_FILTER_PTP_V1_L4_EVENT:
		/* For V1, the hardware can only filter Sync messages or
		 * Delay Request messages but not both so fall-through to
		 * time stamp all packets.
		 */
3612
	case HWTSTAMP_FILTER_ALL:
3613 3614
		is_l2 = true;
		is_l4 = true;
3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645
		tsync_rx_ctl |= E1000_TSYNCRXCTL_TYPE_ALL;
		config->rx_filter = HWTSTAMP_FILTER_ALL;
		break;
	default:
		return -ERANGE;
	}

	/* enable/disable Tx h/w time stamping */
	regval = er32(TSYNCTXCTL);
	regval &= ~E1000_TSYNCTXCTL_ENABLED;
	regval |= tsync_tx_ctl;
	ew32(TSYNCTXCTL, regval);
	if ((er32(TSYNCTXCTL) & E1000_TSYNCTXCTL_ENABLED) !=
	    (regval & E1000_TSYNCTXCTL_ENABLED)) {
		e_err("Timesync Tx Control register not set as expected\n");
		return -EAGAIN;
	}

	/* enable/disable Rx h/w time stamping */
	regval = er32(TSYNCRXCTL);
	regval &= ~(E1000_TSYNCRXCTL_ENABLED | E1000_TSYNCRXCTL_TYPE_MASK);
	regval |= tsync_rx_ctl;
	ew32(TSYNCRXCTL, regval);
	if ((er32(TSYNCRXCTL) & (E1000_TSYNCRXCTL_ENABLED |
				 E1000_TSYNCRXCTL_TYPE_MASK)) !=
	    (regval & (E1000_TSYNCRXCTL_ENABLED |
		       E1000_TSYNCRXCTL_TYPE_MASK))) {
		e_err("Timesync Rx Control register not set as expected\n");
		return -EAGAIN;
	}

3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661
	/* L2: define ethertype filter for time stamped packets */
	if (is_l2)
		rxmtrl |= ETH_P_1588;

	/* define which PTP packets get time stamped */
	ew32(RXMTRL, rxmtrl);

	/* Filter by destination port */
	if (is_l4) {
		rxudp = PTP_EV_PORT;
		cpu_to_be16s(&rxudp);
	}
	ew32(RXUDP, rxudp);

	e1e_flush();

3662
	/* Clear TSYNCRXCTL_VALID & TSYNCTXCTL_VALID bit */
3663 3664
	er32(RXSTMPH);
	er32(TXSTMPH);
3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678

	/* Get and set the System Time Register SYSTIM base frequency */
	ret_val = e1000e_get_base_timinca(adapter, &regval);
	if (ret_val)
		return ret_val;
	ew32(TIMINCA, regval);

	/* reset the ns time counter */
	timecounter_init(&adapter->tc, &adapter->cc,
			 ktime_to_ns(ktime_get_real()));

	return 0;
}

3679
/**
3680
 * e1000_configure - configure the hardware for Rx and Tx
3681 3682 3683 3684
 * @adapter: private board structure
 **/
static void e1000_configure(struct e1000_adapter *adapter)
{
3685 3686
	struct e1000_ring *rx_ring = adapter->rx_ring;

3687
	e1000e_set_rx_mode(adapter->netdev);
3688 3689

	e1000_restore_vlan(adapter);
3690
	e1000_init_manageability_pt(adapter);
3691 3692

	e1000_configure_tx(adapter);
3693 3694 3695

	if (adapter->netdev->features & NETIF_F_RXHASH)
		e1000e_setup_rss_hash(adapter);
3696 3697
	e1000_setup_rctl(adapter);
	e1000_configure_rx(adapter);
3698
	adapter->alloc_rx_buf(rx_ring, e1000_desc_unused(rx_ring), GFP_KERNEL);
3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710
}

/**
 * e1000e_power_up_phy - restore link in case the phy was powered down
 * @adapter: address of board private structure
 *
 * The phy may be powered down to save power and turn off link when the
 * driver is unloaded and wake on lan is not enabled (among others)
 * *** this routine MUST be followed by a call to e1000e_reset ***
 **/
void e1000e_power_up_phy(struct e1000_adapter *adapter)
{
3711 3712
	if (adapter->hw.phy.ops.power_up)
		adapter->hw.phy.ops.power_up(&adapter->hw);
3713 3714 3715 3716 3717 3718 3719

	adapter->hw.mac.ops.setup_link(&adapter->hw);
}

/**
 * e1000_power_down_phy - Power down the PHY
 *
3720 3721
 * Power down the PHY so no link is implied when interface is down.
 * The PHY cannot be powered down if management or WoL is active.
3722 3723 3724 3725
 */
static void e1000_power_down_phy(struct e1000_adapter *adapter)
{
	/* WoL is enabled */
3726
	if (adapter->wol)
3727 3728
		return;

3729 3730
	if (adapter->hw.phy.ops.power_down)
		adapter->hw.phy.ops.power_down(&adapter->hw);
3731 3732 3733 3734 3735 3736 3737 3738
}

/**
 * e1000e_reset - bring the hardware into a known good state
 *
 * This function boots the hardware and enables some settings that
 * require a configuration cycle of the hardware - those cannot be
 * set/changed during runtime. After reset the device needs to be
3739
 * properly configured for Rx, Tx etc.
3740 3741 3742 3743
 */
void e1000e_reset(struct e1000_adapter *adapter)
{
	struct e1000_mac_info *mac = &adapter->hw.mac;
3744
	struct e1000_fc_info *fc = &adapter->hw.fc;
3745 3746
	struct e1000_hw *hw = &adapter->hw;
	u32 tx_space, min_tx_space, min_rx_space;
3747
	u32 pba = adapter->pba;
3748 3749
	u16 hwm;

3750
	/* reset Packet Buffer Allocation to default */
3751
	ew32(PBA, pba);
3752

3753
	if (adapter->max_frame_size > ETH_FRAME_LEN + ETH_FCS_LEN) {
B
Bruce Allan 已提交
3754
		/* To maintain wire speed transmits, the Tx FIFO should be
3755 3756 3757 3758
		 * large enough to accommodate two full transmit packets,
		 * rounded up to the next 1KB and expressed in KB.  Likewise,
		 * the Rx FIFO should be large enough to accommodate at least
		 * one full receive packet and is similarly rounded up and
3759 3760
		 * expressed in KB.
		 */
3761
		pba = er32(PBA);
3762
		/* upper 16 bits has Tx packet buffer allocation size in KB */
3763
		tx_space = pba >> 16;
3764
		/* lower 16 bits has Rx packet buffer allocation size in KB */
3765
		pba &= 0xffff;
B
Bruce Allan 已提交
3766
		/* the Tx fifo also stores 16 bytes of information about the Tx
3767
		 * but don't include ethernet FCS because hardware appends it
3768 3769
		 */
		min_tx_space = (adapter->max_frame_size +
3770 3771 3772 3773 3774
				sizeof(struct e1000_tx_desc) -
				ETH_FCS_LEN) * 2;
		min_tx_space = ALIGN(min_tx_space, 1024);
		min_tx_space >>= 10;
		/* software strips receive CRC, so leave room for it */
3775
		min_rx_space = adapter->max_frame_size;
3776 3777 3778
		min_rx_space = ALIGN(min_rx_space, 1024);
		min_rx_space >>= 10;

B
Bruce Allan 已提交
3779
		/* If current Tx allocation is less than the min Tx FIFO size,
3780
		 * and the min Tx FIFO size is less than the current Rx FIFO
3781 3782
		 * allocation, take space away from current Rx allocation
		 */
3783 3784 3785
		if ((tx_space < min_tx_space) &&
		    ((min_tx_space - tx_space) < pba)) {
			pba -= min_tx_space - tx_space;
3786

B
Bruce Allan 已提交
3787
			/* if short on Rx space, Rx wins and must trump Tx
3788
			 * adjustment
3789
			 */
3790
			if (pba < min_rx_space)
3791
				pba = min_rx_space;
3792
		}
3793 3794

		ew32(PBA, pba);
3795 3796
	}

B
Bruce Allan 已提交
3797
	/* flow control settings
3798
	 *
3799
	 * The high water mark must be low enough to fit one full frame
3800 3801 3802
	 * (or the size used for early receive) above it in the Rx FIFO.
	 * Set it to the lower of:
	 * - 90% of the Rx FIFO size, and
3803
	 * - the full Rx FIFO size minus one full frame
3804
	 */
3805 3806 3807 3808
	if (adapter->flags & FLAG_DISABLE_FC_PAUSE_TIME)
		fc->pause_time = 0xFFFF;
	else
		fc->pause_time = E1000_FC_PAUSE_TIME;
3809
	fc->send_xon = true;
3810 3811 3812
	fc->current_mode = fc->requested_mode;

	switch (hw->mac.type) {
3813 3814 3815 3816 3817 3818 3819 3820 3821 3822
	case e1000_ich9lan:
	case e1000_ich10lan:
		if (adapter->netdev->mtu > ETH_DATA_LEN) {
			pba = 14;
			ew32(PBA, pba);
			fc->high_water = 0x2800;
			fc->low_water = fc->high_water - 8;
			break;
		}
		/* fall-through */
3823
	default:
3824 3825
		hwm = min(((pba << 10) * 9 / 10),
			  ((pba << 10) - adapter->max_frame_size));
3826 3827 3828 3829 3830

		fc->high_water = hwm & E1000_FCRTH_RTH; /* 8-byte granularity */
		fc->low_water = fc->high_water - 8;
		break;
	case e1000_pchlan:
B
Bruce Allan 已提交
3831
		/* Workaround PCH LOM adapter hangs with certain network
3832 3833 3834 3835 3836 3837 3838 3839 3840
		 * loads.  If hangs persist, try disabling Tx flow control.
		 */
		if (adapter->netdev->mtu > ETH_DATA_LEN) {
			fc->high_water = 0x3500;
			fc->low_water  = 0x1500;
		} else {
			fc->high_water = 0x5000;
			fc->low_water  = 0x3000;
		}
3841
		fc->refresh_time = 0x1000;
3842 3843
		break;
	case e1000_pch2lan:
B
Bruce Allan 已提交
3844
	case e1000_pch_lpt:
3845
		fc->refresh_time = 0x0400;
3846 3847 3848 3849 3850 3851

		if (adapter->netdev->mtu <= ETH_DATA_LEN) {
			fc->high_water = 0x05C20;
			fc->low_water = 0x05048;
			fc->pause_time = 0x0650;
			break;
3852
		}
3853 3854 3855

		fc->high_water = ((pba << 10) * 9 / 10) & E1000_FCRTH_RTH;
		fc->low_water = ((pba << 10) * 8 / 10) & E1000_FCRTL_RTL;
3856
		break;
3857
	}
3858

B
Bruce Allan 已提交
3859
	/* Alignment of Tx data is on an arbitrary byte boundary with the
3860 3861 3862 3863 3864 3865 3866
	 * maximum size per Tx descriptor limited only to the transmit
	 * allocation of the packet buffer minus 96 bytes with an upper
	 * limit of 24KB due to receive synchronization limitations.
	 */
	adapter->tx_fifo_limit = min_t(u32, ((er32(PBA) >> 16) << 10) - 96,
				       24 << 10);

B
Bruce Allan 已提交
3867
	/* Disable Adaptive Interrupt Moderation if 2 full packets cannot
3868
	 * fit in receive buffer.
3869 3870
	 */
	if (adapter->itr_setting & 0x3) {
3871
		if ((adapter->max_frame_size * 2) > (pba << 10)) {
3872 3873 3874 3875
			if (!(adapter->flags2 & FLAG2_DISABLE_AIM)) {
				dev_info(&adapter->pdev->dev,
					"Interrupt Throttle Rate turned off\n");
				adapter->flags2 |= FLAG2_DISABLE_AIM;
3876
				e1000e_write_itr(adapter, 0);
3877 3878 3879 3880 3881 3882
			}
		} else if (adapter->flags2 & FLAG2_DISABLE_AIM) {
			dev_info(&adapter->pdev->dev,
				 "Interrupt Throttle Rate turned on\n");
			adapter->flags2 &= ~FLAG2_DISABLE_AIM;
			adapter->itr = 20000;
3883
			e1000e_write_itr(adapter, adapter->itr);
3884 3885 3886
		}
	}

3887 3888
	/* Allow time for pending master requests to run */
	mac->ops.reset_hw(hw);
3889

B
Bruce Allan 已提交
3890
	/* For parts with AMT enabled, let the firmware know
3891 3892
	 * that the network interface is in control
	 */
J
Jesse Brandeburg 已提交
3893
	if (adapter->flags & FLAG_HAS_AMT)
3894
		e1000e_get_hw_control(adapter);
3895

3896 3897 3898
	ew32(WUC, 0);

	if (mac->ops.init_hw(hw))
3899
		e_err("Hardware Error\n");
3900 3901 3902 3903 3904 3905 3906

	e1000_update_mng_vlan(adapter);

	/* Enable h/w to recognize an 802.1Q VLAN Ethernet packet */
	ew32(VET, ETH_P_8021Q);

	e1000e_reset_adaptive(hw);
3907

3908 3909 3910
	/* initialize systim and reset the ns time counter */
	e1000e_config_hwtstamp(adapter);

3911 3912 3913 3914 3915 3916
	if (!netif_running(adapter->netdev) &&
	    !test_bit(__E1000_TESTING, &adapter->state)) {
		e1000_power_down_phy(adapter);
		return;
	}

3917 3918
	e1000_get_phy_info(hw);

3919 3920
	if ((adapter->flags & FLAG_HAS_SMART_POWER_DOWN) &&
	    !(adapter->flags & FLAG_SMART_POWER_DOWN)) {
3921
		u16 phy_data = 0;
B
Bruce Allan 已提交
3922
		/* speed up time to link by disabling smart power down, ignore
3923
		 * the return value of this function because there is nothing
3924 3925
		 * different we would do if it failed
		 */
3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940
		e1e_rphy(hw, IGP02E1000_PHY_POWER_MGMT, &phy_data);
		phy_data &= ~IGP02E1000_PM_SPD;
		e1e_wphy(hw, IGP02E1000_PHY_POWER_MGMT, phy_data);
	}
}

int e1000e_up(struct e1000_adapter *adapter)
{
	struct e1000_hw *hw = &adapter->hw;

	/* hardware has been reset, we need to reload some things */
	e1000_configure(adapter);

	clear_bit(__E1000_DOWN, &adapter->state);

3941 3942
	if (adapter->msix_entries)
		e1000_configure_msix(adapter);
3943 3944
	e1000_irq_enable(adapter);

3945
	netif_start_queue(adapter->netdev);
3946

3947
	/* fire a link change interrupt to start the watchdog */
3948 3949 3950 3951 3952
	if (adapter->msix_entries)
		ew32(ICS, E1000_ICS_LSC | E1000_ICR_OTHER);
	else
		ew32(ICS, E1000_ICS_LSC);

3953 3954 3955
	return 0;
}

3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968
static void e1000e_flush_descriptors(struct e1000_adapter *adapter)
{
	struct e1000_hw *hw = &adapter->hw;

	if (!(adapter->flags2 & FLAG2_DMA_BURST))
		return;

	/* flush pending descriptor writebacks to memory */
	ew32(TIDV, adapter->tx_int_delay | E1000_TIDV_FPD);
	ew32(RDTR, adapter->rx_int_delay | E1000_RDTR_FPD);

	/* execute the writes immediately */
	e1e_flush();
3969

B
Bruce Allan 已提交
3970
	/* due to rare timing issues, write to TIDV/RDTR again to ensure the
3971 3972 3973 3974
	 * write is successful
	 */
	ew32(TIDV, adapter->tx_int_delay | E1000_TIDV_FPD);
	ew32(RDTR, adapter->rx_int_delay | E1000_RDTR_FPD);
3975 3976 3977 3978 3979

	/* execute the writes immediately */
	e1e_flush();
}

J
Jeff Kirsher 已提交
3980 3981
static void e1000e_update_stats(struct e1000_adapter *adapter);

3982 3983 3984 3985 3986 3987
void e1000e_down(struct e1000_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;
	struct e1000_hw *hw = &adapter->hw;
	u32 tctl, rctl;

B
Bruce Allan 已提交
3988
	/* signal that we're down so the interrupt handler does not
3989 3990
	 * reschedule our watchdog timer
	 */
3991 3992 3993 3994
	set_bit(__E1000_DOWN, &adapter->state);

	/* disable receives in the hardware */
	rctl = er32(RCTL);
3995 3996
	if (!(adapter->flags2 & FLAG2_NO_DISABLE_RX))
		ew32(RCTL, rctl & ~E1000_RCTL_EN);
3997 3998
	/* flush and sleep below */

3999
	netif_stop_queue(netdev);
4000 4001 4002 4003 4004

	/* disable transmits in the hardware */
	tctl = er32(TCTL);
	tctl &= ~E1000_TCTL_EN;
	ew32(TCTL, tctl);
4005

4006 4007
	/* flush both disables and wait for them to finish */
	e1e_flush();
4008
	usleep_range(10000, 20000);
4009 4010 4011 4012 4013 4014 4015

	e1000_irq_disable(adapter);

	del_timer_sync(&adapter->watchdog_timer);
	del_timer_sync(&adapter->phy_info_timer);

	netif_carrier_off(netdev);
J
Jeff Kirsher 已提交
4016 4017 4018 4019 4020

	spin_lock(&adapter->stats64_lock);
	e1000e_update_stats(adapter);
	spin_unlock(&adapter->stats64_lock);

4021
	e1000e_flush_descriptors(adapter);
4022 4023
	e1000_clean_tx_ring(adapter->tx_ring);
	e1000_clean_rx_ring(adapter->rx_ring);
4024

4025 4026 4027
	adapter->link_speed = 0;
	adapter->link_duplex = 0;

4028 4029
	if (!pci_channel_offline(adapter->pdev))
		e1000e_reset(adapter);
4030

B
Bruce Allan 已提交
4031
	/* TODO: for power management, we could drop the link and
4032 4033 4034 4035 4036 4037 4038 4039
	 * pci_disable_device here.
	 */
}

void e1000e_reinit_locked(struct e1000_adapter *adapter)
{
	might_sleep();
	while (test_and_set_bit(__E1000_RESETTING, &adapter->state))
4040
		usleep_range(1000, 2000);
4041 4042 4043 4044 4045
	e1000e_down(adapter);
	e1000e_up(adapter);
	clear_bit(__E1000_RESETTING, &adapter->state);
}

4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063
/**
 * e1000e_cyclecounter_read - read raw cycle counter (used by time counter)
 * @cc: cyclecounter structure
 **/
static cycle_t e1000e_cyclecounter_read(const struct cyclecounter *cc)
{
	struct e1000_adapter *adapter = container_of(cc, struct e1000_adapter,
						     cc);
	struct e1000_hw *hw = &adapter->hw;
	cycle_t systim;

	/* latch SYSTIMH on read of SYSTIML */
	systim = (cycle_t)er32(SYSTIML);
	systim |= (cycle_t)er32(SYSTIMH) << 32;

	return systim;
}

4064 4065 4066 4067 4068 4069 4070 4071
/**
 * e1000_sw_init - Initialize general software structures (struct e1000_adapter)
 * @adapter: board private structure to initialize
 *
 * e1000_sw_init initializes the Adapter private data structure.
 * Fields are initialized based on PCI device information and
 * OS network device settings (MTU size).
 **/
4072
static int e1000_sw_init(struct e1000_adapter *adapter)
4073 4074 4075 4076 4077
{
	struct net_device *netdev = adapter->netdev;

	adapter->rx_buffer_len = ETH_FRAME_LEN + VLAN_HLEN + ETH_FCS_LEN;
	adapter->rx_ps_bsize0 = 128;
4078 4079
	adapter->max_frame_size = netdev->mtu + ETH_HLEN + ETH_FCS_LEN;
	adapter->min_frame_size = ETH_ZLEN + ETH_FCS_LEN;
4080 4081
	adapter->tx_ring_count = E1000_DEFAULT_TXD;
	adapter->rx_ring_count = E1000_DEFAULT_RXD;
4082

J
Jeff Kirsher 已提交
4083 4084
	spin_lock_init(&adapter->stats64_lock);

4085
	e1000e_set_interrupt_capability(adapter);
4086

4087 4088
	if (e1000_alloc_queues(adapter))
		return -ENOMEM;
4089

4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100
	/* Setup hardware time stamping cyclecounter */
	if (adapter->flags & FLAG_HAS_HW_TIMESTAMP) {
		adapter->cc.read = e1000e_cyclecounter_read;
		adapter->cc.mask = CLOCKSOURCE_MASK(64);
		adapter->cc.mult = 1;
		/* cc.shift set in e1000e_get_base_tininca() */

		spin_lock_init(&adapter->systim_lock);
		INIT_WORK(&adapter->tx_hwtstamp_work, e1000e_tx_hwtstamp_work);
	}

4101 4102 4103 4104 4105 4106 4107
	/* Explicitly disable IRQ since the NIC can be in any state. */
	e1000_irq_disable(adapter);

	set_bit(__E1000_DOWN, &adapter->state);
	return 0;
}

4108 4109 4110 4111 4112
/**
 * e1000_intr_msi_test - Interrupt Handler
 * @irq: interrupt number
 * @data: pointer to a network interface device structure
 **/
4113
static irqreturn_t e1000_intr_msi_test(int __always_unused irq, void *data)
4114 4115 4116 4117 4118 4119
{
	struct net_device *netdev = data;
	struct e1000_adapter *adapter = netdev_priv(netdev);
	struct e1000_hw *hw = &adapter->hw;
	u32 icr = er32(ICR);

4120
	e_dbg("icr is %08X\n", icr);
4121 4122
	if (icr & E1000_ICR_RXSEQ) {
		adapter->flags &= ~FLAG_MSI_TEST_FAILED;
B
Bruce Allan 已提交
4123
		/* Force memory writes to complete before acknowledging the
4124 4125
		 * interrupt is handled.
		 */
4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146 4147 4148 4149
		wmb();
	}

	return IRQ_HANDLED;
}

/**
 * e1000_test_msi_interrupt - Returns 0 for successful test
 * @adapter: board private struct
 *
 * code flow taken from tg3.c
 **/
static int e1000_test_msi_interrupt(struct e1000_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;
	struct e1000_hw *hw = &adapter->hw;
	int err;

	/* poll_enable hasn't been called yet, so don't need disable */
	/* clear any pending events */
	er32(ICR);

	/* free the real vector and request a test handler */
	e1000_free_irq(adapter);
4150
	e1000e_reset_interrupt_capability(adapter);
4151 4152

	/* Assume that the test fails, if it succeeds then the test
B
Bruce Allan 已提交
4153 4154
	 * MSI irq handler will unset this flag
	 */
4155 4156 4157 4158 4159 4160
	adapter->flags |= FLAG_MSI_TEST_FAILED;

	err = pci_enable_msi(adapter->pdev);
	if (err)
		goto msi_test_failed;

4161
	err = request_irq(adapter->pdev->irq, e1000_intr_msi_test, 0,
4162 4163 4164 4165 4166 4167
			  netdev->name, netdev);
	if (err) {
		pci_disable_msi(adapter->pdev);
		goto msi_test_failed;
	}

B
Bruce Allan 已提交
4168
	/* Force memory writes to complete before enabling and firing an
4169 4170
	 * interrupt.
	 */
4171 4172 4173 4174 4175 4176 4177
	wmb();

	e1000_irq_enable(adapter);

	/* fire an unusual interrupt on the test handler */
	ew32(ICS, E1000_ICS_RXSEQ);
	e1e_flush();
4178
	msleep(100);
4179 4180 4181

	e1000_irq_disable(adapter);

4182
	rmb();			/* read flags after interrupt has been fired */
4183 4184

	if (adapter->flags & FLAG_MSI_TEST_FAILED) {
4185
		adapter->int_mode = E1000E_INT_MODE_LEGACY;
4186
		e_info("MSI interrupt test failed, using legacy interrupt.\n");
4187
	} else {
4188
		e_dbg("MSI interrupt test succeeded!\n");
4189
	}
4190 4191 4192 4193 4194

	free_irq(adapter->pdev->irq, netdev);
	pci_disable_msi(adapter->pdev);

msi_test_failed:
4195
	e1000e_set_interrupt_capability(adapter);
4196
	return e1000_request_irq(adapter);
4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214
}

/**
 * e1000_test_msi - Returns 0 if MSI test succeeds or INTx mode is restored
 * @adapter: board private struct
 *
 * code flow taken from tg3.c, called with e1000 interrupts disabled.
 **/
static int e1000_test_msi(struct e1000_adapter *adapter)
{
	int err;
	u16 pci_cmd;

	if (!(adapter->flags & FLAG_MSI_ENABLED))
		return 0;

	/* disable SERR in case the MSI write causes a master abort */
	pci_read_config_word(adapter->pdev, PCI_COMMAND, &pci_cmd);
4215 4216 4217
	if (pci_cmd & PCI_COMMAND_SERR)
		pci_write_config_word(adapter->pdev, PCI_COMMAND,
				      pci_cmd & ~PCI_COMMAND_SERR);
4218 4219 4220

	err = e1000_test_msi_interrupt(adapter);

4221 4222 4223 4224 4225 4226
	/* re-enable SERR */
	if (pci_cmd & PCI_COMMAND_SERR) {
		pci_read_config_word(adapter->pdev, PCI_COMMAND, &pci_cmd);
		pci_cmd |= PCI_COMMAND_SERR;
		pci_write_config_word(adapter->pdev, PCI_COMMAND, pci_cmd);
	}
4227 4228 4229 4230

	return err;
}

4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246
/**
 * e1000_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 e1000_open(struct net_device *netdev)
{
	struct e1000_adapter *adapter = netdev_priv(netdev);
	struct e1000_hw *hw = &adapter->hw;
4247
	struct pci_dev *pdev = adapter->pdev;
4248 4249 4250 4251 4252 4253
	int err;

	/* disallow open during test */
	if (test_bit(__E1000_TESTING, &adapter->state))
		return -EBUSY;

4254 4255
	pm_runtime_get_sync(&pdev->dev);

4256 4257
	netif_carrier_off(netdev);

4258
	/* allocate transmit descriptors */
4259
	err = e1000e_setup_tx_resources(adapter->tx_ring);
4260 4261 4262 4263
	if (err)
		goto err_setup_tx;

	/* allocate receive descriptors */
4264
	err = e1000e_setup_rx_resources(adapter->rx_ring);
4265 4266 4267
	if (err)
		goto err_setup_rx;

B
Bruce Allan 已提交
4268
	/* If AMT is enabled, let the firmware know that the network
4269 4270 4271
	 * interface is now open and reset the part to a known state.
	 */
	if (adapter->flags & FLAG_HAS_AMT) {
4272
		e1000e_get_hw_control(adapter);
4273 4274 4275
		e1000e_reset(adapter);
	}

4276 4277 4278 4279 4280 4281 4282
	e1000e_power_up_phy(adapter);

	adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
	if ((adapter->hw.mng_cookie.status &
	     E1000_MNG_DHCP_COOKIE_STATUS_VLAN))
		e1000_update_mng_vlan(adapter);

4283
	/* DMA latency requirement to workaround jumbo issue */
B
Bruce Allan 已提交
4284 4285
	pm_qos_add_request(&adapter->netdev->pm_qos_req, PM_QOS_CPU_DMA_LATENCY,
			   PM_QOS_DEFAULT_VALUE);
4286

B
Bruce Allan 已提交
4287
	/* before we allocate an interrupt, we must be ready to handle it.
4288 4289
	 * Setting DEBUG_SHIRQ in the kernel makes it fire an interrupt
	 * as soon as we call pci_request_irq, so we have to setup our
4290 4291
	 * clean_rx handler before we do so.
	 */
4292 4293 4294 4295 4296 4297
	e1000_configure(adapter);

	err = e1000_request_irq(adapter);
	if (err)
		goto err_req_irq;

B
Bruce Allan 已提交
4298
	/* Work around PCIe errata with MSI interrupts causing some chipsets to
4299 4300 4301
	 * ignore e1000e MSI messages, which means we need to test our MSI
	 * interrupt now
	 */
4302
	if (adapter->int_mode != E1000E_INT_MODE_LEGACY) {
4303 4304 4305 4306 4307 4308 4309
		err = e1000_test_msi(adapter);
		if (err) {
			e_err("Interrupt allocation failed\n");
			goto err_req_irq;
		}
	}

4310 4311 4312 4313 4314 4315 4316
	/* From here on the code is the same as e1000e_up() */
	clear_bit(__E1000_DOWN, &adapter->state);

	napi_enable(&adapter->napi);

	e1000_irq_enable(adapter);

4317
	adapter->tx_hang_recheck = false;
4318
	netif_start_queue(netdev);
4319

4320 4321 4322
	adapter->idle_check = true;
	pm_runtime_put(&pdev->dev);

4323
	/* fire a link status change interrupt to start the watchdog */
4324 4325 4326 4327
	if (adapter->msix_entries)
		ew32(ICS, E1000_ICS_LSC | E1000_ICR_OTHER);
	else
		ew32(ICS, E1000_ICS_LSC);
4328 4329 4330 4331

	return 0;

err_req_irq:
4332
	e1000e_release_hw_control(adapter);
4333
	e1000_power_down_phy(adapter);
4334
	e1000e_free_rx_resources(adapter->rx_ring);
4335
err_setup_rx:
4336
	e1000e_free_tx_resources(adapter->tx_ring);
4337 4338
err_setup_tx:
	e1000e_reset(adapter);
4339
	pm_runtime_put_sync(&pdev->dev);
4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357

	return err;
}

/**
 * e1000_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 e1000_close(struct net_device *netdev)
{
	struct e1000_adapter *adapter = netdev_priv(netdev);
4358
	struct pci_dev *pdev = adapter->pdev;
4359 4360 4361 4362
	int count = E1000_CHECK_RESET_COUNT;

	while (test_bit(__E1000_RESETTING, &adapter->state) && count--)
		usleep_range(10000, 20000);
4363 4364

	WARN_ON(test_bit(__E1000_RESETTING, &adapter->state));
4365 4366 4367

	pm_runtime_get_sync(&pdev->dev);

4368 4369
	napi_disable(&adapter->napi);

4370 4371 4372 4373
	if (!test_bit(__E1000_DOWN, &adapter->state)) {
		e1000e_down(adapter);
		e1000_free_irq(adapter);
	}
4374 4375
	e1000_power_down_phy(adapter);

4376 4377
	e1000e_free_tx_resources(adapter->tx_ring);
	e1000e_free_rx_resources(adapter->rx_ring);
4378

B
Bruce Allan 已提交
4379
	/* kill manageability vlan ID if supported, but not if a vlan with
4380 4381
	 * the same ID is registered on the host OS (let 8021q kill it)
	 */
J
Jeff Kirsher 已提交
4382 4383
	if (adapter->hw.mng_cookie.status &
	    E1000_MNG_DHCP_COOKIE_STATUS_VLAN)
4384 4385
		e1000_vlan_rx_kill_vid(netdev, adapter->mng_vlan_id);

B
Bruce Allan 已提交
4386
	/* If AMT is enabled, let the firmware know that the network
4387 4388
	 * interface is now closed
	 */
4389 4390 4391
	if ((adapter->flags & FLAG_HAS_AMT) &&
	    !test_bit(__E1000_TESTING, &adapter->state))
		e1000e_release_hw_control(adapter);
4392

B
Bruce Allan 已提交
4393
	pm_qos_remove_request(&adapter->netdev->pm_qos_req);
4394

4395 4396
	pm_runtime_put_sync(&pdev->dev);

4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408
	return 0;
}
/**
 * e1000_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 e1000_set_mac(struct net_device *netdev, void *p)
{
	struct e1000_adapter *adapter = netdev_priv(netdev);
4409
	struct e1000_hw *hw = &adapter->hw;
4410 4411 4412 4413 4414 4415 4416 4417
	struct sockaddr *addr = p;

	if (!is_valid_ether_addr(addr->sa_data))
		return -EADDRNOTAVAIL;

	memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
	memcpy(adapter->hw.mac.addr, addr->sa_data, netdev->addr_len);

4418
	hw->mac.ops.rar_set(&adapter->hw, adapter->hw.mac.addr, 0);
4419 4420 4421 4422 4423

	if (adapter->flags & FLAG_RESET_OVERWRITES_LAA) {
		/* activate the work around */
		e1000e_set_laa_state_82571(&adapter->hw, 1);

B
Bruce Allan 已提交
4424
		/* Hold a copy of the LAA in RAR[14] This is done so that
4425 4426 4427 4428
		 * between the time RAR[0] gets clobbered  and the time it
		 * gets fixed (in e1000_watchdog), the actual LAA is in one
		 * of the RARs and no incoming packets directed to this port
		 * are dropped. Eventually the LAA will be in RAR[0] and
4429 4430
		 * RAR[14]
		 */
4431 4432
		hw->mac.ops.rar_set(&adapter->hw, adapter->hw.mac.addr,
				    adapter->hw.mac.rar_entry_count - 1);
4433 4434 4435 4436 4437
	}

	return 0;
}

4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449
/**
 * e1000e_update_phy_task - work thread to update phy
 * @work: pointer to our work struct
 *
 * this worker thread exists because we must acquire a
 * semaphore to read the phy, which we could msleep while
 * waiting for it, and we can't msleep in a timer.
 **/
static void e1000e_update_phy_task(struct work_struct *work)
{
	struct e1000_adapter *adapter = container_of(work,
					struct e1000_adapter, update_phy_task);
4450 4451 4452 4453

	if (test_bit(__E1000_DOWN, &adapter->state))
		return;

4454 4455 4456
	e1000_get_phy_info(&adapter->hw);
}

B
Bruce Allan 已提交
4457 4458 4459 4460
/**
 * e1000_update_phy_info - timre call-back to update PHY info
 * @data: pointer to adapter cast into an unsigned long
 *
4461 4462
 * Need to wait a few seconds after link up to get diagnostic information from
 * the phy
B
Bruce Allan 已提交
4463
 **/
4464 4465 4466
static void e1000_update_phy_info(unsigned long data)
{
	struct e1000_adapter *adapter = (struct e1000_adapter *) data;
4467 4468 4469 4470

	if (test_bit(__E1000_DOWN, &adapter->state))
		return;

4471
	schedule_work(&adapter->update_phy_task);
4472 4473
}

4474 4475 4476
/**
 * e1000e_update_phy_stats - Update the PHY statistics counters
 * @adapter: board private structure
4477 4478
 *
 * Read/clear the upper 16-bit PHY registers and read/accumulate lower
4479 4480 4481 4482 4483 4484 4485 4486 4487 4488 4489
 **/
static void e1000e_update_phy_stats(struct e1000_adapter *adapter)
{
	struct e1000_hw *hw = &adapter->hw;
	s32 ret_val;
	u16 phy_data;

	ret_val = hw->phy.ops.acquire(hw);
	if (ret_val)
		return;

B
Bruce Allan 已提交
4490
	/* A page set is expensive so check if already on desired page.
4491 4492
	 * If not, set to the page with the PHY status registers.
	 */
4493
	hw->phy.addr = 1;
4494 4495 4496 4497
	ret_val = e1000e_read_phy_reg_mdic(hw, IGP01E1000_PHY_PAGE_SELECT,
					   &phy_data);
	if (ret_val)
		goto release;
4498 4499 4500
	if (phy_data != (HV_STATS_PAGE << IGP_PAGE_SHIFT)) {
		ret_val = hw->phy.ops.set_page(hw,
					       HV_STATS_PAGE << IGP_PAGE_SHIFT);
4501 4502 4503 4504 4505
		if (ret_val)
			goto release;
	}

	/* Single Collision Count */
4506 4507
	hw->phy.ops.read_reg_page(hw, HV_SCC_UPPER, &phy_data);
	ret_val = hw->phy.ops.read_reg_page(hw, HV_SCC_LOWER, &phy_data);
4508 4509 4510 4511
	if (!ret_val)
		adapter->stats.scc += phy_data;

	/* Excessive Collision Count */
4512 4513
	hw->phy.ops.read_reg_page(hw, HV_ECOL_UPPER, &phy_data);
	ret_val = hw->phy.ops.read_reg_page(hw, HV_ECOL_LOWER, &phy_data);
4514 4515 4516 4517
	if (!ret_val)
		adapter->stats.ecol += phy_data;

	/* Multiple Collision Count */
4518 4519
	hw->phy.ops.read_reg_page(hw, HV_MCC_UPPER, &phy_data);
	ret_val = hw->phy.ops.read_reg_page(hw, HV_MCC_LOWER, &phy_data);
4520 4521 4522 4523
	if (!ret_val)
		adapter->stats.mcc += phy_data;

	/* Late Collision Count */
4524 4525
	hw->phy.ops.read_reg_page(hw, HV_LATECOL_UPPER, &phy_data);
	ret_val = hw->phy.ops.read_reg_page(hw, HV_LATECOL_LOWER, &phy_data);
4526 4527 4528 4529
	if (!ret_val)
		adapter->stats.latecol += phy_data;

	/* Collision Count - also used for adaptive IFS */
4530 4531
	hw->phy.ops.read_reg_page(hw, HV_COLC_UPPER, &phy_data);
	ret_val = hw->phy.ops.read_reg_page(hw, HV_COLC_LOWER, &phy_data);
4532 4533 4534 4535
	if (!ret_val)
		hw->mac.collision_delta = phy_data;

	/* Defer Count */
4536 4537
	hw->phy.ops.read_reg_page(hw, HV_DC_UPPER, &phy_data);
	ret_val = hw->phy.ops.read_reg_page(hw, HV_DC_LOWER, &phy_data);
4538 4539 4540 4541
	if (!ret_val)
		adapter->stats.dc += phy_data;

	/* Transmit with no CRS */
4542 4543
	hw->phy.ops.read_reg_page(hw, HV_TNCRS_UPPER, &phy_data);
	ret_val = hw->phy.ops.read_reg_page(hw, HV_TNCRS_LOWER, &phy_data);
4544 4545 4546 4547 4548 4549 4550
	if (!ret_val)
		adapter->stats.tncrs += phy_data;

release:
	hw->phy.ops.release(hw);
}

4551 4552 4553 4554
/**
 * e1000e_update_stats - Update the board statistics counters
 * @adapter: board private structure
 **/
J
Jeff Kirsher 已提交
4555
static void e1000e_update_stats(struct e1000_adapter *adapter)
4556
{
4557
	struct net_device *netdev = adapter->netdev;
4558 4559 4560
	struct e1000_hw *hw = &adapter->hw;
	struct pci_dev *pdev = adapter->pdev;

B
Bruce Allan 已提交
4561
	/* Prevent stats update while adapter is being reset, or if the pci
4562 4563 4564 4565 4566 4567 4568 4569 4570
	 * connection is down.
	 */
	if (adapter->link_speed == 0)
		return;
	if (pci_channel_offline(pdev))
		return;

	adapter->stats.crcerrs += er32(CRCERRS);
	adapter->stats.gprc += er32(GPRC);
4571 4572
	adapter->stats.gorc += er32(GORCL);
	er32(GORCH); /* Clear gorc */
4573 4574 4575 4576 4577
	adapter->stats.bprc += er32(BPRC);
	adapter->stats.mprc += er32(MPRC);
	adapter->stats.roc += er32(ROC);

	adapter->stats.mpc += er32(MPC);
4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596

	/* Half-duplex statistics */
	if (adapter->link_duplex == HALF_DUPLEX) {
		if (adapter->flags2 & FLAG2_HAS_PHY_STATS) {
			e1000e_update_phy_stats(adapter);
		} else {
			adapter->stats.scc += er32(SCC);
			adapter->stats.ecol += er32(ECOL);
			adapter->stats.mcc += er32(MCC);
			adapter->stats.latecol += er32(LATECOL);
			adapter->stats.dc += er32(DC);

			hw->mac.collision_delta = er32(COLC);

			if ((hw->mac.type != e1000_82574) &&
			    (hw->mac.type != e1000_82583))
				adapter->stats.tncrs += er32(TNCRS);
		}
		adapter->stats.colc += hw->mac.collision_delta;
4597
	}
4598

4599 4600 4601 4602 4603
	adapter->stats.xonrxc += er32(XONRXC);
	adapter->stats.xontxc += er32(XONTXC);
	adapter->stats.xoffrxc += er32(XOFFRXC);
	adapter->stats.xofftxc += er32(XOFFTXC);
	adapter->stats.gptc += er32(GPTC);
4604 4605
	adapter->stats.gotc += er32(GOTCL);
	er32(GOTCH); /* Clear gotc */
4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623
	adapter->stats.rnbc += er32(RNBC);
	adapter->stats.ruc += er32(RUC);

	adapter->stats.mptc += er32(MPTC);
	adapter->stats.bptc += er32(BPTC);

	/* used for adaptive IFS */

	hw->mac.tx_packet_delta = er32(TPT);
	adapter->stats.tpt += hw->mac.tx_packet_delta;

	adapter->stats.algnerrc += er32(ALGNERRC);
	adapter->stats.rxerrc += er32(RXERRC);
	adapter->stats.cexterr += er32(CEXTERR);
	adapter->stats.tsctc += er32(TSCTC);
	adapter->stats.tsctfc += er32(TSCTFC);

	/* Fill out the OS statistics structure */
4624 4625
	netdev->stats.multicast = adapter->stats.mprc;
	netdev->stats.collisions = adapter->stats.colc;
4626 4627 4628

	/* Rx Errors */

B
Bruce Allan 已提交
4629
	/* RLEC on some newer hardware can be incorrect so build
4630 4631
	 * our own version based on RUC and ROC
	 */
4632
	netdev->stats.rx_errors = adapter->stats.rxerrc +
4633 4634 4635
		adapter->stats.crcerrs + adapter->stats.algnerrc +
		adapter->stats.ruc + adapter->stats.roc +
		adapter->stats.cexterr;
4636
	netdev->stats.rx_length_errors = adapter->stats.ruc +
4637
					      adapter->stats.roc;
4638 4639 4640
	netdev->stats.rx_crc_errors = adapter->stats.crcerrs;
	netdev->stats.rx_frame_errors = adapter->stats.algnerrc;
	netdev->stats.rx_missed_errors = adapter->stats.mpc;
4641 4642

	/* Tx Errors */
4643
	netdev->stats.tx_errors = adapter->stats.ecol +
4644
				       adapter->stats.latecol;
4645 4646 4647
	netdev->stats.tx_aborted_errors = adapter->stats.ecol;
	netdev->stats.tx_window_errors = adapter->stats.latecol;
	netdev->stats.tx_carrier_errors = adapter->stats.tncrs;
4648 4649 4650 4651 4652 4653 4654

	/* Tx Dropped needs to be maintained elsewhere */

	/* Management Stats */
	adapter->stats.mgptc += er32(MGTPTC);
	adapter->stats.mgprc += er32(MGTPRC);
	adapter->stats.mgpdc += er32(MGTPDC);
4655 4656 4657 4658 4659 4660 4661 4662 4663 4664

	/* Correctable ECC Errors */
	if (hw->mac.type == e1000_pch_lpt) {
		u32 pbeccsts = er32(PBECCSTS);
		adapter->corr_errors +=
		    pbeccsts & E1000_PBECCSTS_CORR_ERR_CNT_MASK;
		adapter->uncorr_errors +=
		    (pbeccsts & E1000_PBECCSTS_UNCORR_ERR_CNT_MASK) >>
		    E1000_PBECCSTS_UNCORR_ERR_CNT_SHIFT;
	}
4665 4666
}

4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677
/**
 * e1000_phy_read_status - Update the PHY register status snapshot
 * @adapter: board private structure
 **/
static void e1000_phy_read_status(struct e1000_adapter *adapter)
{
	struct e1000_hw *hw = &adapter->hw;
	struct e1000_phy_regs *phy = &adapter->phy_regs;

	if ((er32(STATUS) & E1000_STATUS_LU) &&
	    (adapter->hw.phy.media_type == e1000_media_type_copper)) {
4678 4679
		int ret_val;

4680 4681 4682 4683 4684 4685 4686 4687 4688
		ret_val  = e1e_rphy(hw, PHY_CONTROL, &phy->bmcr);
		ret_val |= e1e_rphy(hw, PHY_STATUS, &phy->bmsr);
		ret_val |= e1e_rphy(hw, PHY_AUTONEG_ADV, &phy->advertise);
		ret_val |= e1e_rphy(hw, PHY_LP_ABILITY, &phy->lpa);
		ret_val |= e1e_rphy(hw, PHY_AUTONEG_EXP, &phy->expansion);
		ret_val |= e1e_rphy(hw, PHY_1000T_CTRL, &phy->ctrl1000);
		ret_val |= e1e_rphy(hw, PHY_1000T_STATUS, &phy->stat1000);
		ret_val |= e1e_rphy(hw, PHY_EXT_STATUS, &phy->estatus);
		if (ret_val)
4689
			e_warn("Error reading PHY register\n");
4690
	} else {
B
Bruce Allan 已提交
4691
		/* Do not read PHY registers if link is not up
4692 4693 4694 4695 4696 4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707
		 * Set values to typical power-on defaults
		 */
		phy->bmcr = (BMCR_SPEED1000 | BMCR_ANENABLE | BMCR_FULLDPLX);
		phy->bmsr = (BMSR_100FULL | BMSR_100HALF | BMSR_10FULL |
			     BMSR_10HALF | BMSR_ESTATEN | BMSR_ANEGCAPABLE |
			     BMSR_ERCAP);
		phy->advertise = (ADVERTISE_PAUSE_ASYM | ADVERTISE_PAUSE_CAP |
				  ADVERTISE_ALL | ADVERTISE_CSMA);
		phy->lpa = 0;
		phy->expansion = EXPANSION_ENABLENPAGE;
		phy->ctrl1000 = ADVERTISE_1000FULL;
		phy->stat1000 = 0;
		phy->estatus = (ESTATUS_1000_TFULL | ESTATUS_1000_THALF);
	}
}

4708 4709 4710 4711 4712
static void e1000_print_link_info(struct e1000_adapter *adapter)
{
	struct e1000_hw *hw = &adapter->hw;
	u32 ctrl = er32(CTRL);

4713
	/* Link status message must follow this format for user tools */
4714 4715
	pr_info("%s NIC Link is Up %d Mbps %s Duplex, Flow Control: %s\n",
		adapter->netdev->name, adapter->link_speed,
4716 4717 4718 4719
		adapter->link_duplex == FULL_DUPLEX ? "Full" : "Half",
		(ctrl & E1000_CTRL_TFCE) && (ctrl & E1000_CTRL_RFCE) ? "Rx/Tx" :
		(ctrl & E1000_CTRL_RFCE) ? "Rx" :
		(ctrl & E1000_CTRL_TFCE) ? "Tx" : "None");
4720 4721
}

4722
static bool e1000e_has_link(struct e1000_adapter *adapter)
4723 4724
{
	struct e1000_hw *hw = &adapter->hw;
4725
	bool link_active = false;
4726 4727
	s32 ret_val = 0;

B
Bruce Allan 已提交
4728
	/* get_link_status is set on LSC (link status) interrupt or
4729 4730 4731 4732 4733 4734 4735 4736 4737 4738
	 * Rx sequence error interrupt.  get_link_status will stay
	 * false until the check_for_link establishes link
	 * for copper adapters ONLY
	 */
	switch (hw->phy.media_type) {
	case e1000_media_type_copper:
		if (hw->mac.get_link_status) {
			ret_val = hw->mac.ops.check_for_link(hw);
			link_active = !hw->mac.get_link_status;
		} else {
4739
			link_active = true;
4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757
		}
		break;
	case e1000_media_type_fiber:
		ret_val = hw->mac.ops.check_for_link(hw);
		link_active = !!(er32(STATUS) & E1000_STATUS_LU);
		break;
	case e1000_media_type_internal_serdes:
		ret_val = hw->mac.ops.check_for_link(hw);
		link_active = adapter->hw.mac.serdes_has_link;
		break;
	default:
	case e1000_media_type_unknown:
		break;
	}

	if ((ret_val == E1000_ERR_PHY) && (hw->phy.type == e1000_phy_igp_3) &&
	    (er32(CTRL) & E1000_PHY_CTRL_GBE_DISABLE)) {
		/* See e1000_kmrn_lock_loss_workaround_ich8lan() */
4758
		e_info("Gigabit has been disabled, downgrading speed\n");
4759 4760 4761 4762 4763 4764 4765 4766 4767
	}

	return link_active;
}

static void e1000e_enable_receives(struct e1000_adapter *adapter)
{
	/* make sure the receive unit is started */
	if ((adapter->flags & FLAG_RX_NEEDS_RESTART) &&
4768
	    (adapter->flags & FLAG_RESTART_NOW)) {
4769 4770 4771
		struct e1000_hw *hw = &adapter->hw;
		u32 rctl = er32(RCTL);
		ew32(RCTL, rctl | E1000_RCTL_EN);
4772
		adapter->flags &= ~FLAG_RESTART_NOW;
4773 4774 4775
	}
}

4776 4777 4778 4779
static void e1000e_check_82574_phy_workaround(struct e1000_adapter *adapter)
{
	struct e1000_hw *hw = &adapter->hw;

B
Bruce Allan 已提交
4780
	/* With 82574 controllers, PHY needs to be checked periodically
4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793
	 * for hung state and reset, if two calls return true
	 */
	if (e1000_check_phy_82574(hw))
		adapter->phy_hang_count++;
	else
		adapter->phy_hang_count = 0;

	if (adapter->phy_hang_count > 1) {
		adapter->phy_hang_count = 0;
		schedule_work(&adapter->reset_task);
	}
}

4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813
/**
 * e1000_watchdog - Timer Call-back
 * @data: pointer to adapter cast into an unsigned long
 **/
static void e1000_watchdog(unsigned long data)
{
	struct e1000_adapter *adapter = (struct e1000_adapter *) data;

	/* Do the rest outside of interrupt context */
	schedule_work(&adapter->watchdog_task);

	/* TODO: make this use queue_delayed_work() */
}

static void e1000_watchdog_task(struct work_struct *work)
{
	struct e1000_adapter *adapter = container_of(work,
					struct e1000_adapter, watchdog_task);
	struct net_device *netdev = adapter->netdev;
	struct e1000_mac_info *mac = &adapter->hw.mac;
B
Bruce Allan 已提交
4814
	struct e1000_phy_info *phy = &adapter->hw.phy;
4815 4816 4817 4818
	struct e1000_ring *tx_ring = adapter->tx_ring;
	struct e1000_hw *hw = &adapter->hw;
	u32 link, tctl;

4819 4820 4821
	if (test_bit(__E1000_DOWN, &adapter->state))
		return;

4822
	link = e1000e_has_link(adapter);
4823
	if ((netif_carrier_ok(netdev)) && link) {
4824 4825 4826
		/* Cancel scheduled suspend requests. */
		pm_runtime_resume(netdev->dev.parent);

4827
		e1000e_enable_receives(adapter);
4828 4829 4830 4831 4832 4833 4834 4835 4836
		goto link_up;
	}

	if ((e1000e_enable_tx_pkt_filtering(hw)) &&
	    (adapter->mng_vlan_id != adapter->hw.mng_cookie.vlan_id))
		e1000_update_mng_vlan(adapter);

	if (link) {
		if (!netif_carrier_ok(netdev)) {
4837
			bool txb2b = true;
4838 4839 4840 4841

			/* Cancel scheduled suspend requests. */
			pm_runtime_resume(netdev->dev.parent);

4842
			/* update snapshot of PHY registers on LSC */
4843
			e1000_phy_read_status(adapter);
4844 4845 4846 4847
			mac->ops.get_link_up_info(&adapter->hw,
						   &adapter->link_speed,
						   &adapter->link_duplex);
			e1000_print_link_info(adapter);
B
Bruce Allan 已提交
4848
			/* On supported PHYs, check for duplex mismatch only
4849 4850 4851 4852 4853 4854 4855 4856 4857 4858 4859 4860 4861
			 * if link has autonegotiated at 10/100 half
			 */
			if ((hw->phy.type == e1000_phy_igp_3 ||
			     hw->phy.type == e1000_phy_bm) &&
			    (hw->mac.autoneg == true) &&
			    (adapter->link_speed == SPEED_10 ||
			     adapter->link_speed == SPEED_100) &&
			    (adapter->link_duplex == HALF_DUPLEX)) {
				u16 autoneg_exp;

				e1e_rphy(hw, PHY_AUTONEG_EXP, &autoneg_exp);

				if (!(autoneg_exp & NWAY_ER_LP_NWAY_CAPS))
4862
					e_info("Autonegotiated half duplex but link partner cannot autoneg.  Try forcing full duplex if link gets many collisions.\n");
4863 4864
			}

4865
			/* adjust timeout factor according to speed/duplex */
4866 4867 4868
			adapter->tx_timeout_factor = 1;
			switch (adapter->link_speed) {
			case SPEED_10:
4869
				txb2b = false;
4870
				adapter->tx_timeout_factor = 16;
4871 4872
				break;
			case SPEED_100:
4873
				txb2b = false;
4874
				adapter->tx_timeout_factor = 10;
4875 4876 4877
				break;
			}

B
Bruce Allan 已提交
4878
			/* workaround: re-program speed mode bit after
4879 4880
			 * link-up event
			 */
4881 4882 4883
			if ((adapter->flags & FLAG_TARC_SPEED_MODE_BIT) &&
			    !txb2b) {
				u32 tarc0;
4884
				tarc0 = er32(TARC(0));
4885
				tarc0 &= ~SPEED_MODE_BIT;
4886
				ew32(TARC(0), tarc0);
4887 4888
			}

B
Bruce Allan 已提交
4889
			/* disable TSO for pcie and 10/100 speeds, to avoid
4890 4891
			 * some hardware issues
			 */
4892 4893 4894 4895
			if (!(adapter->flags & FLAG_TSO_FORCE)) {
				switch (adapter->link_speed) {
				case SPEED_10:
				case SPEED_100:
4896
					e_info("10/100 speed: disabling TSO\n");
4897 4898 4899 4900 4901 4902 4903 4904 4905 4906 4907 4908 4909
					netdev->features &= ~NETIF_F_TSO;
					netdev->features &= ~NETIF_F_TSO6;
					break;
				case SPEED_1000:
					netdev->features |= NETIF_F_TSO;
					netdev->features |= NETIF_F_TSO6;
					break;
				default:
					/* oops */
					break;
				}
			}

B
Bruce Allan 已提交
4910
			/* enable transmits in the hardware, need to do this
4911 4912
			 * after setting TARC(0)
			 */
4913 4914 4915 4916
			tctl = er32(TCTL);
			tctl |= E1000_TCTL_EN;
			ew32(TCTL, tctl);

B
Bruce Allan 已提交
4917
			/* Perform any post-link-up configuration before
B
Bruce Allan 已提交
4918 4919 4920 4921 4922
			 * reporting link up.
			 */
			if (phy->ops.cfg_on_link_up)
				phy->ops.cfg_on_link_up(hw);

4923 4924 4925 4926 4927 4928 4929 4930 4931 4932
			netif_carrier_on(netdev);

			if (!test_bit(__E1000_DOWN, &adapter->state))
				mod_timer(&adapter->phy_info_timer,
					  round_jiffies(jiffies + 2 * HZ));
		}
	} else {
		if (netif_carrier_ok(netdev)) {
			adapter->link_speed = 0;
			adapter->link_duplex = 0;
4933
			/* Link status message must follow this format */
4934
			pr_info("%s NIC Link is Down\n", adapter->netdev->name);
4935 4936 4937 4938 4939
			netif_carrier_off(netdev);
			if (!test_bit(__E1000_DOWN, &adapter->state))
				mod_timer(&adapter->phy_info_timer,
					  round_jiffies(jiffies + 2 * HZ));

4940 4941 4942 4943 4944 4945 4946 4947 4948 4949
			/* The link is lost so the controller stops DMA.
			 * If there is queued Tx work that cannot be done
			 * or if on an 8000ES2LAN which requires a Rx packet
			 * buffer work-around on link down event, reset the
			 * controller to flush the Tx/Rx packet buffers.
			 * (Do the reset outside of interrupt context).
			 */
			if ((adapter->flags & FLAG_RX_NEEDS_RESTART) ||
			    (e1000_desc_unused(tx_ring) + 1 < tx_ring->count))
				adapter->flags |= FLAG_RESTART_NOW;
4950 4951 4952
			else
				pm_schedule_suspend(netdev->dev.parent,
							LINK_TIMEOUT);
4953 4954 4955 4956
		}
	}

link_up:
J
Jeff Kirsher 已提交
4957
	spin_lock(&adapter->stats64_lock);
4958 4959 4960 4961 4962 4963 4964
	e1000e_update_stats(adapter);

	mac->tx_packet_delta = adapter->stats.tpt - adapter->tpt_old;
	adapter->tpt_old = adapter->stats.tpt;
	mac->collision_delta = adapter->stats.colc - adapter->colc_old;
	adapter->colc_old = adapter->stats.colc;

4965 4966 4967 4968
	adapter->gorc = adapter->stats.gorc - adapter->gorc_old;
	adapter->gorc_old = adapter->stats.gorc;
	adapter->gotc = adapter->stats.gotc - adapter->gotc_old;
	adapter->gotc_old = adapter->stats.gotc;
4969
	spin_unlock(&adapter->stats64_lock);
4970

4971
	if (adapter->flags & FLAG_RESTART_NOW) {
4972 4973 4974
		schedule_work(&adapter->reset_task);
		/* return immediately since reset is imminent */
		return;
4975 4976
	}

4977 4978
	e1000e_update_adaptive(&adapter->hw);

4979 4980
	/* Simple mode for Interrupt Throttle Rate (ITR) */
	if (adapter->itr_setting == 4) {
B
Bruce Allan 已提交
4981
		/* Symmetric Tx/Rx gets a reduced ITR=2000;
4982 4983 4984 4985 4986 4987 4988 4989 4990
		 * Total asymmetrical Tx or Rx gets ITR=8000;
		 * everyone else is between 2000-8000.
		 */
		u32 goc = (adapter->gotc + adapter->gorc) / 10000;
		u32 dif = (adapter->gotc > adapter->gorc ?
			    adapter->gotc - adapter->gorc :
			    adapter->gorc - adapter->gotc) / 10000;
		u32 itr = goc > 0 ? (dif * 6000 / goc + 2000) : 8000;

4991
		e1000e_write_itr(adapter, itr);
4992 4993
	}

4994
	/* Cause software interrupt to ensure Rx ring is cleaned */
4995 4996 4997 4998
	if (adapter->msix_entries)
		ew32(ICS, adapter->rx_ring->ims_val);
	else
		ew32(ICS, E1000_ICS_RXDMT0);
4999

5000 5001 5002
	/* flush pending descriptors to memory before detecting Tx hang */
	e1000e_flush_descriptors(adapter);

5003
	/* Force detection of hung controller every watchdog period */
5004
	adapter->detect_tx_hung = true;
5005

B
Bruce Allan 已提交
5006
	/* With 82571 controllers, LAA may be overwritten due to controller
5007 5008
	 * reset from the other port. Set the appropriate LAA in RAR[0]
	 */
5009
	if (e1000e_get_laa_state_82571(hw))
5010
		hw->mac.ops.rar_set(hw, adapter->hw.mac.addr, 0);
5011

5012 5013 5014
	if (adapter->flags2 & FLAG2_CHECK_PHY_HANG)
		e1000e_check_82574_phy_workaround(adapter);

5015 5016 5017 5018 5019 5020 5021 5022 5023 5024 5025
	/* Clear valid timestamp stuck in RXSTMPL/H due to a Rx error */
	if (adapter->hwtstamp_config.rx_filter != HWTSTAMP_FILTER_NONE) {
		if ((adapter->flags2 & FLAG2_CHECK_RX_HWTSTAMP) &&
		    (er32(TSYNCRXCTL) & E1000_TSYNCRXCTL_VALID)) {
			er32(RXSTMPH);
			adapter->rx_hwtstamp_cleared++;
		} else {
			adapter->flags2 |= FLAG2_CHECK_RX_HWTSTAMP;
		}
	}

5026 5027 5028 5029 5030 5031 5032 5033 5034 5035
	/* Reset the timer */
	if (!test_bit(__E1000_DOWN, &adapter->state))
		mod_timer(&adapter->watchdog_timer,
			  round_jiffies(jiffies + 2 * HZ));
}

#define E1000_TX_FLAGS_CSUM		0x00000001
#define E1000_TX_FLAGS_VLAN		0x00000002
#define E1000_TX_FLAGS_TSO		0x00000004
#define E1000_TX_FLAGS_IPV4		0x00000008
5036
#define E1000_TX_FLAGS_NO_FCS		0x00000010
5037
#define E1000_TX_FLAGS_HWTSTAMP		0x00000020
5038 5039 5040
#define E1000_TX_FLAGS_VLAN_MASK	0xffff0000
#define E1000_TX_FLAGS_VLAN_SHIFT	16

5041
static int e1000_tso(struct e1000_ring *tx_ring, struct sk_buff *skb)
5042 5043 5044 5045 5046
{
	struct e1000_context_desc *context_desc;
	struct e1000_buffer *buffer_info;
	unsigned int i;
	u32 cmd_length = 0;
5047
	u16 ipcse = 0, mss;
5048 5049
	u8 ipcss, ipcso, tucss, tucso, hdr_len;

5050 5051
	if (!skb_is_gso(skb))
		return 0;
5052

5053
	if (skb_header_cloned(skb)) {
5054 5055
		int err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);

5056 5057
		if (err)
			return err;
5058 5059
	}

5060 5061 5062 5063 5064 5065 5066 5067 5068 5069
	hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
	mss = skb_shinfo(skb)->gso_size;
	if (skb->protocol == htons(ETH_P_IP)) {
		struct iphdr *iph = ip_hdr(skb);
		iph->tot_len = 0;
		iph->check = 0;
		tcp_hdr(skb)->check = ~csum_tcpudp_magic(iph->saddr, iph->daddr,
		                                         0, IPPROTO_TCP, 0);
		cmd_length = E1000_TXD_CMD_IP;
		ipcse = skb_transport_offset(skb) - 1;
5070
	} else if (skb_is_gso_v6(skb)) {
5071 5072 5073 5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087 5088 5089 5090 5091 5092 5093
		ipv6_hdr(skb)->payload_len = 0;
		tcp_hdr(skb)->check = ~csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
		                                       &ipv6_hdr(skb)->daddr,
		                                       0, IPPROTO_TCP, 0);
		ipcse = 0;
	}
	ipcss = skb_network_offset(skb);
	ipcso = (void *)&(ip_hdr(skb)->check) - (void *)skb->data;
	tucss = skb_transport_offset(skb);
	tucso = (void *)&(tcp_hdr(skb)->check) - (void *)skb->data;

	cmd_length |= (E1000_TXD_CMD_DEXT | E1000_TXD_CMD_TSE |
	               E1000_TXD_CMD_TCP | (skb->len - (hdr_len)));

	i = tx_ring->next_to_use;
	context_desc = E1000_CONTEXT_DESC(*tx_ring, i);
	buffer_info = &tx_ring->buffer_info[i];

	context_desc->lower_setup.ip_fields.ipcss  = ipcss;
	context_desc->lower_setup.ip_fields.ipcso  = ipcso;
	context_desc->lower_setup.ip_fields.ipcse  = cpu_to_le16(ipcse);
	context_desc->upper_setup.tcp_fields.tucss = tucss;
	context_desc->upper_setup.tcp_fields.tucso = tucso;
5094
	context_desc->upper_setup.tcp_fields.tucse = 0;
5095 5096 5097 5098 5099 5100 5101 5102 5103 5104 5105 5106 5107
	context_desc->tcp_seg_setup.fields.mss     = cpu_to_le16(mss);
	context_desc->tcp_seg_setup.fields.hdr_len = hdr_len;
	context_desc->cmd_and_length = cpu_to_le32(cmd_length);

	buffer_info->time_stamp = jiffies;
	buffer_info->next_to_watch = i;

	i++;
	if (i == tx_ring->count)
		i = 0;
	tx_ring->next_to_use = i;

	return 1;
5108 5109
}

5110
static bool e1000_tx_csum(struct e1000_ring *tx_ring, struct sk_buff *skb)
5111
{
5112
	struct e1000_adapter *adapter = tx_ring->adapter;
5113 5114 5115 5116
	struct e1000_context_desc *context_desc;
	struct e1000_buffer *buffer_info;
	unsigned int i;
	u8 css;
5117
	u32 cmd_len = E1000_TXD_CMD_DEXT;
5118
	__be16 protocol;
5119

5120 5121
	if (skb->ip_summed != CHECKSUM_PARTIAL)
		return 0;
5122

5123 5124 5125 5126 5127
	if (skb->protocol == cpu_to_be16(ETH_P_8021Q))
		protocol = vlan_eth_hdr(skb)->h_vlan_encapsulated_proto;
	else
		protocol = skb->protocol;

A
Arthur Jones 已提交
5128
	switch (protocol) {
5129
	case cpu_to_be16(ETH_P_IP):
5130 5131 5132
		if (ip_hdr(skb)->protocol == IPPROTO_TCP)
			cmd_len |= E1000_TXD_CMD_TCP;
		break;
5133
	case cpu_to_be16(ETH_P_IPV6):
5134 5135 5136 5137 5138 5139
		/* XXX not handling all IPV6 headers */
		if (ipv6_hdr(skb)->nexthdr == IPPROTO_TCP)
			cmd_len |= E1000_TXD_CMD_TCP;
		break;
	default:
		if (unlikely(net_ratelimit()))
5140 5141
			e_warn("checksum_partial proto=%x!\n",
			       be16_to_cpu(protocol));
5142
		break;
5143 5144
	}

5145
	css = skb_checksum_start_offset(skb);
5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162 5163 5164 5165 5166 5167

	i = tx_ring->next_to_use;
	buffer_info = &tx_ring->buffer_info[i];
	context_desc = E1000_CONTEXT_DESC(*tx_ring, i);

	context_desc->lower_setup.ip_config = 0;
	context_desc->upper_setup.tcp_fields.tucss = css;
	context_desc->upper_setup.tcp_fields.tucso =
				css + skb->csum_offset;
	context_desc->upper_setup.tcp_fields.tucse = 0;
	context_desc->tcp_seg_setup.data = 0;
	context_desc->cmd_and_length = cpu_to_le32(cmd_len);

	buffer_info->time_stamp = jiffies;
	buffer_info->next_to_watch = i;

	i++;
	if (i == tx_ring->count)
		i = 0;
	tx_ring->next_to_use = i;

	return 1;
5168 5169
}

5170 5171
static int e1000_tx_map(struct e1000_ring *tx_ring, struct sk_buff *skb,
			unsigned int first, unsigned int max_per_txd,
5172
			unsigned int nr_frags)
5173
{
5174
	struct e1000_adapter *adapter = tx_ring->adapter;
5175
	struct pci_dev *pdev = adapter->pdev;
5176
	struct e1000_buffer *buffer_info;
J
Jesse Brandeburg 已提交
5177
	unsigned int len = skb_headlen(skb);
5178
	unsigned int offset = 0, size, count = 0, i;
5179
	unsigned int f, bytecount, segs;
5180 5181 5182 5183

	i = tx_ring->next_to_use;

	while (len) {
5184
		buffer_info = &tx_ring->buffer_info[i];
5185 5186 5187 5188 5189
		size = min(len, max_per_txd);

		buffer_info->length = size;
		buffer_info->time_stamp = jiffies;
		buffer_info->next_to_watch = i;
5190 5191
		buffer_info->dma = dma_map_single(&pdev->dev,
						  skb->data + offset,
5192
						  size, DMA_TO_DEVICE);
5193
		buffer_info->mapped_as_page = false;
5194
		if (dma_mapping_error(&pdev->dev, buffer_info->dma))
5195
			goto dma_error;
5196 5197 5198

		len -= size;
		offset += size;
5199
		count++;
5200 5201 5202 5203 5204 5205

		if (len) {
			i++;
			if (i == tx_ring->count)
				i = 0;
		}
5206 5207 5208
	}

	for (f = 0; f < nr_frags; f++) {
E
Eric Dumazet 已提交
5209
		const struct skb_frag_struct *frag;
5210 5211

		frag = &skb_shinfo(skb)->frags[f];
E
Eric Dumazet 已提交
5212
		len = skb_frag_size(frag);
5213
		offset = 0;
5214 5215

		while (len) {
5216 5217 5218 5219
			i++;
			if (i == tx_ring->count)
				i = 0;

5220 5221 5222 5223 5224 5225
			buffer_info = &tx_ring->buffer_info[i];
			size = min(len, max_per_txd);

			buffer_info->length = size;
			buffer_info->time_stamp = jiffies;
			buffer_info->next_to_watch = i;
5226 5227
			buffer_info->dma = skb_frag_dma_map(&pdev->dev, frag,
						offset, size, DMA_TO_DEVICE);
5228
			buffer_info->mapped_as_page = true;
5229
			if (dma_mapping_error(&pdev->dev, buffer_info->dma))
5230
				goto dma_error;
5231 5232 5233 5234 5235 5236 5237

			len -= size;
			offset += size;
			count++;
		}
	}

5238
	segs = skb_shinfo(skb)->gso_segs ? : 1;
5239 5240 5241
	/* multiply data chunks by size of headers */
	bytecount = ((segs - 1) * skb_headlen(skb)) + skb->len;

5242
	tx_ring->buffer_info[i].skb = skb;
5243 5244
	tx_ring->buffer_info[i].segs = segs;
	tx_ring->buffer_info[i].bytecount = bytecount;
5245 5246 5247
	tx_ring->buffer_info[first].next_to_watch = i;

	return count;
5248 5249

dma_error:
5250
	dev_err(&pdev->dev, "Tx DMA map failed\n");
5251
	buffer_info->dma = 0;
5252
	if (count)
5253
		count--;
5254 5255

	while (count--) {
5256
		if (i == 0)
5257
			i += tx_ring->count;
5258
		i--;
5259
		buffer_info = &tx_ring->buffer_info[i];
5260
		e1000_put_txbuf(tx_ring, buffer_info);
5261 5262 5263
	}

	return 0;
5264 5265
}

5266
static void e1000_tx_queue(struct e1000_ring *tx_ring, int tx_flags, int count)
5267
{
5268
	struct e1000_adapter *adapter = tx_ring->adapter;
5269 5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292
	struct e1000_tx_desc *tx_desc = NULL;
	struct e1000_buffer *buffer_info;
	u32 txd_upper = 0, txd_lower = E1000_TXD_CMD_IFCS;
	unsigned int i;

	if (tx_flags & E1000_TX_FLAGS_TSO) {
		txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D |
			     E1000_TXD_CMD_TSE;
		txd_upper |= E1000_TXD_POPTS_TXSM << 8;

		if (tx_flags & E1000_TX_FLAGS_IPV4)
			txd_upper |= E1000_TXD_POPTS_IXSM << 8;
	}

	if (tx_flags & E1000_TX_FLAGS_CSUM) {
		txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
		txd_upper |= E1000_TXD_POPTS_TXSM << 8;
	}

	if (tx_flags & E1000_TX_FLAGS_VLAN) {
		txd_lower |= E1000_TXD_CMD_VLE;
		txd_upper |= (tx_flags & E1000_TX_FLAGS_VLAN_MASK);
	}

5293 5294 5295
	if (unlikely(tx_flags & E1000_TX_FLAGS_NO_FCS))
		txd_lower &= ~(E1000_TXD_CMD_IFCS);

5296 5297 5298 5299 5300
	if (unlikely(tx_flags & E1000_TX_FLAGS_HWTSTAMP)) {
		txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
		txd_upper |= E1000_TXD_EXTCMD_TSTAMP;
	}

5301 5302
	i = tx_ring->next_to_use;

5303
	do {
5304 5305 5306 5307 5308 5309 5310 5311 5312 5313
		buffer_info = &tx_ring->buffer_info[i];
		tx_desc = E1000_TX_DESC(*tx_ring, i);
		tx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);
		tx_desc->lower.data =
			cpu_to_le32(txd_lower | buffer_info->length);
		tx_desc->upper.data = cpu_to_le32(txd_upper);

		i++;
		if (i == tx_ring->count)
			i = 0;
5314
	} while (--count > 0);
5315 5316 5317

	tx_desc->lower.data |= cpu_to_le32(adapter->txd_cmd);

5318 5319 5320 5321
	/* txd_cmd re-enables FCS, so we'll re-disable it here as desired. */
	if (unlikely(tx_flags & E1000_TX_FLAGS_NO_FCS))
		tx_desc->lower.data &= ~(cpu_to_le32(E1000_TXD_CMD_IFCS));

B
Bruce Allan 已提交
5322
	/* Force memory writes to complete before letting h/w
5323 5324
	 * know there are new descriptors to fetch.  (Only
	 * applicable for weak-ordered memory model archs,
5325 5326
	 * such as IA-64).
	 */
5327 5328 5329
	wmb();

	tx_ring->next_to_use = i;
5330 5331

	if (adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
5332
		e1000e_update_tdt_wa(tx_ring, i);
5333
	else
5334
		writel(i, tx_ring->tail);
5335

B
Bruce Allan 已提交
5336
	/* we need this if more than one processor can write to our tail
5337 5338
	 * at a time, it synchronizes IO on IA64/Altix systems
	 */
5339 5340 5341 5342 5343 5344 5345 5346 5347 5348
	mmiowb();
}

#define MINIMUM_DHCP_PACKET_SIZE 282
static int e1000_transfer_dhcp_info(struct e1000_adapter *adapter,
				    struct sk_buff *skb)
{
	struct e1000_hw *hw =  &adapter->hw;
	u16 length, offset;

5349 5350 5351 5352 5353
	if (vlan_tx_tag_present(skb) &&
	    !((vlan_tx_tag_get(skb) == adapter->hw.mng_cookie.vlan_id) &&
	      (adapter->hw.mng_cookie.status &
	       E1000_MNG_DHCP_COOKIE_STATUS_VLAN)))
		return 0;
5354 5355 5356 5357 5358 5359 5360 5361 5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379

	if (skb->len <= MINIMUM_DHCP_PACKET_SIZE)
		return 0;

	if (((struct ethhdr *) skb->data)->h_proto != htons(ETH_P_IP))
		return 0;

	{
		const struct iphdr *ip = (struct iphdr *)((u8 *)skb->data+14);
		struct udphdr *udp;

		if (ip->protocol != IPPROTO_UDP)
			return 0;

		udp = (struct udphdr *)((u8 *)ip + (ip->ihl << 2));
		if (ntohs(udp->dest) != 67)
			return 0;

		offset = (u8 *)udp + 8 - skb->data;
		length = skb->len - offset;
		return e1000e_mng_write_dhcp_info(hw, (u8 *)udp + 8, length);
	}

	return 0;
}

5380
static int __e1000_maybe_stop_tx(struct e1000_ring *tx_ring, int size)
5381
{
5382
	struct e1000_adapter *adapter = tx_ring->adapter;
5383

5384
	netif_stop_queue(adapter->netdev);
B
Bruce Allan 已提交
5385
	/* Herbert's original patch had:
5386
	 *  smp_mb__after_netif_stop_queue();
5387 5388
	 * but since that doesn't exist yet, just open code it.
	 */
5389 5390
	smp_mb();

B
Bruce Allan 已提交
5391
	/* We need to check again in a case another CPU has just
5392 5393
	 * made room available.
	 */
5394
	if (e1000_desc_unused(tx_ring) < size)
5395 5396 5397
		return -EBUSY;

	/* A reprieve! */
5398
	netif_start_queue(adapter->netdev);
5399 5400 5401 5402
	++adapter->restart_queue;
	return 0;
}

5403
static int e1000_maybe_stop_tx(struct e1000_ring *tx_ring, int size)
5404
{
5405 5406
	BUG_ON(size > tx_ring->count);

5407
	if (e1000_desc_unused(tx_ring) >= size)
5408
		return 0;
5409
	return __e1000_maybe_stop_tx(tx_ring, size);
5410 5411
}

5412 5413
static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
				    struct net_device *netdev)
5414 5415 5416 5417 5418
{
	struct e1000_adapter *adapter = netdev_priv(netdev);
	struct e1000_ring *tx_ring = adapter->tx_ring;
	unsigned int first;
	unsigned int tx_flags = 0;
E
Eric Dumazet 已提交
5419
	unsigned int len = skb_headlen(skb);
5420 5421
	unsigned int nr_frags;
	unsigned int mss;
5422 5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435
	int count = 0;
	int tso;
	unsigned int f;

	if (test_bit(__E1000_DOWN, &adapter->state)) {
		dev_kfree_skb_any(skb);
		return NETDEV_TX_OK;
	}

	if (skb->len <= 0) {
		dev_kfree_skb_any(skb);
		return NETDEV_TX_OK;
	}

B
Bruce Allan 已提交
5436
	/* The minimum packet size with TCTL.PSP set is 17 bytes so
5437 5438 5439 5440 5441 5442 5443 5444 5445
	 * pad skb in order to meet this minimum size requirement
	 */
	if (unlikely(skb->len < 17)) {
		if (skb_pad(skb, 17 - skb->len))
			return NETDEV_TX_OK;
		skb->len = 17;
		skb_set_tail_pointer(skb, 17);
	}

5446 5447 5448 5449
	mss = skb_shinfo(skb)->gso_size;
	if (mss) {
		u8 hdr_len;

B
Bruce Allan 已提交
5450
		/* TSO Workaround for 82571/2/3 Controllers -- if skb->data
5451 5452 5453
		 * points to just header, pull a few bytes of payload from
		 * frags into skb->data
		 */
5454
		hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
B
Bruce Allan 已提交
5455
		/* we do this workaround for ES2LAN, but it is un-necessary,
5456 5457
		 * avoiding it could save a lot of cycles
		 */
5458
		if (skb->data_len && (hdr_len == len)) {
5459 5460
			unsigned int pull_size;

5461
			pull_size = min_t(unsigned int, 4, skb->data_len);
5462
			if (!__pskb_pull_tail(skb, pull_size)) {
5463
				e_err("__pskb_pull_tail failed.\n");
5464 5465 5466
				dev_kfree_skb_any(skb);
				return NETDEV_TX_OK;
			}
E
Eric Dumazet 已提交
5467
			len = skb_headlen(skb);
5468 5469 5470 5471 5472 5473 5474 5475
		}
	}

	/* reserve a descriptor for the offload context */
	if ((mss) || (skb->ip_summed == CHECKSUM_PARTIAL))
		count++;
	count++;

5476
	count += DIV_ROUND_UP(len, adapter->tx_fifo_limit);
5477 5478 5479

	nr_frags = skb_shinfo(skb)->nr_frags;
	for (f = 0; f < nr_frags; f++)
5480 5481
		count += DIV_ROUND_UP(skb_frag_size(&skb_shinfo(skb)->frags[f]),
				      adapter->tx_fifo_limit);
5482 5483 5484 5485

	if (adapter->hw.mac.tx_pkt_filtering)
		e1000_transfer_dhcp_info(adapter, skb);

B
Bruce Allan 已提交
5486
	/* need: count + 2 desc gap to keep tail from touching
5487 5488
	 * head, otherwise try next time
	 */
5489
	if (e1000_maybe_stop_tx(tx_ring, count + 2))
5490 5491
		return NETDEV_TX_BUSY;

5492
	if (vlan_tx_tag_present(skb)) {
5493 5494 5495 5496 5497 5498
		tx_flags |= E1000_TX_FLAGS_VLAN;
		tx_flags |= (vlan_tx_tag_get(skb) << E1000_TX_FLAGS_VLAN_SHIFT);
	}

	first = tx_ring->next_to_use;

5499
	tso = e1000_tso(tx_ring, skb);
5500 5501 5502 5503 5504 5505 5506
	if (tso < 0) {
		dev_kfree_skb_any(skb);
		return NETDEV_TX_OK;
	}

	if (tso)
		tx_flags |= E1000_TX_FLAGS_TSO;
5507
	else if (e1000_tx_csum(tx_ring, skb))
5508 5509
		tx_flags |= E1000_TX_FLAGS_CSUM;

B
Bruce Allan 已提交
5510
	/* Old method was to assume IPv4 packet by default if TSO was enabled.
5511
	 * 82571 hardware supports TSO capabilities for IPv6 as well...
5512 5513
	 * no longer assume, we must.
	 */
5514 5515 5516
	if (skb->protocol == htons(ETH_P_IP))
		tx_flags |= E1000_TX_FLAGS_IPV4;

5517 5518 5519
	if (unlikely(skb->no_fcs))
		tx_flags |= E1000_TX_FLAGS_NO_FCS;

L
Lucas De Marchi 已提交
5520
	/* if count is 0 then mapping error has occurred */
5521 5522
	count = e1000_tx_map(tx_ring, skb, first, adapter->tx_fifo_limit,
			     nr_frags);
5523
	if (count) {
5524 5525 5526 5527 5528 5529 5530 5531 5532
		if (unlikely((skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP) &&
			     !adapter->tx_hwtstamp_skb)) {
			skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
			tx_flags |= E1000_TX_FLAGS_HWTSTAMP;
			adapter->tx_hwtstamp_skb = skb_get(skb);
			schedule_work(&adapter->tx_hwtstamp_work);
		} else {
			skb_tx_timestamp(skb);
		}
5533

5534
		netdev_sent_queue(netdev, skb->len);
5535
		e1000_tx_queue(tx_ring, tx_flags, count);
5536
		/* Make sure there is space in the ring for the next send. */
5537 5538 5539 5540
		e1000_maybe_stop_tx(tx_ring,
				    (MAX_SKB_FRAGS *
				     DIV_ROUND_UP(PAGE_SIZE,
						  adapter->tx_fifo_limit) + 2));
5541
	} else {
5542
		dev_kfree_skb_any(skb);
5543 5544
		tx_ring->buffer_info[first].time_stamp = 0;
		tx_ring->next_to_use = first;
5545 5546 5547 5548 5549 5550 5551 5552 5553 5554 5555 5556 5557 5558 5559 5560 5561 5562 5563 5564 5565 5566 5567
	}

	return NETDEV_TX_OK;
}

/**
 * e1000_tx_timeout - Respond to a Tx Hang
 * @netdev: network interface device structure
 **/
static void e1000_tx_timeout(struct net_device *netdev)
{
	struct e1000_adapter *adapter = netdev_priv(netdev);

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

static void e1000_reset_task(struct work_struct *work)
{
	struct e1000_adapter *adapter;
	adapter = container_of(work, struct e1000_adapter, reset_task);

5568 5569 5570 5571
	/* don't run the task if already down */
	if (test_bit(__E1000_DOWN, &adapter->state))
		return;

5572
	if (!(adapter->flags & FLAG_RESTART_NOW)) {
5573
		e1000e_dump(adapter);
5574
		e_err("Reset adapter unexpectedly\n");
5575
	}
5576 5577 5578 5579
	e1000e_reinit_locked(adapter);
}

/**
J
Jeff Kirsher 已提交
5580
 * e1000_get_stats64 - Get System Network Statistics
5581
 * @netdev: network interface device structure
J
Jeff Kirsher 已提交
5582
 * @stats: rtnl_link_stats64 pointer
5583 5584 5585
 *
 * Returns the address of the device statistics structure.
 **/
J
Jeff Kirsher 已提交
5586 5587
struct rtnl_link_stats64 *e1000e_get_stats64(struct net_device *netdev,
                                             struct rtnl_link_stats64 *stats)
5588
{
J
Jeff Kirsher 已提交
5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603
	struct e1000_adapter *adapter = netdev_priv(netdev);

	memset(stats, 0, sizeof(struct rtnl_link_stats64));
	spin_lock(&adapter->stats64_lock);
	e1000e_update_stats(adapter);
	/* Fill out the OS statistics structure */
	stats->rx_bytes = adapter->stats.gorc;
	stats->rx_packets = adapter->stats.gprc;
	stats->tx_bytes = adapter->stats.gotc;
	stats->tx_packets = adapter->stats.gptc;
	stats->multicast = adapter->stats.mprc;
	stats->collisions = adapter->stats.colc;

	/* Rx Errors */

B
Bruce Allan 已提交
5604
	/* RLEC on some newer hardware can be incorrect so build
J
Jeff Kirsher 已提交
5605 5606 5607 5608 5609 5610 5611 5612 5613 5614 5615 5616 5617 5618 5619 5620 5621 5622 5623 5624 5625 5626 5627
	 * our own version based on RUC and ROC
	 */
	stats->rx_errors = adapter->stats.rxerrc +
		adapter->stats.crcerrs + adapter->stats.algnerrc +
		adapter->stats.ruc + adapter->stats.roc +
		adapter->stats.cexterr;
	stats->rx_length_errors = adapter->stats.ruc +
					      adapter->stats.roc;
	stats->rx_crc_errors = adapter->stats.crcerrs;
	stats->rx_frame_errors = adapter->stats.algnerrc;
	stats->rx_missed_errors = adapter->stats.mpc;

	/* Tx Errors */
	stats->tx_errors = adapter->stats.ecol +
				       adapter->stats.latecol;
	stats->tx_aborted_errors = adapter->stats.ecol;
	stats->tx_window_errors = adapter->stats.latecol;
	stats->tx_carrier_errors = adapter->stats.tncrs;

	/* Tx Dropped needs to be maintained elsewhere */

	spin_unlock(&adapter->stats64_lock);
	return stats;
5628 5629 5630 5631 5632 5633 5634 5635 5636 5637 5638 5639 5640 5641
}

/**
 * e1000_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 e1000_change_mtu(struct net_device *netdev, int new_mtu)
{
	struct e1000_adapter *adapter = netdev_priv(netdev);
	int max_frame = new_mtu + ETH_HLEN + ETH_FCS_LEN;

5642
	/* Jumbo frame support */
5643 5644 5645 5646
	if ((max_frame > ETH_FRAME_LEN + ETH_FCS_LEN) &&
	    !(adapter->flags & FLAG_HAS_JUMBO_FRAMES)) {
		e_err("Jumbo Frames not supported.\n");
		return -EINVAL;
5647 5648
	}

5649 5650 5651 5652
	/* Supported frame sizes */
	if ((new_mtu < ETH_ZLEN + ETH_FCS_LEN + VLAN_HLEN) ||
	    (max_frame > adapter->max_hw_frame_size)) {
		e_err("Unsupported MTU setting\n");
5653 5654 5655
		return -EINVAL;
	}

B
Bruce Allan 已提交
5656 5657
	/* Jumbo frame workaround on 82579 and newer requires CRC be stripped */
	if ((adapter->hw.mac.type >= e1000_pch2lan) &&
5658 5659
	    !(adapter->flags2 & FLAG2_CRC_STRIPPING) &&
	    (new_mtu > ETH_DATA_LEN)) {
B
Bruce Allan 已提交
5660
		e_err("Jumbo Frames not supported on this device when CRC stripping is disabled.\n");
5661 5662 5663
		return -EINVAL;
	}

5664
	while (test_and_set_bit(__E1000_RESETTING, &adapter->state))
5665
		usleep_range(1000, 2000);
5666
	/* e1000e_down -> e1000e_reset dependent on max_frame_size & mtu */
5667
	adapter->max_frame_size = max_frame;
5668 5669
	e_info("changing MTU from %d to %d\n", netdev->mtu, new_mtu);
	netdev->mtu = new_mtu;
5670 5671 5672
	if (netif_running(netdev))
		e1000e_down(adapter);

B
Bruce Allan 已提交
5673
	/* NOTE: netdev_alloc_skb reserves 16 bytes, and typically NET_IP_ALIGN
5674 5675
	 * means we reserve 2 more, this pushes us to allocate from the next
	 * larger slab size.
5676
	 * i.e. RXBUFFER_2048 --> size-4096 slab
5677 5678
	 * However with the new *_jumbo_rx* routines, jumbo receives will use
	 * fragmented skbs
5679
	 */
5680

5681
	if (max_frame <= 2048)
5682 5683 5684 5685 5686 5687 5688 5689
		adapter->rx_buffer_len = 2048;
	else
		adapter->rx_buffer_len = 4096;

	/* adjust allocation if LPE protects us, and we aren't using SBP */
	if ((max_frame == ETH_FRAME_LEN + ETH_FCS_LEN) ||
	     (max_frame == ETH_FRAME_LEN + VLAN_HLEN + ETH_FCS_LEN))
		adapter->rx_buffer_len = ETH_FRAME_LEN + VLAN_HLEN
5690
					 + ETH_FCS_LEN;
5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703 5704 5705 5706 5707

	if (netif_running(netdev))
		e1000e_up(adapter);
	else
		e1000e_reset(adapter);

	clear_bit(__E1000_RESETTING, &adapter->state);

	return 0;
}

static int e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr,
			   int cmd)
{
	struct e1000_adapter *adapter = netdev_priv(netdev);
	struct mii_ioctl_data *data = if_mii(ifr);

5708
	if (adapter->hw.phy.media_type != e1000_media_type_copper)
5709 5710 5711 5712 5713 5714 5715
		return -EOPNOTSUPP;

	switch (cmd) {
	case SIOCGMIIPHY:
		data->phy_id = adapter->hw.phy.addr;
		break;
	case SIOCGMIIREG:
5716 5717
		e1000_phy_read_status(adapter);

5718 5719 5720 5721 5722 5723 5724 5725 5726 5727 5728 5729 5730 5731 5732 5733 5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748 5749
		switch (data->reg_num & 0x1F) {
		case MII_BMCR:
			data->val_out = adapter->phy_regs.bmcr;
			break;
		case MII_BMSR:
			data->val_out = adapter->phy_regs.bmsr;
			break;
		case MII_PHYSID1:
			data->val_out = (adapter->hw.phy.id >> 16);
			break;
		case MII_PHYSID2:
			data->val_out = (adapter->hw.phy.id & 0xFFFF);
			break;
		case MII_ADVERTISE:
			data->val_out = adapter->phy_regs.advertise;
			break;
		case MII_LPA:
			data->val_out = adapter->phy_regs.lpa;
			break;
		case MII_EXPANSION:
			data->val_out = adapter->phy_regs.expansion;
			break;
		case MII_CTRL1000:
			data->val_out = adapter->phy_regs.ctrl1000;
			break;
		case MII_STAT1000:
			data->val_out = adapter->phy_regs.stat1000;
			break;
		case MII_ESTATUS:
			data->val_out = adapter->phy_regs.estatus;
			break;
		default:
5750 5751 5752 5753 5754 5755 5756 5757 5758 5759
			return -EIO;
		}
		break;
	case SIOCSMIIREG:
	default:
		return -EOPNOTSUPP;
	}
	return 0;
}

5760 5761 5762 5763 5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792
/**
 * e1000e_hwtstamp_ioctl - control hardware time stamping
 * @netdev: network interface device structure
 * @ifreq: interface request
 *
 * Outgoing time stamping can be enabled and disabled. Play nice and
 * disable it when requested, although it shouldn't cause any overhead
 * when no packet needs it. At most one packet in the queue may be
 * marked for time stamping, otherwise it would be impossible to tell
 * for sure to which packet the hardware time stamp belongs.
 *
 * Incoming time stamping has to be configured via the hardware filters.
 * Not all combinations are supported, in particular event type has to be
 * specified. Matching the kind of event packet is not supported, with the
 * exception of "all V2 events regardless of level 2 or 4".
 **/
static int e1000e_hwtstamp_ioctl(struct net_device *netdev, struct ifreq *ifr)
{
	struct e1000_adapter *adapter = netdev_priv(netdev);
	struct hwtstamp_config config;
	int ret_val;

	if (copy_from_user(&config, ifr->ifr_data, sizeof(config)))
		return -EFAULT;

	adapter->hwtstamp_config = config;

	ret_val = e1000e_config_hwtstamp(adapter);
	if (ret_val)
		return ret_val;

	config = adapter->hwtstamp_config;

5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810
	switch (config.rx_filter) {
	case HWTSTAMP_FILTER_PTP_V2_L4_SYNC:
	case HWTSTAMP_FILTER_PTP_V2_L2_SYNC:
	case HWTSTAMP_FILTER_PTP_V2_SYNC:
	case HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ:
	case HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ:
	case HWTSTAMP_FILTER_PTP_V2_DELAY_REQ:
		/* With V2 type filters which specify a Sync or Delay Request,
		 * Path Delay Request/Response messages are also time stamped
		 * by hardware so notify the caller the requested packets plus
		 * some others are time stamped.
		 */
		config.rx_filter = HWTSTAMP_FILTER_SOME;
		break;
	default:
		break;
	}

5811 5812 5813 5814
	return copy_to_user(ifr->ifr_data, &config,
			    sizeof(config)) ? -EFAULT : 0;
}

5815 5816 5817 5818 5819 5820 5821
static int e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
{
	switch (cmd) {
	case SIOCGMIIPHY:
	case SIOCGMIIREG:
	case SIOCSMIIREG:
		return e1000_mii_ioctl(netdev, ifr, cmd);
5822 5823
	case SIOCSHWTSTAMP:
		return e1000e_hwtstamp_ioctl(netdev, ifr);
5824 5825 5826 5827 5828
	default:
		return -EOPNOTSUPP;
	}
}

5829 5830 5831 5832
static int e1000_init_phy_wakeup(struct e1000_adapter *adapter, u32 wufc)
{
	struct e1000_hw *hw = &adapter->hw;
	u32 i, mac_reg;
5833
	u16 phy_reg, wuc_enable;
5834
	int retval;
5835 5836

	/* copy MAC RARs to PHY RARs */
5837
	e1000_copy_rx_addrs_to_phy_ich8lan(hw);
5838

5839 5840 5841 5842 5843 5844 5845 5846 5847
	retval = hw->phy.ops.acquire(hw);
	if (retval) {
		e_err("Could not acquire PHY\n");
		return retval;
	}

	/* Enable access to wakeup registers on and set page to BM_WUC_PAGE */
	retval = e1000_enable_phy_wakeup_reg_access_bm(hw, &wuc_enable);
	if (retval)
5848
		goto release;
5849 5850

	/* copy MAC MTA to PHY MTA - only needed for pchlan */
5851 5852
	for (i = 0; i < adapter->hw.mac.mta_reg_count; i++) {
		mac_reg = E1000_READ_REG_ARRAY(hw, E1000_MTA, i);
5853 5854 5855 5856
		hw->phy.ops.write_reg_page(hw, BM_MTA(i),
					   (u16)(mac_reg & 0xFFFF));
		hw->phy.ops.write_reg_page(hw, BM_MTA(i) + 1,
					   (u16)((mac_reg >> 16) & 0xFFFF));
5857 5858 5859
	}

	/* configure PHY Rx Control register */
5860
	hw->phy.ops.read_reg_page(&adapter->hw, BM_RCTL, &phy_reg);
5861 5862 5863 5864 5865 5866 5867 5868 5869 5870 5871 5872 5873 5874 5875 5876
	mac_reg = er32(RCTL);
	if (mac_reg & E1000_RCTL_UPE)
		phy_reg |= BM_RCTL_UPE;
	if (mac_reg & E1000_RCTL_MPE)
		phy_reg |= BM_RCTL_MPE;
	phy_reg &= ~(BM_RCTL_MO_MASK);
	if (mac_reg & E1000_RCTL_MO_3)
		phy_reg |= (((mac_reg & E1000_RCTL_MO_3) >> E1000_RCTL_MO_SHIFT)
				<< BM_RCTL_MO_SHIFT);
	if (mac_reg & E1000_RCTL_BAM)
		phy_reg |= BM_RCTL_BAM;
	if (mac_reg & E1000_RCTL_PMCF)
		phy_reg |= BM_RCTL_PMCF;
	mac_reg = er32(CTRL);
	if (mac_reg & E1000_CTRL_RFCE)
		phy_reg |= BM_RCTL_RFCE;
5877
	hw->phy.ops.write_reg_page(&adapter->hw, BM_RCTL, phy_reg);
5878 5879 5880 5881 5882 5883

	/* enable PHY wakeup in MAC register */
	ew32(WUFC, wufc);
	ew32(WUC, E1000_WUC_PHY_WAKE | E1000_WUC_PME_EN);

	/* configure and enable PHY wakeup in PHY registers */
5884 5885
	hw->phy.ops.write_reg_page(&adapter->hw, BM_WUFC, wufc);
	hw->phy.ops.write_reg_page(&adapter->hw, BM_WUC, E1000_WUC_PME_EN);
5886 5887

	/* activate PHY wakeup */
5888 5889
	wuc_enable |= BM_WUC_ENABLE_BIT | BM_WUC_HOST_WU_BIT;
	retval = e1000_disable_phy_wakeup_reg_access_bm(hw, &wuc_enable);
5890 5891
	if (retval)
		e_err("Could not set PHY Host Wakeup bit\n");
5892
release:
5893
	hw->phy.ops.release(hw);
5894 5895 5896 5897

	return retval;
}

5898 5899
static int __e1000_shutdown(struct pci_dev *pdev, bool *enable_wake,
			    bool runtime)
5900 5901 5902 5903 5904
{
	struct net_device *netdev = pci_get_drvdata(pdev);
	struct e1000_adapter *adapter = netdev_priv(netdev);
	struct e1000_hw *hw = &adapter->hw;
	u32 ctrl, ctrl_ext, rctl, status;
5905 5906
	/* Runtime suspend should only enable wakeup for link changes */
	u32 wufc = runtime ? E1000_WUFC_LNKC : adapter->wol;
5907 5908 5909 5910 5911
	int retval = 0;

	netif_device_detach(netdev);

	if (netif_running(netdev)) {
5912 5913 5914 5915 5916
		int count = E1000_CHECK_RESET_COUNT;

		while (test_bit(__E1000_RESETTING, &adapter->state) && count--)
			usleep_range(10000, 20000);

5917 5918 5919 5920
		WARN_ON(test_bit(__E1000_RESETTING, &adapter->state));
		e1000e_down(adapter);
		e1000_free_irq(adapter);
	}
5921
	e1000e_reset_interrupt_capability(adapter);
5922 5923 5924 5925 5926 5927 5928 5929 5930 5931 5932

	retval = pci_save_state(pdev);
	if (retval)
		return retval;

	status = er32(STATUS);
	if (status & E1000_STATUS_LU)
		wufc &= ~E1000_WUFC_LNKC;

	if (wufc) {
		e1000_setup_rctl(adapter);
5933
		e1000e_set_rx_mode(netdev);
5934 5935 5936 5937 5938 5939 5940 5941 5942 5943 5944 5945 5946

		/* turn on all-multi mode if wake on multicast is enabled */
		if (wufc & E1000_WUFC_MC) {
			rctl = er32(RCTL);
			rctl |= E1000_RCTL_MPE;
			ew32(RCTL, rctl);
		}

		ctrl = er32(CTRL);
		/* advertise wake from D3Cold */
		#define E1000_CTRL_ADVD3WUC 0x00100000
		/* phy power management enable */
		#define E1000_CTRL_EN_PHY_PWR_MGMT 0x00200000
5947 5948 5949
		ctrl |= E1000_CTRL_ADVD3WUC;
		if (!(adapter->flags2 & FLAG2_HAS_PHY_WAKEUP))
			ctrl |= E1000_CTRL_EN_PHY_PWR_MGMT;
5950 5951
		ew32(CTRL, ctrl);

5952 5953 5954
		if (adapter->hw.phy.media_type == e1000_media_type_fiber ||
		    adapter->hw.phy.media_type ==
		    e1000_media_type_internal_serdes) {
5955 5956
			/* keep the laser running in D3 */
			ctrl_ext = er32(CTRL_EXT);
5957
			ctrl_ext |= E1000_CTRL_EXT_SDP3_DATA;
5958 5959 5960
			ew32(CTRL_EXT, ctrl_ext);
		}

5961
		if (adapter->flags & FLAG_IS_ICH)
5962
			e1000_suspend_workarounds_ich8lan(&adapter->hw);
5963

5964 5965 5966
		/* Allow time for pending master requests to run */
		e1000e_disable_pcie_master(&adapter->hw);

5967
		if (adapter->flags2 & FLAG2_HAS_PHY_WAKEUP) {
5968 5969 5970 5971 5972 5973 5974 5975 5976
			/* enable wakeup by the PHY */
			retval = e1000_init_phy_wakeup(adapter, wufc);
			if (retval)
				return retval;
		} else {
			/* enable wakeup by the MAC */
			ew32(WUFC, wufc);
			ew32(WUC, E1000_WUC_PME_EN);
		}
5977 5978 5979 5980 5981
	} else {
		ew32(WUC, 0);
		ew32(WUFC, 0);
	}

5982 5983
	*enable_wake = !!wufc;

5984
	/* make sure adapter isn't asleep if manageability is enabled */
5985 5986
	if ((adapter->flags & FLAG_MNG_PT_ENABLED) ||
	    (hw->mac.ops.check_mng_mode(hw)))
5987
		*enable_wake = true;
5988 5989 5990 5991

	if (adapter->hw.phy.type == e1000_phy_igp_3)
		e1000e_igp3_phy_powerdown_workaround_ich8lan(&adapter->hw);

B
Bruce Allan 已提交
5992
	/* Release control of h/w to f/w.  If f/w is AMT enabled, this
5993 5994
	 * would have already happened in close and is redundant.
	 */
5995
	e1000e_release_hw_control(adapter);
5996 5997 5998

	pci_disable_device(pdev);

5999 6000 6001 6002 6003 6004 6005 6006 6007 6008 6009 6010 6011 6012 6013 6014 6015 6016 6017 6018
	return 0;
}

static void e1000_power_off(struct pci_dev *pdev, bool sleep, bool wake)
{
	if (sleep && wake) {
		pci_prepare_to_sleep(pdev);
		return;
	}

	pci_wake_from_d3(pdev, wake);
	pci_set_power_state(pdev, PCI_D3hot);
}

static void e1000_complete_shutdown(struct pci_dev *pdev, bool sleep,
                                    bool wake)
{
	struct net_device *netdev = pci_get_drvdata(pdev);
	struct e1000_adapter *adapter = netdev_priv(netdev);

B
Bruce Allan 已提交
6019
	/* The pci-e switch on some quad port adapters will report a
6020 6021 6022 6023 6024 6025 6026 6027
	 * correctable error when the MAC transitions from D0 to D3.  To
	 * prevent this we need to mask off the correctable errors on the
	 * downstream port of the pci-e switch.
	 */
	if (adapter->flags & FLAG_IS_QUAD_PORT) {
		struct pci_dev *us_dev = pdev->bus->self;
		u16 devctl;

6028 6029 6030
		pcie_capability_read_word(us_dev, PCI_EXP_DEVCTL, &devctl);
		pcie_capability_write_word(us_dev, PCI_EXP_DEVCTL,
					   (devctl & ~PCI_EXP_DEVCTL_CERE));
6031

6032
		e1000_power_off(pdev, sleep, wake);
6033

6034
		pcie_capability_write_word(us_dev, PCI_EXP_DEVCTL, devctl);
6035
	} else {
6036
		e1000_power_off(pdev, sleep, wake);
6037
	}
6038 6039
}

6040 6041 6042
#ifdef CONFIG_PCIEASPM
static void __e1000e_disable_aspm(struct pci_dev *pdev, u16 state)
{
6043
	pci_disable_link_state_locked(pdev, state);
6044 6045 6046
}
#else
static void __e1000e_disable_aspm(struct pci_dev *pdev, u16 state)
6047
{
6048 6049 6050 6051 6052 6053 6054
	u16 aspm_ctl = 0;

	if (state & PCIE_LINK_STATE_L0S)
		aspm_ctl |= PCI_EXP_LNKCTL_ASPM_L0S;
	if (state & PCIE_LINK_STATE_L1)
		aspm_ctl |= PCI_EXP_LNKCTL_ASPM_L1;

B
Bruce Allan 已提交
6055
	/* Both device and parent should have the same ASPM setting.
6056
	 * Disable ASPM in downstream component first and then upstream.
6057
	 */
6058
	pcie_capability_clear_word(pdev, PCI_EXP_LNKCTL, aspm_ctl);
6059

6060 6061
	if (pdev->bus->self)
		pcie_capability_clear_word(pdev->bus->self, PCI_EXP_LNKCTL,
6062
					   aspm_ctl);
6063 6064
}
#endif
6065
static void e1000e_disable_aspm(struct pci_dev *pdev, u16 state)
6066 6067 6068 6069 6070 6071
{
	dev_info(&pdev->dev, "Disabling ASPM %s %s\n",
		 (state & PCIE_LINK_STATE_L0S) ? "L0s" : "",
		 (state & PCIE_LINK_STATE_L1) ? "L1" : "");

	__e1000e_disable_aspm(pdev, state);
6072 6073
}

R
Rafael J. Wysocki 已提交
6074
#ifdef CONFIG_PM
6075
static bool e1000e_pm_ready(struct e1000_adapter *adapter)
6076
{
6077
	return !!adapter->tx_ring->buffer_info;
6078 6079
}

6080
static int __e1000_resume(struct pci_dev *pdev)
6081 6082 6083 6084
{
	struct net_device *netdev = pci_get_drvdata(pdev);
	struct e1000_adapter *adapter = netdev_priv(netdev);
	struct e1000_hw *hw = &adapter->hw;
6085
	u16 aspm_disable_flag = 0;
6086 6087
	u32 err;

6088 6089 6090 6091 6092 6093 6094
	if (adapter->flags2 & FLAG2_DISABLE_ASPM_L0S)
		aspm_disable_flag = PCIE_LINK_STATE_L0S;
	if (adapter->flags2 & FLAG2_DISABLE_ASPM_L1)
		aspm_disable_flag |= PCIE_LINK_STATE_L1;
	if (aspm_disable_flag)
		e1000e_disable_aspm(pdev, aspm_disable_flag);

6095 6096
	pci_set_power_state(pdev, PCI_D0);
	pci_restore_state(pdev);
6097
	pci_save_state(pdev);
T
Taku Izumi 已提交
6098

6099
	e1000e_set_interrupt_capability(adapter);
6100 6101 6102 6103 6104 6105
	if (netif_running(netdev)) {
		err = e1000_request_irq(adapter);
		if (err)
			return err;
	}

B
Bruce Allan 已提交
6106
	if (hw->mac.type >= e1000_pch2lan)
6107 6108
		e1000_resume_workarounds_pchlan(&adapter->hw);

6109
	e1000e_power_up_phy(adapter);
6110 6111 6112 6113 6114 6115 6116 6117 6118 6119 6120 6121

	/* report the system wakeup cause from S3/S4 */
	if (adapter->flags2 & FLAG2_HAS_PHY_WAKEUP) {
		u16 phy_data;

		e1e_rphy(&adapter->hw, BM_WUS, &phy_data);
		if (phy_data) {
			e_info("PHY Wakeup cause - %s\n",
				phy_data & E1000_WUS_EX ? "Unicast Packet" :
				phy_data & E1000_WUS_MC ? "Multicast Packet" :
				phy_data & E1000_WUS_BC ? "Broadcast Packet" :
				phy_data & E1000_WUS_MAG ? "Magic Packet" :
6122 6123
				phy_data & E1000_WUS_LNKC ?
				"Link Status Change" : "other");
6124 6125 6126 6127 6128 6129 6130 6131 6132 6133 6134 6135 6136 6137 6138 6139
		}
		e1e_wphy(&adapter->hw, BM_WUS, ~0);
	} else {
		u32 wus = er32(WUS);
		if (wus) {
			e_info("MAC Wakeup cause - %s\n",
				wus & E1000_WUS_EX ? "Unicast Packet" :
				wus & E1000_WUS_MC ? "Multicast Packet" :
				wus & E1000_WUS_BC ? "Broadcast Packet" :
				wus & E1000_WUS_MAG ? "Magic Packet" :
				wus & E1000_WUS_LNKC ? "Link Status Change" :
				"other");
		}
		ew32(WUS, ~0);
	}

6140 6141
	e1000e_reset(adapter);

6142
	e1000_init_manageability_pt(adapter);
6143 6144 6145 6146 6147 6148

	if (netif_running(netdev))
		e1000e_up(adapter);

	netif_device_attach(netdev);

B
Bruce Allan 已提交
6149
	/* If the controller has AMT, do not set DRV_LOAD until the interface
6150
	 * is up.  For all other cases, let the f/w know that the h/w is now
6151 6152
	 * under the control of the driver.
	 */
J
Jesse Brandeburg 已提交
6153
	if (!(adapter->flags & FLAG_HAS_AMT))
6154
		e1000e_get_hw_control(adapter);
6155 6156 6157

	return 0;
}
6158

6159 6160 6161 6162 6163 6164 6165 6166 6167 6168 6169 6170 6171 6172
#ifdef CONFIG_PM_SLEEP
static int e1000_suspend(struct device *dev)
{
	struct pci_dev *pdev = to_pci_dev(dev);
	int retval;
	bool wake;

	retval = __e1000_shutdown(pdev, &wake, false);
	if (!retval)
		e1000_complete_shutdown(pdev, true, wake);

	return retval;
}

6173 6174 6175 6176 6177 6178 6179 6180 6181 6182 6183
static int e1000_resume(struct device *dev)
{
	struct pci_dev *pdev = to_pci_dev(dev);
	struct net_device *netdev = pci_get_drvdata(pdev);
	struct e1000_adapter *adapter = netdev_priv(netdev);

	if (e1000e_pm_ready(adapter))
		adapter->idle_check = true;

	return __e1000_resume(pdev);
}
6184 6185 6186 6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197 6198 6199 6200 6201 6202 6203 6204 6205 6206 6207 6208 6209 6210 6211 6212 6213 6214 6215 6216 6217 6218
#endif /* CONFIG_PM_SLEEP */

#ifdef CONFIG_PM_RUNTIME
static int e1000_runtime_suspend(struct device *dev)
{
	struct pci_dev *pdev = to_pci_dev(dev);
	struct net_device *netdev = pci_get_drvdata(pdev);
	struct e1000_adapter *adapter = netdev_priv(netdev);

	if (e1000e_pm_ready(adapter)) {
		bool wake;

		__e1000_shutdown(pdev, &wake, true);
	}

	return 0;
}

static int e1000_idle(struct device *dev)
{
	struct pci_dev *pdev = to_pci_dev(dev);
	struct net_device *netdev = pci_get_drvdata(pdev);
	struct e1000_adapter *adapter = netdev_priv(netdev);

	if (!e1000e_pm_ready(adapter))
		return 0;

	if (adapter->idle_check) {
		adapter->idle_check = false;
		if (!e1000e_has_link(adapter))
			pm_schedule_suspend(dev, MSEC_PER_SEC);
	}

	return -EBUSY;
}
6219 6220 6221 6222 6223 6224 6225 6226 6227 6228 6229 6230 6231

static int e1000_runtime_resume(struct device *dev)
{
	struct pci_dev *pdev = to_pci_dev(dev);
	struct net_device *netdev = pci_get_drvdata(pdev);
	struct e1000_adapter *adapter = netdev_priv(netdev);

	if (!e1000e_pm_ready(adapter))
		return 0;

	adapter->idle_check = !dev->power.runtime_auto;
	return __e1000_resume(pdev);
}
6232
#endif /* CONFIG_PM_RUNTIME */
R
Rafael J. Wysocki 已提交
6233
#endif /* CONFIG_PM */
6234 6235 6236

static void e1000_shutdown(struct pci_dev *pdev)
{
6237 6238
	bool wake = false;

6239
	__e1000_shutdown(pdev, &wake, false);
6240 6241 6242

	if (system_state == SYSTEM_POWER_OFF)
		e1000_complete_shutdown(pdev, false, wake);
6243 6244 6245
}

#ifdef CONFIG_NET_POLL_CONTROLLER
6246

6247
static irqreturn_t e1000_intr_msix(int __always_unused irq, void *data)
6248 6249 6250 6251 6252
{
	struct net_device *netdev = data;
	struct e1000_adapter *adapter = netdev_priv(netdev);

	if (adapter->msix_entries) {
6253 6254
		int vector, msix_irq;

6255 6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266 6267 6268 6269 6270 6271 6272 6273 6274 6275 6276
		vector = 0;
		msix_irq = adapter->msix_entries[vector].vector;
		disable_irq(msix_irq);
		e1000_intr_msix_rx(msix_irq, netdev);
		enable_irq(msix_irq);

		vector++;
		msix_irq = adapter->msix_entries[vector].vector;
		disable_irq(msix_irq);
		e1000_intr_msix_tx(msix_irq, netdev);
		enable_irq(msix_irq);

		vector++;
		msix_irq = adapter->msix_entries[vector].vector;
		disable_irq(msix_irq);
		e1000_msix_other(msix_irq, netdev);
		enable_irq(msix_irq);
	}

	return IRQ_HANDLED;
}

B
Bruce Allan 已提交
6277 6278 6279 6280
/**
 * e1000_netpoll
 * @netdev: network interface device structure
 *
6281 6282 6283 6284 6285 6286 6287 6288
 * 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 e1000_netpoll(struct net_device *netdev)
{
	struct e1000_adapter *adapter = netdev_priv(netdev);

6289 6290 6291 6292 6293 6294 6295 6296 6297 6298 6299 6300 6301 6302 6303
	switch (adapter->int_mode) {
	case E1000E_INT_MODE_MSIX:
		e1000_intr_msix(adapter->pdev->irq, netdev);
		break;
	case E1000E_INT_MODE_MSI:
		disable_irq(adapter->pdev->irq);
		e1000_intr_msi(adapter->pdev->irq, netdev);
		enable_irq(adapter->pdev->irq);
		break;
	default: /* E1000E_INT_MODE_LEGACY */
		disable_irq(adapter->pdev->irq);
		e1000_intr(adapter->pdev->irq, netdev);
		enable_irq(adapter->pdev->irq);
		break;
	}
6304 6305 6306 6307 6308 6309 6310 6311 6312 6313 6314 6315 6316 6317 6318 6319 6320 6321 6322
}
#endif

/**
 * e1000_io_error_detected - called when PCI error is detected
 * @pdev: Pointer to PCI device
 * @state: The current pci connection state
 *
 * This function is called after a PCI bus error affecting
 * this device has been detected.
 */
static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev,
						pci_channel_state_t state)
{
	struct net_device *netdev = pci_get_drvdata(pdev);
	struct e1000_adapter *adapter = netdev_priv(netdev);

	netif_device_detach(netdev);

6323 6324 6325
	if (state == pci_channel_io_perm_failure)
		return PCI_ERS_RESULT_DISCONNECT;

6326 6327 6328 6329 6330 6331 6332 6333 6334 6335 6336 6337 6338 6339 6340 6341 6342 6343 6344 6345
	if (netif_running(netdev))
		e1000e_down(adapter);
	pci_disable_device(pdev);

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

/**
 * e1000_io_slot_reset - called after the pci bus has been reset.
 * @pdev: Pointer to PCI device
 *
 * Restart the card from scratch, as if from a cold-boot. Implementation
 * resembles the first-half of the e1000_resume routine.
 */
static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev)
{
	struct net_device *netdev = pci_get_drvdata(pdev);
	struct e1000_adapter *adapter = netdev_priv(netdev);
	struct e1000_hw *hw = &adapter->hw;
6346
	u16 aspm_disable_flag = 0;
T
Taku Izumi 已提交
6347
	int err;
J
Jesse Brandeburg 已提交
6348
	pci_ers_result_t result;
6349

6350 6351
	if (adapter->flags2 & FLAG2_DISABLE_ASPM_L0S)
		aspm_disable_flag = PCIE_LINK_STATE_L0S;
6352
	if (adapter->flags2 & FLAG2_DISABLE_ASPM_L1)
6353 6354 6355 6356
		aspm_disable_flag |= PCIE_LINK_STATE_L1;
	if (aspm_disable_flag)
		e1000e_disable_aspm(pdev, aspm_disable_flag);

6357
	err = pci_enable_device_mem(pdev);
T
Taku Izumi 已提交
6358
	if (err) {
6359 6360
		dev_err(&pdev->dev,
			"Cannot re-enable PCI device after reset.\n");
J
Jesse Brandeburg 已提交
6361 6362 6363
		result = PCI_ERS_RESULT_DISCONNECT;
	} else {
		pci_set_master(pdev);
6364
		pdev->state_saved = true;
J
Jesse Brandeburg 已提交
6365
		pci_restore_state(pdev);
6366

J
Jesse Brandeburg 已提交
6367 6368
		pci_enable_wake(pdev, PCI_D3hot, 0);
		pci_enable_wake(pdev, PCI_D3cold, 0);
6369

J
Jesse Brandeburg 已提交
6370 6371 6372 6373
		e1000e_reset(adapter);
		ew32(WUS, ~0);
		result = PCI_ERS_RESULT_RECOVERED;
	}
6374

J
Jesse Brandeburg 已提交
6375 6376 6377
	pci_cleanup_aer_uncorrect_error_status(pdev);

	return result;
6378 6379 6380 6381 6382 6383 6384 6385 6386 6387 6388 6389 6390 6391 6392
}

/**
 * e1000_io_resume - called when traffic can start flowing again.
 * @pdev: Pointer to PCI device
 *
 * This callback is called when the error recovery driver tells us that
 * its OK to resume normal operation. Implementation resembles the
 * second-half of the e1000_resume routine.
 */
static void e1000_io_resume(struct pci_dev *pdev)
{
	struct net_device *netdev = pci_get_drvdata(pdev);
	struct e1000_adapter *adapter = netdev_priv(netdev);

6393
	e1000_init_manageability_pt(adapter);
6394 6395 6396 6397 6398 6399 6400 6401 6402 6403 6404

	if (netif_running(netdev)) {
		if (e1000e_up(adapter)) {
			dev_err(&pdev->dev,
				"can't bring device back up after reset\n");
			return;
		}
	}

	netif_device_attach(netdev);

B
Bruce Allan 已提交
6405
	/* If the controller has AMT, do not set DRV_LOAD until the interface
6406
	 * is up.  For all other cases, let the f/w know that the h/w is now
6407 6408
	 * under the control of the driver.
	 */
J
Jesse Brandeburg 已提交
6409
	if (!(adapter->flags & FLAG_HAS_AMT))
6410
		e1000e_get_hw_control(adapter);
6411 6412 6413 6414 6415 6416 6417

}

static void e1000_print_device_info(struct e1000_adapter *adapter)
{
	struct e1000_hw *hw = &adapter->hw;
	struct net_device *netdev = adapter->netdev;
6418 6419
	u32 ret_val;
	u8 pba_str[E1000_PBANUM_LENGTH];
6420 6421

	/* print bus type/speed/width info */
6422
	e_info("(PCI Express:2.5GT/s:%s) %pM\n",
6423 6424 6425 6426
	       /* bus width */
	       ((hw->bus.width == e1000_bus_width_pcie_x4) ? "Width x4" :
	        "Width x1"),
	       /* MAC address */
J
Johannes Berg 已提交
6427
	       netdev->dev_addr);
6428 6429
	e_info("Intel(R) PRO/%s Network Connection\n",
	       (hw->phy.type == e1000_phy_ife) ? "10/100" : "1000");
6430 6431 6432
	ret_val = e1000_read_pba_string_generic(hw, pba_str,
						E1000_PBANUM_LENGTH);
	if (ret_val)
6433
		strlcpy((char *)pba_str, "Unknown", sizeof(pba_str));
6434 6435
	e_info("MAC: %d, PHY: %d, PBA No: %s\n",
	       hw->mac.type, hw->phy.type, pba_str);
6436 6437
}

6438 6439 6440 6441 6442 6443 6444 6445 6446 6447
static void e1000_eeprom_checks(struct e1000_adapter *adapter)
{
	struct e1000_hw *hw = &adapter->hw;
	int ret_val;
	u16 buf = 0;

	if (hw->mac.type != e1000_82573)
		return;

	ret_val = e1000_read_nvm(hw, NVM_INIT_CONTROL2_REG, 1, &buf);
6448 6449
	le16_to_cpus(&buf);
	if (!ret_val && (!(buf & (1 << 0)))) {
6450
		/* Deep Smart Power Down (DSPD) */
6451 6452
		dev_warn(&adapter->pdev->dev,
			 "Warning: detected DSPD enabled in EEPROM\n");
6453 6454 6455
	}
}

6456
static int e1000_set_features(struct net_device *netdev,
6457
			      netdev_features_t features)
6458 6459
{
	struct e1000_adapter *adapter = netdev_priv(netdev);
6460
	netdev_features_t changed = features ^ netdev->features;
6461 6462 6463 6464 6465

	if (changed & (NETIF_F_TSO | NETIF_F_TSO6))
		adapter->flags |= FLAG_TSO_FORCE;

	if (!(changed & (NETIF_F_HW_VLAN_RX | NETIF_F_HW_VLAN_TX |
B
Ben Greear 已提交
6466 6467
			 NETIF_F_RXCSUM | NETIF_F_RXHASH | NETIF_F_RXFCS |
			 NETIF_F_RXALL)))
6468 6469
		return 0;

B
Ben Greear 已提交
6470 6471 6472 6473 6474 6475 6476 6477 6478 6479 6480 6481 6482 6483
	if (changed & NETIF_F_RXFCS) {
		if (features & NETIF_F_RXFCS) {
			adapter->flags2 &= ~FLAG2_CRC_STRIPPING;
		} else {
			/* We need to take it back to defaults, which might mean
			 * stripping is still disabled at the adapter level.
			 */
			if (adapter->flags2 & FLAG2_DFLT_CRC_STRIPPING)
				adapter->flags2 |= FLAG2_CRC_STRIPPING;
			else
				adapter->flags2 &= ~FLAG2_CRC_STRIPPING;
		}
	}

6484 6485
	netdev->features = features;

6486 6487 6488 6489 6490 6491 6492 6493
	if (netif_running(netdev))
		e1000e_reinit_locked(adapter);
	else
		e1000e_reset(adapter);

	return 0;
}

6494 6495 6496
static const struct net_device_ops e1000e_netdev_ops = {
	.ndo_open		= e1000_open,
	.ndo_stop		= e1000_close,
6497
	.ndo_start_xmit		= e1000_xmit_frame,
J
Jeff Kirsher 已提交
6498
	.ndo_get_stats64	= e1000e_get_stats64,
6499
	.ndo_set_rx_mode	= e1000e_set_rx_mode,
6500 6501 6502 6503 6504 6505 6506 6507 6508 6509 6510
	.ndo_set_mac_address	= e1000_set_mac,
	.ndo_change_mtu		= e1000_change_mtu,
	.ndo_do_ioctl		= e1000_ioctl,
	.ndo_tx_timeout		= e1000_tx_timeout,
	.ndo_validate_addr	= eth_validate_addr,

	.ndo_vlan_rx_add_vid	= e1000_vlan_rx_add_vid,
	.ndo_vlan_rx_kill_vid	= e1000_vlan_rx_kill_vid,
#ifdef CONFIG_NET_POLL_CONTROLLER
	.ndo_poll_controller	= e1000_netpoll,
#endif
6511
	.ndo_set_features = e1000_set_features,
6512 6513
};

6514 6515 6516 6517 6518 6519 6520 6521 6522 6523 6524
/**
 * e1000_probe - Device Initialization Routine
 * @pdev: PCI device information struct
 * @ent: entry in e1000_pci_tbl
 *
 * Returns 0 on success, negative on failure
 *
 * e1000_probe initializes an adapter identified by a pci_dev structure.
 * The OS initialization, configuring of the adapter private structure,
 * and a hardware reset occur.
 **/
6525
static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
6526 6527 6528 6529 6530
{
	struct net_device *netdev;
	struct e1000_adapter *adapter;
	struct e1000_hw *hw;
	const struct e1000_info *ei = e1000_info_tbl[ent->driver_data];
6531 6532
	resource_size_t mmio_start, mmio_len;
	resource_size_t flash_start, flash_len;
6533
	static int cards_found;
6534
	u16 aspm_disable_flag = 0;
6535 6536 6537 6538
	int i, err, pci_using_dac;
	u16 eeprom_data = 0;
	u16 eeprom_apme_mask = E1000_EEPROM_APME;

6539 6540
	if (ei->flags2 & FLAG2_DISABLE_ASPM_L0S)
		aspm_disable_flag = PCIE_LINK_STATE_L0S;
6541
	if (ei->flags2 & FLAG2_DISABLE_ASPM_L1)
6542 6543 6544
		aspm_disable_flag |= PCIE_LINK_STATE_L1;
	if (aspm_disable_flag)
		e1000e_disable_aspm(pdev, aspm_disable_flag);
T
Taku Izumi 已提交
6545

6546
	err = pci_enable_device_mem(pdev);
6547 6548 6549 6550
	if (err)
		return err;

	pci_using_dac = 0;
6551
	err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(64));
6552
	if (!err) {
6553
		err = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64));
6554 6555 6556
		if (!err)
			pci_using_dac = 1;
	} else {
6557
		err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
6558
		if (err) {
6559 6560
			err = dma_set_coherent_mask(&pdev->dev,
						    DMA_BIT_MASK(32));
6561
			if (err) {
6562
				dev_err(&pdev->dev, "No usable DMA configuration, aborting\n");
6563 6564 6565 6566 6567
				goto err_dma;
			}
		}
	}

6568
	err = pci_request_selected_regions_exclusive(pdev,
6569 6570
					  pci_select_bars(pdev, IORESOURCE_MEM),
					  e1000e_driver_name);
6571 6572 6573
	if (err)
		goto err_pci_reg;

6574
	/* AER (Advanced Error Reporting) hooks */
6575
	pci_enable_pcie_error_reporting(pdev);
6576

6577
	pci_set_master(pdev);
6578 6579 6580 6581
	/* PCI config space info */
	err = pci_save_state(pdev);
	if (err)
		goto err_alloc_etherdev;
6582 6583 6584 6585 6586 6587 6588 6589

	err = -ENOMEM;
	netdev = alloc_etherdev(sizeof(struct e1000_adapter));
	if (!netdev)
		goto err_alloc_etherdev;

	SET_NETDEV_DEV(netdev, &pdev->dev);

6590 6591
	netdev->irq = pdev->irq;

6592 6593 6594 6595 6596 6597 6598 6599
	pci_set_drvdata(pdev, netdev);
	adapter = netdev_priv(netdev);
	hw = &adapter->hw;
	adapter->netdev = netdev;
	adapter->pdev = pdev;
	adapter->ei = ei;
	adapter->pba = ei->pba;
	adapter->flags = ei->flags;
J
Jeff Kirsher 已提交
6600
	adapter->flags2 = ei->flags2;
6601 6602
	adapter->hw.adapter = adapter;
	adapter->hw.mac.type = ei->mac;
6603
	adapter->max_hw_frame_size = ei->max_hw_frame_size;
6604
	adapter->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE);
6605 6606 6607 6608 6609 6610 6611 6612 6613 6614 6615 6616 6617 6618 6619 6620 6621 6622 6623

	mmio_start = pci_resource_start(pdev, 0);
	mmio_len = pci_resource_len(pdev, 0);

	err = -EIO;
	adapter->hw.hw_addr = ioremap(mmio_start, mmio_len);
	if (!adapter->hw.hw_addr)
		goto err_ioremap;

	if ((adapter->flags & FLAG_HAS_FLASH) &&
	    (pci_resource_flags(pdev, 1) & IORESOURCE_MEM)) {
		flash_start = pci_resource_start(pdev, 1);
		flash_len = pci_resource_len(pdev, 1);
		adapter->hw.flash_address = ioremap(flash_start, flash_len);
		if (!adapter->hw.flash_address)
			goto err_flashmap;
	}

	/* construct the net_device struct */
6624
	netdev->netdev_ops		= &e1000e_netdev_ops;
6625 6626
	e1000e_set_ethtool_ops(netdev);
	netdev->watchdog_timeo		= 5 * HZ;
B
Bruce Allan 已提交
6627
	netif_napi_add(netdev, &adapter->napi, e1000e_poll, 64);
6628
	strlcpy(netdev->name, pci_name(pdev), sizeof(netdev->name));
6629 6630 6631 6632 6633 6634

	netdev->mem_start = mmio_start;
	netdev->mem_end = mmio_start + mmio_len;

	adapter->bd_number = cards_found++;

6635 6636
	e1000e_check_options(adapter);

6637 6638 6639 6640 6641 6642 6643 6644 6645
	/* setup adapter struct */
	err = e1000_sw_init(adapter);
	if (err)
		goto err_sw_init;

	memcpy(&hw->mac.ops, ei->mac_ops, sizeof(hw->mac.ops));
	memcpy(&hw->nvm.ops, ei->nvm_ops, sizeof(hw->nvm.ops));
	memcpy(&hw->phy.ops, ei->phy_ops, sizeof(hw->phy.ops));

J
Jeff Kirsher 已提交
6646
	err = ei->get_variants(adapter);
6647 6648 6649
	if (err)
		goto err_hw_init;

6650 6651 6652 6653
	if ((adapter->flags & FLAG_IS_ICH) &&
	    (adapter->flags & FLAG_READ_ONLY_NVM))
		e1000e_write_protect_nvm_ich8lan(&adapter->hw);

6654 6655
	hw->mac.ops.get_bus_info(&adapter->hw);

6656
	adapter->hw.phy.autoneg_wait_to_complete = 0;
6657 6658

	/* Copper options */
6659
	if (adapter->hw.phy.media_type == e1000_media_type_copper) {
6660 6661 6662 6663 6664
		adapter->hw.phy.mdix = AUTO_ALL_MODES;
		adapter->hw.phy.disable_polarity_correction = 0;
		adapter->hw.phy.ms_type = e1000_ms_hw_default;
	}

6665
	if (hw->phy.ops.check_reset_block && hw->phy.ops.check_reset_block(hw))
6666 6667
		dev_info(&pdev->dev,
			 "PHY reset is blocked due to SOL/IDER session.\n");
6668

6669 6670 6671 6672 6673 6674
	/* Set initial default active device features */
	netdev->features = (NETIF_F_SG |
			    NETIF_F_HW_VLAN_RX |
			    NETIF_F_HW_VLAN_TX |
			    NETIF_F_TSO |
			    NETIF_F_TSO6 |
6675
			    NETIF_F_RXHASH |
6676 6677 6678 6679 6680
			    NETIF_F_RXCSUM |
			    NETIF_F_HW_CSUM);

	/* Set user-changeable features (subset of all device features) */
	netdev->hw_features = netdev->features;
B
Ben Greear 已提交
6681
	netdev->hw_features |= NETIF_F_RXFCS;
6682
	netdev->priv_flags |= IFF_SUPP_NOFCS;
B
Ben Greear 已提交
6683
	netdev->hw_features |= NETIF_F_RXALL;
6684 6685 6686 6687

	if (adapter->flags & FLAG_HAS_HW_VLAN_FILTER)
		netdev->features |= NETIF_F_HW_VLAN_FILTER;

6688 6689 6690 6691
	netdev->vlan_features |= (NETIF_F_SG |
				  NETIF_F_TSO |
				  NETIF_F_TSO6 |
				  NETIF_F_HW_CSUM);
6692

6693 6694
	netdev->priv_flags |= IFF_UNICAST_FLT;

6695
	if (pci_using_dac) {
6696
		netdev->features |= NETIF_F_HIGHDMA;
6697 6698
		netdev->vlan_features |= NETIF_F_HIGHDMA;
	}
6699 6700 6701 6702

	if (e1000e_enable_mng_pass_thru(&adapter->hw))
		adapter->flags |= FLAG_MNG_PT_ENABLED;

B
Bruce Allan 已提交
6703
	/* before reading the NVM, reset the controller to
6704 6705
	 * put the device in a known good starting state
	 */
6706 6707
	adapter->hw.mac.ops.reset_hw(&adapter->hw);

B
Bruce Allan 已提交
6708
	/* systems with ASPM and others may see the checksum fail on the first
6709 6710 6711 6712 6713 6714
	 * attempt. Let's give it a few tries
	 */
	for (i = 0;; i++) {
		if (e1000_validate_nvm_checksum(&adapter->hw) >= 0)
			break;
		if (i == 2) {
6715
			dev_err(&pdev->dev, "The NVM Checksum Is Not Valid\n");
6716 6717 6718 6719 6720
			err = -EIO;
			goto err_eeprom;
		}
	}

6721 6722
	e1000_eeprom_checks(adapter);

6723
	/* copy the MAC address */
6724
	if (e1000e_read_mac_addr(&adapter->hw))
6725 6726
		dev_err(&pdev->dev,
			"NVM Read Error while reading MAC address\n");
6727 6728 6729

	memcpy(netdev->dev_addr, adapter->hw.mac.addr, netdev->addr_len);

6730
	if (!is_valid_ether_addr(netdev->dev_addr)) {
6731
		dev_err(&pdev->dev, "Invalid MAC Address: %pM\n",
6732
			netdev->dev_addr);
6733 6734 6735 6736 6737
		err = -EIO;
		goto err_eeprom;
	}

	init_timer(&adapter->watchdog_timer);
6738
	adapter->watchdog_timer.function = e1000_watchdog;
6739 6740 6741
	adapter->watchdog_timer.data = (unsigned long) adapter;

	init_timer(&adapter->phy_info_timer);
6742
	adapter->phy_info_timer.function = e1000_update_phy_info;
6743 6744 6745 6746
	adapter->phy_info_timer.data = (unsigned long) adapter;

	INIT_WORK(&adapter->reset_task, e1000_reset_task);
	INIT_WORK(&adapter->watchdog_task, e1000_watchdog_task);
6747 6748
	INIT_WORK(&adapter->downshift_task, e1000e_downshift_workaround);
	INIT_WORK(&adapter->update_phy_task, e1000e_update_phy_task);
6749
	INIT_WORK(&adapter->print_hang_task, e1000_print_hw_hang);
6750 6751 6752

	/* Initialize link parameters. User can change them with ethtool */
	adapter->hw.mac.autoneg = 1;
6753
	adapter->fc_autoneg = true;
6754 6755
	adapter->hw.fc.requested_mode = e1000_fc_default;
	adapter->hw.fc.current_mode = e1000_fc_default;
6756 6757 6758
	adapter->hw.phy.autoneg_advertised = 0x2f;

	/* ring size defaults */
6759 6760
	adapter->rx_ring->count = E1000_DEFAULT_RXD;
	adapter->tx_ring->count = E1000_DEFAULT_TXD;
6761

B
Bruce Allan 已提交
6762
	/* Initial Wake on LAN setting - If APM wake is enabled in
6763 6764 6765 6766 6767 6768
	 * the EEPROM, enable the ACPI Magic Packet filter
	 */
	if (adapter->flags & FLAG_APME_IN_WUC) {
		/* APME bit in EEPROM is mapped to WUC.APME */
		eeprom_data = er32(WUC);
		eeprom_apme_mask = E1000_WUC_APME;
6769 6770
		if ((hw->mac.type > e1000_ich10lan) &&
		    (eeprom_data & E1000_WUC_PHY_WAKE))
6771
			adapter->flags2 |= FLAG2_HAS_PHY_WAKEUP;
6772 6773 6774
	} else if (adapter->flags & FLAG_APME_IN_CTRL3) {
		if (adapter->flags & FLAG_APME_CHECK_PORT_B &&
		    (adapter->hw.bus.func == 1))
6775 6776
			e1000_read_nvm(&adapter->hw, NVM_INIT_CONTROL3_PORT_B,
				       1, &eeprom_data);
6777
		else
6778 6779
			e1000_read_nvm(&adapter->hw, NVM_INIT_CONTROL3_PORT_A,
				       1, &eeprom_data);
6780 6781 6782 6783 6784 6785
	}

	/* fetch WoL from EEPROM */
	if (eeprom_data & eeprom_apme_mask)
		adapter->eeprom_wol |= E1000_WUFC_MAG;

B
Bruce Allan 已提交
6786
	/* now that we have the eeprom settings, apply the special cases
6787 6788 6789 6790 6791 6792 6793 6794
	 * where the eeprom may be wrong or the board simply won't support
	 * wake on lan on a particular port
	 */
	if (!(adapter->flags & FLAG_HAS_WOL))
		adapter->eeprom_wol = 0;

	/* initialize the wol settings based on the eeprom settings */
	adapter->wol = adapter->eeprom_wol;
6795
	device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);
6796

6797 6798 6799
	/* save off EEPROM version number */
	e1000_read_nvm(&adapter->hw, 5, 1, &adapter->eeprom_vers);

6800 6801 6802
	/* reset the hardware with the new settings */
	e1000e_reset(adapter);

B
Bruce Allan 已提交
6803
	/* If the controller has AMT, do not set DRV_LOAD until the interface
6804
	 * is up.  For all other cases, let the f/w know that the h/w is now
6805 6806
	 * under the control of the driver.
	 */
J
Jesse Brandeburg 已提交
6807
	if (!(adapter->flags & FLAG_HAS_AMT))
6808
		e1000e_get_hw_control(adapter);
6809

6810
	strlcpy(netdev->name, "eth%d", sizeof(netdev->name));
6811 6812 6813 6814
	err = register_netdev(netdev);
	if (err)
		goto err_register;

6815 6816 6817
	/* carrier off reporting is important to ethtool even BEFORE open */
	netif_carrier_off(netdev);

6818 6819 6820
	/* init PTP hardware clock */
	e1000e_ptp_init(adapter);

6821 6822
	e1000_print_device_info(adapter);

6823 6824
	if (pci_dev_run_wake(pdev))
		pm_runtime_put_noidle(&pdev->dev);
6825

6826 6827 6828
	return 0;

err_register:
J
Jesse Brandeburg 已提交
6829
	if (!(adapter->flags & FLAG_HAS_AMT))
6830
		e1000e_release_hw_control(adapter);
6831
err_eeprom:
6832
	if (hw->phy.ops.check_reset_block && !hw->phy.ops.check_reset_block(hw))
6833
		e1000_phy_hw_reset(&adapter->hw);
J
Jesse Brandeburg 已提交
6834
err_hw_init:
6835 6836 6837
	kfree(adapter->tx_ring);
	kfree(adapter->rx_ring);
err_sw_init:
J
Jesse Brandeburg 已提交
6838 6839
	if (adapter->hw.flash_address)
		iounmap(adapter->hw.flash_address);
6840
	e1000e_reset_interrupt_capability(adapter);
J
Jesse Brandeburg 已提交
6841
err_flashmap:
6842 6843 6844 6845
	iounmap(adapter->hw.hw_addr);
err_ioremap:
	free_netdev(netdev);
err_alloc_etherdev:
6846 6847
	pci_release_selected_regions(pdev,
	                             pci_select_bars(pdev, IORESOURCE_MEM));
6848 6849 6850 6851 6852 6853 6854 6855 6856 6857 6858 6859 6860 6861 6862
err_pci_reg:
err_dma:
	pci_disable_device(pdev);
	return err;
}

/**
 * e1000_remove - Device Removal Routine
 * @pdev: PCI device information struct
 *
 * e1000_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.
 **/
6863
static void e1000_remove(struct pci_dev *pdev)
6864 6865 6866
{
	struct net_device *netdev = pci_get_drvdata(pdev);
	struct e1000_adapter *adapter = netdev_priv(netdev);
6867 6868
	bool down = test_bit(__E1000_DOWN, &adapter->state);

6869 6870
	e1000e_ptp_remove(adapter);

B
Bruce Allan 已提交
6871
	/* The timers may be rescheduled, so explicitly disable them
6872
	 * from being rescheduled.
6873
	 */
6874 6875
	if (!down)
		set_bit(__E1000_DOWN, &adapter->state);
6876 6877 6878
	del_timer_sync(&adapter->watchdog_timer);
	del_timer_sync(&adapter->phy_info_timer);

6879 6880 6881 6882 6883
	cancel_work_sync(&adapter->reset_task);
	cancel_work_sync(&adapter->watchdog_task);
	cancel_work_sync(&adapter->downshift_task);
	cancel_work_sync(&adapter->update_phy_task);
	cancel_work_sync(&adapter->print_hang_task);
6884

6885 6886 6887 6888 6889 6890 6891 6892
	if (adapter->flags & FLAG_HAS_HW_TIMESTAMP) {
		cancel_work_sync(&adapter->tx_hwtstamp_work);
		if (adapter->tx_hwtstamp_skb) {
			dev_kfree_skb_any(adapter->tx_hwtstamp_skb);
			adapter->tx_hwtstamp_skb = NULL;
		}
	}

6893 6894 6895
	if (!(netdev->flags & IFF_UP))
		e1000_power_down_phy(adapter);

6896 6897 6898
	/* Don't lie to e1000_close() down the road. */
	if (!down)
		clear_bit(__E1000_DOWN, &adapter->state);
6899 6900
	unregister_netdev(netdev);

6901 6902
	if (pci_dev_run_wake(pdev))
		pm_runtime_get_noresume(&pdev->dev);
6903

B
Bruce Allan 已提交
6904
	/* Release control of h/w to f/w.  If f/w is AMT enabled, this
6905 6906
	 * would have already happened in close and is redundant.
	 */
6907
	e1000e_release_hw_control(adapter);
6908

6909
	e1000e_reset_interrupt_capability(adapter);
6910 6911 6912 6913 6914 6915
	kfree(adapter->tx_ring);
	kfree(adapter->rx_ring);

	iounmap(adapter->hw.hw_addr);
	if (adapter->hw.flash_address)
		iounmap(adapter->hw.flash_address);
6916 6917
	pci_release_selected_regions(pdev,
	                             pci_select_bars(pdev, IORESOURCE_MEM));
6918 6919 6920

	free_netdev(netdev);

J
Jesse Brandeburg 已提交
6921
	/* AER disable */
6922
	pci_disable_pcie_error_reporting(pdev);
J
Jesse Brandeburg 已提交
6923

6924 6925 6926 6927
	pci_disable_device(pdev);
}

/* PCI Error Recovery (ERS) */
6928
static const struct pci_error_handlers e1000_err_handler = {
6929 6930 6931 6932 6933
	.error_detected = e1000_io_error_detected,
	.slot_reset = e1000_io_slot_reset,
	.resume = e1000_io_resume,
};

6934
static DEFINE_PCI_DEVICE_TABLE(e1000_pci_tbl) = {
6935 6936 6937 6938 6939 6940
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_COPPER), board_82571 },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_FIBER), board_82571 },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_QUAD_COPPER), board_82571 },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_QUAD_COPPER_LP), board_82571 },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_QUAD_FIBER), board_82571 },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_SERDES), board_82571 },
6941 6942 6943
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_SERDES_DUAL), board_82571 },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_SERDES_QUAD), board_82571 },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82571PT_QUAD_COPPER), board_82571 },
6944

6945 6946 6947 6948
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82572EI), board_82572 },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82572EI_COPPER), board_82572 },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82572EI_FIBER), board_82572 },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82572EI_SERDES), board_82572 },
6949

6950 6951 6952
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82573E), board_82573 },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82573E_IAMT), board_82573 },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82573L), board_82573 },
6953

6954
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82574L), board_82574 },
6955
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82574LA), board_82574 },
6956
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_82583V), board_82583 },
6957

6958 6959 6960 6961 6962 6963 6964 6965
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_80003ES2LAN_COPPER_DPT),
	  board_80003es2lan },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_80003ES2LAN_COPPER_SPT),
	  board_80003es2lan },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_80003ES2LAN_SERDES_DPT),
	  board_80003es2lan },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_80003ES2LAN_SERDES_SPT),
	  board_80003es2lan },
6966

6967 6968 6969 6970 6971 6972 6973
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH8_IFE), board_ich8lan },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH8_IFE_G), board_ich8lan },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH8_IFE_GT), board_ich8lan },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH8_IGP_AMT), board_ich8lan },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH8_IGP_C), board_ich8lan },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH8_IGP_M), board_ich8lan },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH8_IGP_M_AMT), board_ich8lan },
B
Bruce Allan 已提交
6974
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH8_82567V_3), board_ich8lan },
6975

6976 6977 6978 6979 6980
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IFE), board_ich9lan },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IFE_G), board_ich9lan },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IFE_GT), board_ich9lan },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IGP_AMT), board_ich9lan },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IGP_C), board_ich9lan },
6981
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_BM), board_ich9lan },
6982 6983 6984 6985 6986 6987 6988
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IGP_M), board_ich9lan },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IGP_M_AMT), board_ich9lan },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IGP_M_V), board_ich9lan },

	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH10_R_BM_LM), board_ich9lan },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH10_R_BM_LF), board_ich9lan },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH10_R_BM_V), board_ich9lan },
6989

6990 6991
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH10_D_BM_LM), board_ich10lan },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH10_D_BM_LF), board_ich10lan },
6992
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH10_D_BM_V), board_ich10lan },
6993

6994 6995 6996 6997 6998
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_M_HV_LM), board_pchlan },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_M_HV_LC), board_pchlan },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_D_HV_DM), board_pchlan },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_D_HV_DC), board_pchlan },

6999 7000 7001
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH2_LV_LM), board_pch2lan },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH2_LV_V), board_pch2lan },

B
Bruce Allan 已提交
7002 7003
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_LPT_I217_LM), board_pch_lpt },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_LPT_I217_V), board_pch_lpt },
B
Bruce Allan 已提交
7004 7005
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_LPTLP_I218_LM), board_pch_lpt },
	{ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_LPTLP_I218_V), board_pch_lpt },
B
Bruce Allan 已提交
7006

7007
	{ 0, 0, 0, 0, 0, 0, 0 }	/* terminate list */
7008 7009 7010
};
MODULE_DEVICE_TABLE(pci, e1000_pci_tbl);

R
Rafael J. Wysocki 已提交
7011
#ifdef CONFIG_PM
7012
static const struct dev_pm_ops e1000_pm_ops = {
7013 7014 7015
	SET_SYSTEM_SLEEP_PM_OPS(e1000_suspend, e1000_resume)
	SET_RUNTIME_PM_OPS(e1000_runtime_suspend,
				e1000_runtime_resume, e1000_idle)
7016
};
7017
#endif
7018

7019 7020 7021 7022 7023
/* PCI Device API Driver */
static struct pci_driver e1000_driver = {
	.name     = e1000e_driver_name,
	.id_table = e1000_pci_tbl,
	.probe    = e1000_probe,
7024
	.remove   = e1000_remove,
R
Rafael J. Wysocki 已提交
7025
#ifdef CONFIG_PM
7026 7027 7028
	.driver   = {
		.pm = &e1000_pm_ops,
	},
7029 7030 7031 7032 7033 7034 7035 7036 7037 7038 7039 7040 7041 7042
#endif
	.shutdown = e1000_shutdown,
	.err_handler = &e1000_err_handler
};

/**
 * e1000_init_module - Driver Registration Routine
 *
 * e1000_init_module is the first routine called when the driver is
 * loaded. All it does is register with the PCI subsystem.
 **/
static int __init e1000_init_module(void)
{
	int ret;
7043 7044
	pr_info("Intel(R) PRO/1000 Network Driver - %s\n",
		e1000e_driver_version);
B
Bruce Allan 已提交
7045
	pr_info("Copyright(c) 1999 - 2013 Intel Corporation.\n");
7046
	ret = pci_register_driver(&e1000_driver);
7047

7048 7049 7050 7051 7052 7053 7054 7055 7056 7057 7058 7059 7060 7061 7062 7063 7064 7065 7066 7067 7068 7069
	return ret;
}
module_init(e1000_init_module);

/**
 * e1000_exit_module - Driver Exit Cleanup Routine
 *
 * e1000_exit_module is called just before the driver is removed
 * from memory.
 **/
static void __exit e1000_exit_module(void)
{
	pci_unregister_driver(&e1000_driver);
}
module_exit(e1000_exit_module);


MODULE_AUTHOR("Intel Corporation, <linux.nics@intel.com>");
MODULE_DESCRIPTION("Intel(R) PRO/1000 Network Driver");
MODULE_LICENSE("GPL");
MODULE_VERSION(DRV_VERSION);

7070
/* netdev.c */