1

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

     2

     3

  Intel PRO/1000 Linux driver

     4

  Copyright(c) 1999 - 2010 Intel Corporation.

     5

     6

  This program is free software; you can redistribute it and/or modify it

     7

  under the terms and conditions of the GNU General Public License,

     8

  version 2, as published by the Free Software Foundation.

     9

    10

  This program is distributed in the hope it will be useful, but WITHOUT

    11

  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    12

  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for

    13

  more details.

    14

    15

  You should have received a copy of the GNU General Public License along with

    16

  this program; if not, write to the Free Software Foundation, Inc.,

    17

  51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.

    18

    19

  The full GNU General Public License is included in this distribution in

    20

  the file called "COPYING".

    21

    22

  Contact Information:

    23

  Linux NICS <linux.nics@intel.com>

    24

  e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>

    25

  Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497

    26

    27

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

    28

    29

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

    30

    31

#include <linux/module.h>

    32

#include <linux/types.h>

    33

#include <linux/init.h>

    34

#include <linux/pci.h>

    35

#include <linux/vmalloc.h>

    36

#include <linux/pagemap.h>

    37

#include <linux/delay.h>

    38

#include <linux/netdevice.h>

    39

#include <linux/tcp.h>

    40

#include <linux/ipv6.h>

    41

#include <linux/slab.h>

    42

#include <net/checksum.h>

    43

#include <net/ip6_checksum.h>

    44

#include <linux/mii.h>

    45

#include <linux/ethtool.h>

    46

#include <linux/if_vlan.h>

    47

#include <linux/cpu.h>

    48

#include <linux/smp.h>

    49

#include <linux/pm_qos_params.h>

    50

#include <linux/pm_runtime.h>

    51

#include <linux/aer.h>

    52

    53

#include "e1000.h"

    54

    55

#define DRV_EXTRAVERSION "-k2"

    56

    57

#define DRV_VERSION "1.2.7" DRV_EXTRAVERSION

    58

char e1000e_driver_name[] = "e1000e";

    59

const char e1000e_driver_version[] = DRV_VERSION;

    60

    61

static const struct e1000_info *e1000_info_tbl[] = {

    62

	[board_82571]		= &e1000_82571_info,

    63

	[board_82572]		= &e1000_82572_info,

    64

	[board_82573]		= &e1000_82573_info,

    65

	[board_82574]		= &e1000_82574_info,

    66

	[board_82583]		= &e1000_82583_info,

    67

	[board_80003es2lan]	= &e1000_es2_info,

    68

	[board_ich8lan]		= &e1000_ich8_info,

    69

	[board_ich9lan]		= &e1000_ich9_info,

    70

	[board_ich10lan]	= &e1000_ich10_info,

    71

	[board_pchlan]		= &e1000_pch_info,

    72

	[board_pch2lan]		= &e1000_pch2_info,

    73

};

    74

    75

struct e1000_reg_info {

    76

	u32 ofs;

    77

	char *name;

    78

};

    79

    80

#define E1000_RDFH	0x02410 /* Rx Data FIFO Head - RW */

    81

#define E1000_RDFT	0x02418 /* Rx Data FIFO Tail - RW */

    82

#define E1000_RDFHS	0x02420 /* Rx Data FIFO Head Saved - RW */

    83

#define E1000_RDFTS	0x02428 /* Rx Data FIFO Tail Saved - RW */

    84

#define E1000_RDFPC	0x02430 /* Rx Data FIFO Packet Count - RW */

    85

    86

#define E1000_TDFH	0x03410 /* Tx Data FIFO Head - RW */

    87

#define E1000_TDFT	0x03418 /* Tx Data FIFO Tail - RW */

    88

#define E1000_TDFHS	0x03420 /* Tx Data FIFO Head Saved - RW */

    89

#define E1000_TDFTS	0x03428 /* Tx Data FIFO Tail Saved - RW */

    90

#define E1000_TDFPC	0x03430 /* Tx Data FIFO Packet Count - RW */

    91

    92

static const struct e1000_reg_info e1000_reg_info_tbl[] = {

    93

    94

	/* General Registers */

    95

	{E1000_CTRL, "CTRL"},

    96

	{E1000_STATUS, "STATUS"},

    97

	{E1000_CTRL_EXT, "CTRL_EXT"},

    98

    99

	/* Interrupt Registers */

   100

	{E1000_ICR, "ICR"},

   101

   102

	/* RX Registers */

   103

	{E1000_RCTL, "RCTL"},

   104

	{E1000_RDLEN, "RDLEN"},

   105

	{E1000_RDH, "RDH"},

   106

	{E1000_RDT, "RDT"},

   107

	{E1000_RDTR, "RDTR"},

   108

	{E1000_RXDCTL(0), "RXDCTL"},

   109

	{E1000_ERT, "ERT"},

   110

	{E1000_RDBAL, "RDBAL"},

   111

	{E1000_RDBAH, "RDBAH"},

   112

	{E1000_RDFH, "RDFH"},

   113

	{E1000_RDFT, "RDFT"},

   114

	{E1000_RDFHS, "RDFHS"},

   115

	{E1000_RDFTS, "RDFTS"},

   116

	{E1000_RDFPC, "RDFPC"},

   117

   118

	/* TX Registers */

   119

	{E1000_TCTL, "TCTL"},

   120

	{E1000_TDBAL, "TDBAL"},

   121

	{E1000_TDBAH, "TDBAH"},

   122

	{E1000_TDLEN, "TDLEN"},

   123

	{E1000_TDH, "TDH"},

   124

	{E1000_TDT, "TDT"},

   125

	{E1000_TIDV, "TIDV"},

   126

	{E1000_TXDCTL(0), "TXDCTL"},

   127

	{E1000_TADV, "TADV"},

   128

	{E1000_TARC(0), "TARC"},

   129

	{E1000_TDFH, "TDFH"},

   130

	{E1000_TDFT, "TDFT"},

   131

	{E1000_TDFHS, "TDFHS"},

   132

	{E1000_TDFTS, "TDFTS"},

   133

	{E1000_TDFPC, "TDFPC"},

   134

   135

	/* List Terminator */

   136

	{}

   137

};

   138

   139

/*

   140

 * e1000_regdump - register printout routine

   141

 */

   142

static void e1000_regdump(struct e1000_hw *hw, struct e1000_reg_info *reginfo)

   143

{

   144

	int n = 0;

   145

	char rname[16];

   146

	u32 regs[8];

   147

   148

	switch (reginfo->ofs) {

   149

	case E1000_RXDCTL(0):

   150

		for (n = 0; n < 2; n++)

   151

			regs[n] = __er32(hw, E1000_RXDCTL(n));

   152

		break;

   153

	case E1000_TXDCTL(0):

   154

		for (n = 0; n < 2; n++)

   155

			regs[n] = __er32(hw, E1000_TXDCTL(n));

   156

		break;

   157

	case E1000_TARC(0):

   158

		for (n = 0; n < 2; n++)

   159

			regs[n] = __er32(hw, E1000_TARC(n));

   160

		break;

   161

	default:

   162

		printk(KERN_INFO "%-15s %08x\n",

   163

			reginfo->name, __er32(hw, reginfo->ofs));

   164

		return;

   165

	}

   166

   167

	snprintf(rname, 16, "%s%s", reginfo->name, "[0-1]");

   168

	printk(KERN_INFO "%-15s ", rname);

   169

	for (n = 0; n < 2; n++)

   170

		printk(KERN_CONT "%08x ", regs[n]);

   171

	printk(KERN_CONT "\n");

   172

}

   173

   174

   175

/*

   176

 * e1000e_dump - Print registers, tx-ring and rx-ring

   177

 */

   178

static void e1000e_dump(struct e1000_adapter *adapter)

   179

{

   180

	struct net_device *netdev = adapter->netdev;

   181

	struct e1000_hw *hw = &adapter->hw;

   182

	struct e1000_reg_info *reginfo;

   183

	struct e1000_ring *tx_ring = adapter->tx_ring;

   184

	struct e1000_tx_desc *tx_desc;

   185

	struct my_u0 { u64 a; u64 b; } *u0;

   186

	struct e1000_buffer *buffer_info;

   187

	struct e1000_ring *rx_ring = adapter->rx_ring;

   188

	union e1000_rx_desc_packet_split *rx_desc_ps;

   189

	struct e1000_rx_desc *rx_desc;

   190

	struct my_u1 { u64 a; u64 b; u64 c; u64 d; } *u1;

   191

	u32 staterr;

   192

	int i = 0;

   193

   194

	if (!netif_msg_hw(adapter))

   195

		return;

   196

   197

	/* Print netdevice Info */

   198

	if (netdev) {

   199

		dev_info(&adapter->pdev->dev, "Net device Info\n");

   200

		printk(KERN_INFO "Device Name     state            "

   201

			"trans_start      last_rx\n");

   202

		printk(KERN_INFO "%-15s %016lX %016lX %016lX\n",

   203

			netdev->name,

   204

			netdev->state,

   205

			netdev->trans_start,

   206

			netdev->last_rx);

   207

	}

   208

   209

	/* Print Registers */

   210

	dev_info(&adapter->pdev->dev, "Register Dump\n");

   211

	printk(KERN_INFO " Register Name   Value\n");

   212

	for (reginfo = (struct e1000_reg_info *)e1000_reg_info_tbl;

   213

	     reginfo->name; reginfo++) {

   214

		e1000_regdump(hw, reginfo);

   215

	}

   216

   217

	/* Print TX Ring Summary */

   218

	if (!netdev || !netif_running(netdev))

   219

		goto exit;

   220

   221

	dev_info(&adapter->pdev->dev, "TX Rings Summary\n");

   222

	printk(KERN_INFO "Queue [NTU] [NTC] [bi(ntc)->dma  ]"

   223

		" leng ntw timestamp\n");

   224

	buffer_info = &tx_ring->buffer_info[tx_ring->next_to_clean];

   225

	printk(KERN_INFO " %5d %5X %5X %016llX %04X %3X %016llX\n",

   226

		0, tx_ring->next_to_use, tx_ring->next_to_clean,

   227

		(unsigned long long)buffer_info->dma,

   228

		buffer_info->length,

   229

		buffer_info->next_to_watch,

   230

		(unsigned long long)buffer_info->time_stamp);

   231

   232

	/* Print TX Rings */

   233

	if (!netif_msg_tx_done(adapter))

   234

		goto rx_ring_summary;

   235

   236

	dev_info(&adapter->pdev->dev, "TX Rings Dump\n");

   237

   238

	/* Transmit Descriptor Formats - DEXT[29] is 0 (Legacy) or 1 (Extended)

   239

	 *

   240

	 * Legacy Transmit Descriptor

   241

	 *   +--------------------------------------------------------------+

   242

	 * 0 |         Buffer Address [63:0] (Reserved on Write Back)       |

   243

	 *   +--------------------------------------------------------------+

   244

	 * 8 | Special  |    CSS     | Status |  CMD    |  CSO   |  Length  |

   245

	 *   +--------------------------------------------------------------+

   246

	 *   63       48 47        36 35    32 31     24 23    16 15        0

   247

	 *

   248

	 * Extended Context Descriptor (DTYP=0x0) for TSO or checksum offload

   249

	 *   63      48 47    40 39       32 31             16 15    8 7      0

   250

	 *   +----------------------------------------------------------------+

   251

	 * 0 |  TUCSE  | TUCS0  |   TUCSS   |     IPCSE       | IPCS0 | IPCSS |

   252

	 *   +----------------------------------------------------------------+

   253

	 * 8 |   MSS   | HDRLEN | RSV | STA | TUCMD | DTYP |      PAYLEN      |

   254

	 *   +----------------------------------------------------------------+

   255

	 *   63      48 47    40 39 36 35 32 31   24 23  20 19                0

   256

	 *

   257

	 * Extended Data Descriptor (DTYP=0x1)

   258

	 *   +----------------------------------------------------------------+

   259

	 * 0 |                     Buffer Address [63:0]                      |

   260

	 *   +----------------------------------------------------------------+

   261

	 * 8 | VLAN tag |  POPTS  | Rsvd | Status | Command | DTYP |  DTALEN  |

   262

	 *   +----------------------------------------------------------------+

   263

	 *   63       48 47     40 39  36 35    32 31     24 23  20 19        0

   264

	 */

   265

	printk(KERN_INFO "Tl[desc]     [address 63:0  ] [SpeCssSCmCsLen]"

   266

		" [bi->dma       ] leng  ntw timestamp        bi->skb "

   267

		"<-- Legacy format\n");

   268

	printk(KERN_INFO "Tc[desc]     [Ce CoCsIpceCoS] [MssHlRSCm0Plen]"

   269

		" [bi->dma       ] leng  ntw timestamp        bi->skb "

   270

		"<-- Ext Context format\n");

   271

	printk(KERN_INFO "Td[desc]     [address 63:0  ] [VlaPoRSCm1Dlen]"

   272

		" [bi->dma       ] leng  ntw timestamp        bi->skb "

   273

		"<-- Ext Data format\n");

   274

	for (i = 0; tx_ring->desc && (i < tx_ring->count); i++) {

   275

		tx_desc = E1000_TX_DESC(*tx_ring, i);

   276

		buffer_info = &tx_ring->buffer_info[i];

   277

		u0 = (struct my_u0 *)tx_desc;

   278

		printk(KERN_INFO "T%c[0x%03X]    %016llX %016llX %016llX "

   279

			"%04X  %3X %016llX %p",

   280

		       (!(le64_to_cpu(u0->b) & (1<<29)) ? 'l' :

   281

			((le64_to_cpu(u0->b) & (1<<20)) ? 'd' : 'c')), i,

   282

		       (unsigned long long)le64_to_cpu(u0->a),

   283

		       (unsigned long long)le64_to_cpu(u0->b),

   284

		       (unsigned long long)buffer_info->dma,

   285

		       buffer_info->length, buffer_info->next_to_watch,

   286

		       (unsigned long long)buffer_info->time_stamp,

   287

		       buffer_info->skb);

   288

		if (i == tx_ring->next_to_use && i == tx_ring->next_to_clean)

   289

			printk(KERN_CONT " NTC/U\n");

   290

		else if (i == tx_ring->next_to_use)

   291

			printk(KERN_CONT " NTU\n");

   292

		else if (i == tx_ring->next_to_clean)

   293

			printk(KERN_CONT " NTC\n");

   294

		else

   295

			printk(KERN_CONT "\n");

   296

   297

		if (netif_msg_pktdata(adapter) && buffer_info->dma != 0)

   298

			print_hex_dump(KERN_INFO, "", DUMP_PREFIX_ADDRESS,

   299

					16, 1, phys_to_virt(buffer_info->dma),

   300

					buffer_info->length, true);

   301

	}

   302

   303

	/* Print RX Rings Summary */

   304

rx_ring_summary:

   305

	dev_info(&adapter->pdev->dev, "RX Rings Summary\n");

   306

	printk(KERN_INFO "Queue [NTU] [NTC]\n");

   307

	printk(KERN_INFO " %5d %5X %5X\n", 0,

   308

		rx_ring->next_to_use, rx_ring->next_to_clean);

   309

   310

	/* Print RX Rings */

   311

	if (!netif_msg_rx_status(adapter))

   312

		goto exit;

   313

   314

	dev_info(&adapter->pdev->dev, "RX Rings Dump\n");

   315

	switch (adapter->rx_ps_pages) {

   316

	case 1:

   317

	case 2:

   318

	case 3:

   319

		/* [Extended] Packet Split Receive Descriptor Format

   320

		 *

   321

		 *    +-----------------------------------------------------+

   322

		 *  0 |                Buffer Address 0 [63:0]              |

   323

		 *    +-----------------------------------------------------+

   324

		 *  8 |                Buffer Address 1 [63:0]              |

   325

		 *    +-----------------------------------------------------+

   326

		 * 16 |                Buffer Address 2 [63:0]              |

   327

		 *    +-----------------------------------------------------+

   328

		 * 24 |                Buffer Address 3 [63:0]              |

   329

		 *    +-----------------------------------------------------+

   330

		 */

   331

		printk(KERN_INFO "R  [desc]      [buffer 0 63:0 ] "

   332

			"[buffer 1 63:0 ] "

   333

		       "[buffer 2 63:0 ] [buffer 3 63:0 ] [bi->dma       ] "

   334

		       "[bi->skb] <-- Ext Pkt Split format\n");

   335

		/* [Extended] Receive Descriptor (Write-Back) Format

   336

		 *

   337

		 *   63       48 47    32 31     13 12    8 7    4 3        0

   338

		 *   +------------------------------------------------------+

   339

		 * 0 | Packet   | IP     |  Rsvd   | MRQ   | Rsvd | MRQ RSS |

   340

		 *   | Checksum | Ident  |         | Queue |      |  Type   |

   341

		 *   +------------------------------------------------------+

   342

		 * 8 | VLAN Tag | Length | Extended Error | Extended Status |

   343

		 *   +------------------------------------------------------+

   344

		 *   63       48 47    32 31            20 19               0

   345

		 */

   346

		printk(KERN_INFO "RWB[desc]      [ck ipid mrqhsh] "

   347

			"[vl   l0 ee  es] "

   348

		       "[ l3  l2  l1 hs] [reserved      ] ---------------- "

   349

		       "[bi->skb] <-- Ext Rx Write-Back format\n");

   350

		for (i = 0; i < rx_ring->count; i++) {

   351

			buffer_info = &rx_ring->buffer_info[i];

   352

			rx_desc_ps = E1000_RX_DESC_PS(*rx_ring, i);

   353

			u1 = (struct my_u1 *)rx_desc_ps;

   354

			staterr =

   355

				le32_to_cpu(rx_desc_ps->wb.middle.status_error);

   356

			if (staterr & E1000_RXD_STAT_DD) {

   357

				/* Descriptor Done */

   358

				printk(KERN_INFO "RWB[0x%03X]     %016llX "

   359

					"%016llX %016llX %016llX "

   360

					"---------------- %p", i,

   361

					(unsigned long long)le64_to_cpu(u1->a),

   362

					(unsigned long long)le64_to_cpu(u1->b),

   363

					(unsigned long long)le64_to_cpu(u1->c),

   364

					(unsigned long long)le64_to_cpu(u1->d),

   365

					buffer_info->skb);

   366

			} else {

   367

				printk(KERN_INFO "R  [0x%03X]     %016llX "

   368

					"%016llX %016llX %016llX %016llX %p", i,

   369

					(unsigned long long)le64_to_cpu(u1->a),

   370

					(unsigned long long)le64_to_cpu(u1->b),

   371

					(unsigned long long)le64_to_cpu(u1->c),

   372

					(unsigned long long)le64_to_cpu(u1->d),

   373

					(unsigned long long)buffer_info->dma,

   374

					buffer_info->skb);

   375

   376

				if (netif_msg_pktdata(adapter))

   377

					print_hex_dump(KERN_INFO, "",

   378

						DUMP_PREFIX_ADDRESS, 16, 1,

   379

						phys_to_virt(buffer_info->dma),

   380

						adapter->rx_ps_bsize0, true);

   381

			}

   382

   383

			if (i == rx_ring->next_to_use)

   384

				printk(KERN_CONT " NTU\n");

   385

			else if (i == rx_ring->next_to_clean)

   386

				printk(KERN_CONT " NTC\n");

   387

			else

   388

				printk(KERN_CONT "\n");

   389

		}

   390

		break;

   391

	default:

   392

	case 0:

   393

		/* Legacy Receive Descriptor Format

   394

		 *

   395

		 * +-----------------------------------------------------+

   396

		 * |                Buffer Address [63:0]                |

   397

		 * +-----------------------------------------------------+

   398

		 * | VLAN Tag | Errors | Status 0 | Packet csum | Length |

   399

		 * +-----------------------------------------------------+

   400

		 * 63       48 47    40 39      32 31         16 15      0

   401

		 */

   402

		printk(KERN_INFO "Rl[desc]     [address 63:0  ] "

   403

			"[vl er S cks ln] [bi->dma       ] [bi->skb] "

   404

			"<-- Legacy format\n");

   405

		for (i = 0; rx_ring->desc && (i < rx_ring->count); i++) {

   406

			rx_desc = E1000_RX_DESC(*rx_ring, i);

   407

			buffer_info = &rx_ring->buffer_info[i];

   408

			u0 = (struct my_u0 *)rx_desc;

   409

			printk(KERN_INFO "Rl[0x%03X]    %016llX %016llX "

   410

				"%016llX %p", i,

   411

				(unsigned long long)le64_to_cpu(u0->a),

   412

				(unsigned long long)le64_to_cpu(u0->b),

   413

				(unsigned long long)buffer_info->dma,

   414

				buffer_info->skb);

   415

			if (i == rx_ring->next_to_use)

   416

				printk(KERN_CONT " NTU\n");

   417

			else if (i == rx_ring->next_to_clean)

   418

				printk(KERN_CONT " NTC\n");

   419

			else

   420

				printk(KERN_CONT "\n");

   421

   422

			if (netif_msg_pktdata(adapter))

   423

				print_hex_dump(KERN_INFO, "",

   424

					DUMP_PREFIX_ADDRESS,

   425

					16, 1, phys_to_virt(buffer_info->dma),

   426

					adapter->rx_buffer_len, true);

   427

		}

   428

	}

   429

   430

exit:

   431

	return;

   432

}

   433

   434

/**

   435

 * e1000_desc_unused - calculate if we have unused descriptors

   436

 **/

   437

static int e1000_desc_unused(struct e1000_ring *ring)

   438

{

   439

	if (ring->next_to_clean > ring->next_to_use)

   440

		return ring->next_to_clean - ring->next_to_use - 1;

   441

   442

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

   443

}

   444

   445

/**

   446

 * e1000_receive_skb - helper function to handle Rx indications

   447

 * @adapter: board private structure

   448

 * @status: descriptor status field as written by hardware

   449

 * @vlan: descriptor vlan field as written by hardware (no le/be conversion)

   450

 * @skb: pointer to sk_buff to be indicated to stack

   451

 **/

   452

static void e1000_receive_skb(struct e1000_adapter *adapter,

   453

			      struct net_device *netdev,

   454

			      struct sk_buff *skb,

   455

			      u8 status, __le16 vlan)

   456

{

   457

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

   458

   459

	if (adapter->vlgrp && (status & E1000_RXD_STAT_VP))

   460

		vlan_gro_receive(&adapter->napi, adapter->vlgrp,

   461

				 le16_to_cpu(vlan), skb);

   462

	else

   463

		napi_gro_receive(&adapter->napi, skb);

   464

}

   465

   466

/**

   467

 * e1000_rx_checksum - Receive Checksum Offload for 82543

   468

 * @adapter:     board private structure

   469

 * @status_err:  receive descriptor status and error fields

   470

 * @csum:	receive descriptor csum field

   471

 * @sk_buff:     socket buffer with received data

   472

 **/

   473

static void e1000_rx_checksum(struct e1000_adapter *adapter, u32 status_err,

   474

			      u32 csum, struct sk_buff *skb)

   475

{

   476

	u16 status = (u16)status_err;

   477

	u8 errors = (u8)(status_err >> 24);

   478

   479

	skb_checksum_none_assert(skb);

   480

   481

	/* Ignore Checksum bit is set */

   482

	if (status & E1000_RXD_STAT_IXSM)

   483

		return;

   484

	/* TCP/UDP checksum error bit is set */

   485

	if (errors & E1000_RXD_ERR_TCPE) {

   486

		/* let the stack verify checksum errors */

   487

		adapter->hw_csum_err++;

   488

		return;

   489

	}

   490

   491

	/* TCP/UDP Checksum has not been calculated */

   492

	if (!(status & (E1000_RXD_STAT_TCPCS | E1000_RXD_STAT_UDPCS)))

   493

		return;

   494

   495

	/* It must be a TCP or UDP packet with a valid checksum */

   496

	if (status & E1000_RXD_STAT_TCPCS) {

   497

		/* TCP checksum is good */

   498

		skb->ip_summed = CHECKSUM_UNNECESSARY;

   499

	} else {

   500

		/*

   501

		 * IP fragment with UDP payload

   502

		 * Hardware complements the payload checksum, so we undo it

   503

		 * and then put the value in host order for further stack use.

   504

		 */

   505

		__sum16 sum = (__force __sum16)htons(csum);

   506

		skb->csum = csum_unfold(~sum);

   507

		skb->ip_summed = CHECKSUM_COMPLETE;

   508

	}

   509

	adapter->hw_csum_good++;

   510

}

   511

   512

/**

   513

 * e1000_alloc_rx_buffers - Replace used receive buffers; legacy & extended

   514

 * @adapter: address of board private structure

   515

 **/

   516

static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,

   517

				   int cleaned_count)

   518

{

   519

	struct net_device *netdev = adapter->netdev;

   520

	struct pci_dev *pdev = adapter->pdev;

   521

	struct e1000_ring *rx_ring = adapter->rx_ring;

   522

	struct e1000_rx_desc *rx_desc;

   523

	struct e1000_buffer *buffer_info;

   524

	struct sk_buff *skb;

   525

	unsigned int i;

   526

	unsigned int bufsz = adapter->rx_buffer_len;

   527

   528

	i = rx_ring->next_to_use;

   529

	buffer_info = &rx_ring->buffer_info[i];