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

  vim: noexpandtab

    28

    29

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

    30

    31

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

    32

    33

#include <linux/module.h>

    34

#include <linux/types.h>

    35

#include <linux/init.h>

    36

#include <linux/pci.h>

    37

#include <linux/vmalloc.h>

    38

#include <linux/pagemap.h>

    39

#include <linux/delay.h>

    40

#include <linux/netdevice.h>

    41

#include <linux/tcp.h>

    42

#include <linux/ipv6.h>

    43

#include <linux/slab.h>

    44

#include <net/checksum.h>

    45

#include <net/ip6_checksum.h>

    46

#include <linux/mii.h>

    47

#include <linux/ethtool.h>

    48

#include <linux/if_vlan.h>

    49

#include <linux/cpu.h>

    50

#include <linux/smp.h>

    51

#include <linux/pm_qos_params.h>

    52

#include <linux/pm_runtime.h>

    53

#include <linux/aer.h>

    54

    55

#include "e1000-2.6.37-ethercat.h"

    56

    57

#define DRV_EXTRAVERSION "-k2-EtherCAT"

    58

    59

#define DRV_VERSION "1.2.7" DRV_EXTRAVERSION

    60

char e1000e_driver_name[] = "ec_e1000e";

    61

const char e1000e_driver_version[] = DRV_VERSION;

    62

    63

static const struct e1000_info *e1000_info_tbl[] = {

    64

	[board_82571]		= &e1000_82571_info,

    65

	[board_82572]		= &e1000_82572_info,

    66

	[board_82573]		= &e1000_82573_info,

    67

	[board_82574]		= &e1000_82574_info,

    68

	[board_82583]		= &e1000_82583_info,

    69

	[board_80003es2lan]	= &e1000_es2_info,

    70

	[board_ich8lan]		= &e1000_ich8_info,

    71

	[board_ich9lan]		= &e1000_ich9_info,

    72

	[board_ich10lan]	= &e1000_ich10_info,

    73

	[board_pchlan]		= &e1000_pch_info,

    74

	[board_pch2lan]		= &e1000_pch2_info,

    75

};

    76

    77

struct e1000_reg_info {

    78

	u32 ofs;

    79

	char *name;

    80

};

    81

    82

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

    83

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

    84

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

    85

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

    86

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

    87

    88

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

    89

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

    90

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

    91

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

    92

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

    93

    94

static const struct e1000_reg_info e1000_reg_info_tbl[] = {

    95

    96

	/* General Registers */

    97

	{E1000_CTRL, "CTRL"},

    98

	{E1000_STATUS, "STATUS"},

    99

	{E1000_CTRL_EXT, "CTRL_EXT"},

   100

   101

	/* Interrupt Registers */

   102

	{E1000_ICR, "ICR"},

   103

   104

	/* RX Registers */

   105

	{E1000_RCTL, "RCTL"},

   106

	{E1000_RDLEN, "RDLEN"},

   107

	{E1000_RDH, "RDH"},

   108

	{E1000_RDT, "RDT"},

   109

	{E1000_RDTR, "RDTR"},

   110

	{E1000_RXDCTL(0), "RXDCTL"},

   111

	{E1000_ERT, "ERT"},

   112

	{E1000_RDBAL, "RDBAL"},

   113

	{E1000_RDBAH, "RDBAH"},

   114

	{E1000_RDFH, "RDFH"},

   115

	{E1000_RDFT, "RDFT"},

   116

	{E1000_RDFHS, "RDFHS"},

   117

	{E1000_RDFTS, "RDFTS"},

   118

	{E1000_RDFPC, "RDFPC"},

   119

   120

	/* TX Registers */

   121

	{E1000_TCTL, "TCTL"},

   122

	{E1000_TDBAL, "TDBAL"},

   123

	{E1000_TDBAH, "TDBAH"},

   124

	{E1000_TDLEN, "TDLEN"},

   125

	{E1000_TDH, "TDH"},

   126

	{E1000_TDT, "TDT"},

   127

	{E1000_TIDV, "TIDV"},

   128

	{E1000_TXDCTL(0), "TXDCTL"},

   129

	{E1000_TADV, "TADV"},

   130

	{E1000_TARC(0), "TARC"},

   131

	{E1000_TDFH, "TDFH"},

   132

	{E1000_TDFT, "TDFT"},

   133

	{E1000_TDFHS, "TDFHS"},

   134

	{E1000_TDFTS, "TDFTS"},

   135

	{E1000_TDFPC, "TDFPC"},

   136

   137

	/* List Terminator */

   138

	{}

   139

};

   140

   141

/*

   142

 * e1000_regdump - register printout routine

   143

 */

   144

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

   145

{

   146

	int n = 0;

   147

	char rname[16];

   148

	u32 regs[8];

   149

   150

	switch (reginfo->ofs) {

   151

	case E1000_RXDCTL(0):

   152

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

   153

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

   154

		break;

   155

	case E1000_TXDCTL(0):

   156

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

   157

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

   158

		break;

   159

	case E1000_TARC(0):

   160

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

   161

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

   162

		break;

   163

	default:

   164

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

   165

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

   166

		return;

   167

	}

   168

   169

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

   170

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

   171

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

   172

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

   173

	printk(KERN_CONT "\n");

   174

}

   175

   176

   177

/*

   178

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

   179

 */

   180

static void e1000e_dump(struct e1000_adapter *adapter)

   181

{

   182

	struct net_device *netdev = adapter->netdev;

   183

	struct e1000_hw *hw = &adapter->hw;

   184

	struct e1000_reg_info *reginfo;

   185

	struct e1000_ring *tx_ring = adapter->tx_ring;

   186

	struct e1000_tx_desc *tx_desc;

   187

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

   188

	struct e1000_buffer *buffer_info;

   189

	struct e1000_ring *rx_ring = adapter->rx_ring;

   190

	union e1000_rx_desc_packet_split *rx_desc_ps;

   191

	struct e1000_rx_desc *rx_desc;

   192

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

   193

	u32 staterr;

   194

	int i = 0;

   195

   196

	if (!netif_msg_hw(adapter))

   197

		return;

   198

   199

	/* Print netdevice Info */

   200

	if (netdev) {

   201

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

   202

		printk(KERN_INFO "Device Name     state            "

   203

			"trans_start      last_rx\n");

   204

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

   205

			netdev->name,

   206

			netdev->state,

   207

			netdev->trans_start,

   208

			netdev->last_rx);

   209

	}

   210

   211

	/* Print Registers */

   212

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

   213

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

   214

	for (reginfo = (struct e1000_reg_info *)e1000_reg_info_tbl;

   215

	     reginfo->name; reginfo++) {

   216

		e1000_regdump(hw, reginfo);

   217

	}

   218

   219

	/* Print TX Ring Summary */

   220

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

   221

		goto exit;

   222

   223

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

   224

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

   225

		" leng ntw timestamp\n");

   226

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

   227

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

   228

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

   229

		(unsigned long long)buffer_info->dma,

   230

		buffer_info->length,

   231

		buffer_info->next_to_watch,

   232

		(unsigned long long)buffer_info->time_stamp);

   233

   234

	/* Print TX Rings */

   235

	if (!netif_msg_tx_done(adapter))

   236

		goto rx_ring_summary;

   237

   238

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

   239

   240

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

   241

	 *

   242

	 * Legacy Transmit Descriptor

   243

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

   244

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

   245

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

   246

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

   247

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

   248

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

   249

	 *

   250

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

   251

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

   252

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

   253

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

   254

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

   255

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

   256

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

   257

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

   258

	 *

   259

	 * Extended Data Descriptor (DTYP=0x1)

   260

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

   261

	 * 0 |                     Buffer Address [63:0]                      |

   262

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

   263

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

   264

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

   265

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

   266

	 */

   267

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

   268

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

   269

		"<-- Legacy format\n");

   270

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

   271

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

   272

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

   273

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

   274

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

   275

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

   276

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

   277

		tx_desc = E1000_TX_DESC(*tx_ring, i);

   278

		buffer_info = &tx_ring->buffer_info[i];

   279

		u0 = (struct my_u0 *)tx_desc;

   280

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

   281

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

   282

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

   283

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

   284

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

   285

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

   286

		       (unsigned long long)buffer_info->dma,

   287

		       buffer_info->length, buffer_info->next_to_watch,

   288

		       (unsigned long long)buffer_info->time_stamp,

   289

		       buffer_info->skb);

   290

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

   291

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

   292

		else if (i == tx_ring->next_to_use)

   293

			printk(KERN_CONT " NTU\n");

   294

		else if (i == tx_ring->next_to_clean)

   295

			printk(KERN_CONT " NTC\n");

   296

		else

   297

			printk(KERN_CONT "\n");

   298

   299

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

   300

			print_hex_dump(KERN_INFO, "", DUMP_PREFIX_ADDRESS,

   301

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

   302

					buffer_info->length, true);

   303

	}

   304

   305

	/* Print RX Rings Summary */

   306

rx_ring_summary:

   307

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

   308

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

   309

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

   310

		rx_ring->next_to_use, rx_ring->next_to_clean);

   311

   312

	/* Print RX Rings */

   313

	if (!netif_msg_rx_status(adapter))

   314

		goto exit;

   315

   316

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

   317

	switch (adapter->rx_ps_pages) {

   318

	case 1:

   319

	case 2:

   320

	case 3:

   321

		/* [Extended] Packet Split Receive Descriptor Format

   322

		 *

   323

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

   324

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

   325

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

   326

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

   327

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

   328

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

   329

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

   330

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

   331

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

   332

		 */

   333

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

   334

			"[buffer 1 63:0 ] "

   335

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

   336

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

   337

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

   338

		 *

   339

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

   340

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

   341

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

   342

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

   343

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

   344

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

   345

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

   346

		 *   63       48 47    32 31            20 19               0

   347

		 */

   348

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

   349

			"[vl   l0 ee  es] "

   350

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

   351

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

   352

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

   353

			buffer_info = &rx_ring->buffer_info[i];

   354

			rx_desc_ps = E1000_RX_DESC_PS(*rx_ring, i);

   355

			u1 = (struct my_u1 *)rx_desc_ps;

   356

			staterr =

   357

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

   358

			if (staterr & E1000_RXD_STAT_DD) {

   359

				/* Descriptor Done */

   360

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

   361

					"%016llX %016llX %016llX "

   362

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

   363

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

   364

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

   365

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

   366

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

   367

					buffer_info->skb);

   368

			} else {

   369

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

   370

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

   371

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

   372

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

   373

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

   374

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

   375

					(unsigned long long)buffer_info->dma,

   376

					buffer_info->skb);

   377

   378

				if (netif_msg_pktdata(adapter))

   379

					print_hex_dump(KERN_INFO, "",

   380

						DUMP_PREFIX_ADDRESS, 16, 1,

   381

						phys_to_virt(buffer_info->dma),

   382

						adapter->rx_ps_bsize0, true);

   383

			}

   384

   385

			if (i == rx_ring->next_to_use)

   386

				printk(KERN_CONT " NTU\n");

   387

			else if (i == rx_ring->next_to_clean)

   388

				printk(KERN_CONT " NTC\n");

   389

			else

   390

				printk(KERN_CONT "\n");

   391

		}

   392

		break;

   393

	default:

   394

	case 0:

   395

		/* Legacy Receive Descriptor Format

   396

		 *

   397

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

   398

		 * |                Buffer Address [63:0]                |

   399

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

   400

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

   401

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

   402

		 * 63       48 47    40 39      32 31         16 15      0

   403

		 */

   404

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

   405

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

   406

			"<-- Legacy format\n");

   407

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

   408

			rx_desc = E1000_RX_DESC(*rx_ring, i);

   409

			buffer_info = &rx_ring->buffer_info[i];

   410

			u0 = (struct my_u0 *)rx_desc;

   411

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

   412

				"%016llX %p", i,

   413

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

   414

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

   415

				(unsigned long long)buffer_info->dma,

   416

				buffer_info->skb);

   417

			if (i == rx_ring->next_to_use)

   418

				printk(KERN_CONT " NTU\n");

   419

			else if (i == rx_ring->next_to_clean)

   420

				printk(KERN_CONT " NTC\n");

   421

			else

   422

				printk(KERN_CONT "\n");

   423

   424

			if (netif_msg_pktdata(adapter))

   425

				print_hex_dump(KERN_INFO, "",

   426

					DUMP_PREFIX_ADDRESS,

   427

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

   428

					adapter->rx_buffer_len, true);

   429

		}

   430

	}

   431

   432

exit:

   433

	return;

   434

}

   435

   436

/**

   437

 * e1000_desc_unused - calculate if we have unused descriptors

   438

 **/

   439

static int e1000_desc_unused(struct e1000_ring *ring)

   440

{

   441

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

   442

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

   443

   444

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

   445

}

   446

   447

/**

   448

 * e1000_receive_skb - helper function to handle Rx indications

   449

 * @adapter: board private structure

   450

 * @status: descriptor status field as written by hardware

   451

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

   452

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

   453

 **/

   454

static void e1000_receive_skb(struct e1000_adapter *adapter,

   455

			      struct net_device *netdev,

   456

			      struct sk_buff *skb,

   457

			      u8 status, __le16 vlan)

   458

{

   459

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

   460

   461

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

   462

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

   463

				 le16_to_cpu(vlan), skb);

   464

	else

   465

		napi_gro_receive(&adapter->napi, skb);

   466

}

   467

   468

/**

   469

 * e1000_rx_checksum - Receive Checksum Offload for 82543

   470

 * @adapter:     board private structure

   471

 * @status_err:  receive descriptor status and error fields

   472

 * @csum:	receive descriptor csum field

   473

 * @sk_buff:     socket buffer with received data

   474

 **/

   475

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

   476

			      u32 csum, struct sk_buff *skb)

   477

{

   478

	u16 status = (u16)status_err;

   479

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

   480

   481

	skb_checksum_none_assert(skb);

   482

   483

	/* Ignore Checksum bit is set */

   484

	if (status & E1000_RXD_STAT_IXSM)

   485

		return;

   486

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

   487

	if (errors & E1000_RXD_ERR_TCPE) {

   488

		/* let the stack verify checksum errors */

   489

		adapter->hw_csum_err++;

   490

		return;

   491

	}

   492

   493

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

   494

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

   495

		return;

   496

   497

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

   498

	if (status & E1000_RXD_STAT_TCPCS) {

   499

		/* TCP checksum is good */

   500

		skb->ip_summed = CHECKSUM_UNNECESSARY;

   501

	} else {

   502

		/*

   503

		 * IP fragment with UDP payload

   504

		 * Hardware complements the payload checksum, so we undo it

   505

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

   506

		 */

   507

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

   508

		skb->csum = csum_unfold(~sum);

   509

		skb->ip_summed = CHECKSUM_COMPLETE;

   510

	}

   511

	adapter->hw_csum_good++;

   512

}

   513

   514

/**

   515

 * e1000_alloc_rx_buffers - Replace used receive buffers; legacy & extended

   516

 * @adapter: address of board private structure

   517

 **/

   518

static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,

   519

				   int cleaned_count)

   520

{

   521

	struct net_device *netdev = adapter->netdev;

   522

	struct pci_dev *pdev = adapter->pdev;

   523

	struct e1000_ring *rx_ring = adapter->rx_ring;

   524

	struct e1000_rx_desc *rx_desc;

   525

	struct e1000_buffer *buffer_info;

   526

	struct sk_buff *skb;

   527

	unsigned int i;

   528

	unsigned int bufsz = adapter->rx_buffer_len;

   529

   530