1

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

     2

     3

  Intel PRO/1000 Linux driver

     4

  Copyright(c) 1999 - 2009 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.35-ethercat.h"

    56

    57

#define DRV_VERSION "1.0.2-k4 (EtherCAT)"

    58

char e1000e_driver_name[] = "ec_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

};

    73

    74

struct e1000_reg_info {

    75

	u32 ofs;

    76

	char *name;

    77

};

    78

    79

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

    80

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

    81

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

    82

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

    83

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

    84

    85

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

    86

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

    87

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

    88

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

    89

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

    90

    91

static const struct e1000_reg_info e1000_reg_info_tbl[] = {

    92

    93

	/* General Registers */

    94

	{E1000_CTRL, "CTRL"},

    95

	{E1000_STATUS, "STATUS"},

    96

	{E1000_CTRL_EXT, "CTRL_EXT"},

    97

    98

	/* Interrupt Registers */

    99

	{E1000_ICR, "ICR"},

   100

   101

	/* RX Registers */

   102

	{E1000_RCTL, "RCTL"},

   103

	{E1000_RDLEN, "RDLEN"},

   104

	{E1000_RDH, "RDH"},

   105

	{E1000_RDT, "RDT"},

   106

	{E1000_RDTR, "RDTR"},

   107

	{E1000_RXDCTL(0), "RXDCTL"},

   108

	{E1000_ERT, "ERT"},

   109

	{E1000_RDBAL, "RDBAL"},

   110

	{E1000_RDBAH, "RDBAH"},

   111

	{E1000_RDFH, "RDFH"},

   112

	{E1000_RDFT, "RDFT"},

   113

	{E1000_RDFHS, "RDFHS"},

   114

	{E1000_RDFTS, "RDFTS"},

   115

	{E1000_RDFPC, "RDFPC"},

   116

   117

	/* TX Registers */

   118

	{E1000_TCTL, "TCTL"},

   119

	{E1000_TDBAL, "TDBAL"},

   120

	{E1000_TDBAH, "TDBAH"},

   121

	{E1000_TDLEN, "TDLEN"},

   122

	{E1000_TDH, "TDH"},

   123

	{E1000_TDT, "TDT"},

   124

	{E1000_TIDV, "TIDV"},

   125

	{E1000_TXDCTL(0), "TXDCTL"},

   126

	{E1000_TADV, "TADV"},

   127

	{E1000_TARC(0), "TARC"},

   128

	{E1000_TDFH, "TDFH"},

   129

	{E1000_TDFT, "TDFT"},

   130

	{E1000_TDFHS, "TDFHS"},

   131

	{E1000_TDFTS, "TDFTS"},

   132

	{E1000_TDFPC, "TDFPC"},

   133

   134

	/* List Terminator */

   135

	{}

   136

};

   137

   138

/*

   139

 * e1000_regdump - register printout routine

   140

 */

   141

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

   142

{

   143

	int n = 0;

   144

	char rname[16];

   145

	u32 regs[8];

   146

   147

	switch (reginfo->ofs) {

   148

	case E1000_RXDCTL(0):

   149

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

   150

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

   151

		break;

   152

	case E1000_TXDCTL(0):

   153

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

   154

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

   155

		break;

   156

	case E1000_TARC(0):

   157

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

   158

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

   159

		break;

   160

	default:

   161

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

   162

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

   163

		return;

   164

	}

   165

   166

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

   167

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

   168

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

   169

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

   170

	printk(KERN_CONT "\n");

   171

}

   172

   173

   174

/*

   175

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

   176

 */

   177

static void e1000e_dump(struct e1000_adapter *adapter)

   178

{

   179

	struct net_device *netdev = adapter->netdev;

   180

	struct e1000_hw *hw = &adapter->hw;

   181

	struct e1000_reg_info *reginfo;

   182

	struct e1000_ring *tx_ring = adapter->tx_ring;

   183

	struct e1000_tx_desc *tx_desc;

   184

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

   185

	struct e1000_buffer *buffer_info;

   186

	struct e1000_ring *rx_ring = adapter->rx_ring;

   187

	union e1000_rx_desc_packet_split *rx_desc_ps;

   188

	struct e1000_rx_desc *rx_desc;

   189

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

   190

	u32 staterr;

   191

	int i = 0;

   192

   193

	if (!netif_msg_hw(adapter))

   194

		return;

   195

   196

	/* Print netdevice Info */

   197

	if (netdev) {

   198

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

   199

		printk(KERN_INFO "Device Name     state            "

   200

			"trans_start      last_rx\n");

   201

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

   202

			netdev->name,

   203

			netdev->state,

   204

			netdev->trans_start,

   205

			netdev->last_rx);

   206

	}

   207

   208

	/* Print Registers */

   209

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

   210

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

   211

	for (reginfo = (struct e1000_reg_info *)e1000_reg_info_tbl;

   212

	     reginfo->name; reginfo++) {

   213

		e1000_regdump(hw, reginfo);

   214

	}

   215

   216

	/* Print TX Ring Summary */

   217

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

   218

		goto exit;

   219

   220

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

   221

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

   222

		" leng ntw timestamp\n");

   223

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

   224

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

   225

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

   226

		(u64)buffer_info->dma,

   227

		buffer_info->length,

   228

		buffer_info->next_to_watch,

   229

		(u64)buffer_info->time_stamp);

   230

   231

	/* Print TX Rings */

   232

	if (!netif_msg_tx_done(adapter))

   233

		goto rx_ring_summary;

   234

   235

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

   236

   237

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

   238

	 *

   239

	 * Legacy Transmit Descriptor

   240

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

   241

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

   242

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

   243

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

   244

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

   245

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

   246

	 *

   247

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

   248

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

   249

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

   250

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

   251

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

   252

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

   253

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

   254

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

   255

	 *

   256

	 * Extended Data Descriptor (DTYP=0x1)

   257

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

   258

	 * 0 |                     Buffer Address [63:0]                      |

   259

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

   260

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

   261

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

   262

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

   263

	 */

   264

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

   265

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

   266

		"<-- Legacy format\n");

   267

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

   268

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

   269

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

   270

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

   271

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

   272

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

   273

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

   274

		tx_desc = E1000_TX_DESC(*tx_ring, i);

   275

		buffer_info = &tx_ring->buffer_info[i];

   276

		u0 = (struct my_u0 *)tx_desc;

   277

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

   278

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

   279

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

   280

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

   281

		       le64_to_cpu(u0->a), le64_to_cpu(u0->b),

   282

		       (u64)buffer_info->dma, buffer_info->length,

   283

		       buffer_info->next_to_watch, (u64)buffer_info->time_stamp,

   284

		       buffer_info->skb);

   285

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

   286

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

   287

		else if (i == tx_ring->next_to_use)

   288

			printk(KERN_CONT " NTU\n");

   289

		else if (i == tx_ring->next_to_clean)

   290

			printk(KERN_CONT " NTC\n");

   291

		else

   292

			printk(KERN_CONT "\n");

   293

   294

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

   295

			print_hex_dump(KERN_INFO, "", DUMP_PREFIX_ADDRESS,

   296

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

   297

					buffer_info->length, true);

   298

	}

   299

   300

	/* Print RX Rings Summary */

   301

rx_ring_summary:

   302

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

   303

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

   304

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

   305

		rx_ring->next_to_use, rx_ring->next_to_clean);

   306

   307

	/* Print RX Rings */

   308

	if (!netif_msg_rx_status(adapter))

   309

		goto exit;

   310

   311

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

   312

	switch (adapter->rx_ps_pages) {

   313

	case 1:

   314

	case 2:

   315

	case 3:

   316

		/* [Extended] Packet Split Receive Descriptor Format

   317

		 *

   318

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

   319

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

   320

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

   321

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

   322

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

   323

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

   324

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

   325

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

   326

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

   327

		 */

   328

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

   329

			"[buffer 1 63:0 ] "

   330

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

   331

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

   332

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

   333

		 *

   334

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

   335

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

   336

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

   337

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

   338

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

   339

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

   340

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

   341

		 *   63       48 47    32 31            20 19               0

   342

		 */

   343

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

   344

			"[vl   l0 ee  es] "

   345

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

   346

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

   347

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

   348

			buffer_info = &rx_ring->buffer_info[i];

   349

			rx_desc_ps = E1000_RX_DESC_PS(*rx_ring, i);

   350

			u1 = (struct my_u1 *)rx_desc_ps;

   351

			staterr =

   352

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

   353

			if (staterr & E1000_RXD_STAT_DD) {

   354

				/* Descriptor Done */

   355

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

   356

					"%016llX %016llX %016llX "

   357

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

   358

					le64_to_cpu(u1->a),

   359

					le64_to_cpu(u1->b),

   360

					le64_to_cpu(u1->c),

   361

					le64_to_cpu(u1->d),

   362

					buffer_info->skb);

   363

			} else {

   364

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

   365

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

   366

					le64_to_cpu(u1->a),

   367

					le64_to_cpu(u1->b),

   368

					le64_to_cpu(u1->c),

   369

					le64_to_cpu(u1->d),

   370

					(u64)buffer_info->dma,

   371

					buffer_info->skb);

   372

   373

				if (netif_msg_pktdata(adapter))

   374

					print_hex_dump(KERN_INFO, "",

   375

						DUMP_PREFIX_ADDRESS, 16, 1,

   376

						phys_to_virt(buffer_info->dma),

   377

						adapter->rx_ps_bsize0, true);

   378

			}

   379

   380

			if (i == rx_ring->next_to_use)

   381

				printk(KERN_CONT " NTU\n");

   382

			else if (i == rx_ring->next_to_clean)

   383

				printk(KERN_CONT " NTC\n");

   384

			else

   385

				printk(KERN_CONT "\n");

   386

		}

   387

		break;

   388

	default:

   389

	case 0:

   390

		/* Legacy Receive Descriptor Format

   391

		 *

   392

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

   393

		 * |                Buffer Address [63:0]                |

   394

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

   395

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

   396

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

   397

		 * 63       48 47    40 39      32 31         16 15      0

   398

		 */

   399

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

   400

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

   401

			"<-- Legacy format\n");

   402

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

   403

			rx_desc = E1000_RX_DESC(*rx_ring, i);

   404

			buffer_info = &rx_ring->buffer_info[i];

   405

			u0 = (struct my_u0 *)rx_desc;

   406

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

   407

				"%016llX %p",

   408

				i, le64_to_cpu(u0->a), le64_to_cpu(u0->b),

   409

				(u64)buffer_info->dma, buffer_info->skb);

   410

			if (i == rx_ring->next_to_use)

   411

				printk(KERN_CONT " NTU\n");

   412

			else if (i == rx_ring->next_to_clean)

   413

				printk(KERN_CONT " NTC\n");

   414

			else

   415

				printk(KERN_CONT "\n");

   416

   417

			if (netif_msg_pktdata(adapter))

   418

				print_hex_dump(KERN_INFO, "",

   419

					DUMP_PREFIX_ADDRESS,

   420

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

   421

					adapter->rx_buffer_len, true);

   422

		}

   423

	}

   424

   425

exit:

   426

	return;

   427

}

   428

   429

/**

   430

 * e1000_desc_unused - calculate if we have unused descriptors

   431

 **/

   432

static int e1000_desc_unused(struct e1000_ring *ring)

   433

{

   434

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

   435

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

   436

   437

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

   438

}

   439

   440

/**

   441

 * e1000_receive_skb - helper function to handle Rx indications

   442

 * @adapter: board private structure

   443

 * @status: descriptor status field as written by hardware

   444

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

   445

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

   446

 **/

   447

static void e1000_receive_skb(struct e1000_adapter *adapter,

   448

			      struct net_device *netdev,

   449

			      struct sk_buff *skb,

   450

			      u8 status, __le16 vlan)

   451

{

   452

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

   453

   454

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

   455

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

   456

				 le16_to_cpu(vlan), skb);

   457

	else

   458

		napi_gro_receive(&adapter->napi, skb);

   459

}

   460

   461

/**

   462

 * e1000_rx_checksum - Receive Checksum Offload for 82543

   463

 * @adapter:     board private structure

   464

 * @status_err:  receive descriptor status and error fields

   465

 * @csum:	receive descriptor csum field

   466

 * @sk_buff:     socket buffer with received data

   467

 **/

   468

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

   469

			      u32 csum, struct sk_buff *skb)

   470

{

   471

	u16 status = (u16)status_err;

   472

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

   473

	skb->ip_summed = CHECKSUM_NONE;

   474

   475

	/* Ignore Checksum bit is set */

   476

	if (status & E1000_RXD_STAT_IXSM)

   477

		return;

   478

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

   479

	if (errors & E1000_RXD_ERR_TCPE) {

   480

		/* let the stack verify checksum errors */

   481

		adapter->hw_csum_err++;

   482

		return;

   483

	}

   484

   485

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

   486

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

   487

		return;

   488

   489

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

   490

	if (status & E1000_RXD_STAT_TCPCS) {

   491

		/* TCP checksum is good */

   492

		skb->ip_summed = CHECKSUM_UNNECESSARY;

   493

	} else {

   494

		/*

   495

		 * IP fragment with UDP payload

   496

		 * Hardware complements the payload checksum, so we undo it

   497

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

   498

		 */

   499

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

   500

		skb->csum = csum_unfold(~sum);

   501

		skb->ip_summed = CHECKSUM_COMPLETE;

   502

	}

   503

	adapter->hw_csum_good++;

   504

}

   505

   506

/**

   507

 * e1000_alloc_rx_buffers - Replace used receive buffers; legacy & extended

   508

 * @adapter: address of board private structure

   509

 **/

   510

static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,

   511

				   int cleaned_count)

   512

{

   513

	struct net_device *netdev = adapter->netdev;

   514

	struct pci_dev *pdev = adapter->pdev;

   515

	struct e1000_ring *rx_ring = adapter->rx_ring;

   516

	struct e1000_rx_desc *rx_desc;

   517

	struct e1000_buffer *buffer_info;

   518

	struct sk_buff *skb;

   519

	unsigned int i;

   520

	unsigned int bufsz = adapter->rx_buffer_len;

   521

   522

	i = rx_ring->next_to_use;

   523

	buffer_info = &rx_ring->buffer_info[i];

   524

   525

	while (cleaned_count--) {

   526

		skb = buffer_info->skb;

   527

		if (skb) {

   528

			skb_trim(skb, 0);

   529

			goto map_skb;

   530