1

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

     2

     3

  Intel PRO/1000 Linux driver

     4

  Copyright(c) 1999 - 2011 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/interrupt.h>

    40

#include <linux/tcp.h>

    41

#include <linux/ipv6.h>

    42

#include <linux/slab.h>

    43

#include <net/checksum.h>

    44

#include <net/ip6_checksum.h>

    45

#include <linux/mii.h>

    46

#include <linux/ethtool.h>

    47

#include <linux/if_vlan.h>

    48

#include <linux/cpu.h>

    49

#include <linux/smp.h>

    50

#include <linux/pm_qos.h>

    51

#include <linux/pm_runtime.h>

    52

#include <linux/aer.h>

    53

#include <linux/prefetch.h>

    54

    55

#include "e1000-3.2-ethercat.h"

    56

    57

#define DRV_EXTRAVERSION "-k-EtherCAT"

    58

    59

#define DRV_VERSION "1.5.1" DRV_EXTRAVERSION

    60

char e1000e_driver_name[] = "ec_e1000e";

    61

const char e1000e_driver_version[] = DRV_VERSION;

    62

    63

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

    64

    65

static const struct e1000_info *e1000_info_tbl[] = {

    66

	[board_82571]		= &e1000_82571_info,

    67

	[board_82572]		= &e1000_82572_info,

    68

	[board_82573]		= &e1000_82573_info,

    69

	[board_82574]		= &e1000_82574_info,

    70

	[board_82583]		= &e1000_82583_info,

    71

	[board_80003es2lan]	= &e1000_es2_info,

    72

	[board_ich8lan]		= &e1000_ich8_info,

    73

	[board_ich9lan]		= &e1000_ich9_info,

    74

	[board_ich10lan]	= &e1000_ich10_info,

    75

	[board_pchlan]		= &e1000_pch_info,

    76

	[board_pch2lan]		= &e1000_pch2_info,

    77

};

    78

    79

struct e1000_reg_info {

    80

	u32 ofs;

    81

	char *name;

    82

};

    83

    84

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

    85

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

    86

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

    87

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

    88

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

    89

    90

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

    91

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

    92

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

    93

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

    94

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

    95

    96

static const struct e1000_reg_info e1000_reg_info_tbl[] = {

    97

    98

	/* General Registers */

    99

	{E1000_CTRL, "CTRL"},

   100

	{E1000_STATUS, "STATUS"},

   101

	{E1000_CTRL_EXT, "CTRL_EXT"},

   102

   103

	/* Interrupt Registers */

   104

	{E1000_ICR, "ICR"},

   105

   106

	/* Rx Registers */

   107

	{E1000_RCTL, "RCTL"},

   108

	{E1000_RDLEN, "RDLEN"},

   109

	{E1000_RDH, "RDH"},

   110

	{E1000_RDT, "RDT"},

   111

	{E1000_RDTR, "RDTR"},

   112

	{E1000_RXDCTL(0), "RXDCTL"},

   113

	{E1000_ERT, "ERT"},

   114

	{E1000_RDBAL, "RDBAL"},

   115

	{E1000_RDBAH, "RDBAH"},

   116

	{E1000_RDFH, "RDFH"},

   117

	{E1000_RDFT, "RDFT"},

   118

	{E1000_RDFHS, "RDFHS"},

   119

	{E1000_RDFTS, "RDFTS"},

   120

	{E1000_RDFPC, "RDFPC"},

   121

   122

	/* Tx Registers */

   123

	{E1000_TCTL, "TCTL"},

   124

	{E1000_TDBAL, "TDBAL"},

   125

	{E1000_TDBAH, "TDBAH"},

   126

	{E1000_TDLEN, "TDLEN"},

   127

	{E1000_TDH, "TDH"},

   128

	{E1000_TDT, "TDT"},

   129

	{E1000_TIDV, "TIDV"},

   130

	{E1000_TXDCTL(0), "TXDCTL"},

   131

	{E1000_TADV, "TADV"},

   132

	{E1000_TARC(0), "TARC"},

   133

	{E1000_TDFH, "TDFH"},

   134

	{E1000_TDFT, "TDFT"},

   135

	{E1000_TDFHS, "TDFHS"},

   136

	{E1000_TDFTS, "TDFTS"},

   137

	{E1000_TDFPC, "TDFPC"},

   138

   139

	/* List Terminator */

   140

	{}

   141

};

   142

   143

/*

   144

 * e1000_regdump - register printout routine

   145

 */

   146

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

   147

{

   148

	int n = 0;

   149

	char rname[16];

   150

	u32 regs[8];

   151

   152

	switch (reginfo->ofs) {

   153

	case E1000_RXDCTL(0):

   154

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

   155

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

   156

		break;

   157

	case E1000_TXDCTL(0):

   158

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

   159

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

   160

		break;

   161

	case E1000_TARC(0):

   162

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

   163

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

   164

		break;

   165

	default:

   166

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

   167

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

   168

		return;

   169

	}

   170

   171

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

   172

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

   173

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

   174

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

   175

	printk(KERN_CONT "\n");

   176

}

   177

   178

/*

   179

 * e1000e_dump - Print registers, Tx-ring and Rx-ring

   180

 */

   181

static void e1000e_dump(struct e1000_adapter *adapter)

   182

{

   183

	struct net_device *netdev = adapter->netdev;

   184

	struct e1000_hw *hw = &adapter->hw;

   185

	struct e1000_reg_info *reginfo;

   186

	struct e1000_ring *tx_ring = adapter->tx_ring;

   187

	struct e1000_tx_desc *tx_desc;

   188

	struct my_u0 {

   189

		u64 a;

   190

		u64 b;

   191

	} *u0;

   192

	struct e1000_buffer *buffer_info;

   193

	struct e1000_ring *rx_ring = adapter->rx_ring;

   194

	union e1000_rx_desc_packet_split *rx_desc_ps;

   195

	union e1000_rx_desc_extended *rx_desc;

   196

	struct my_u1 {

   197

		u64 a;

   198

		u64 b;

   199

		u64 c;

   200

		u64 d;

   201

	} *u1;

   202

	u32 staterr;

   203

	int i = 0;

   204

   205

	if (!netif_msg_hw(adapter))

   206

		return;

   207

   208

	/* Print netdevice Info */

   209

	if (netdev) {

   210

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

   211

		printk(KERN_INFO "Device Name     state            "

   212

		       "trans_start      last_rx\n");

   213

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

   214

		       netdev->name, netdev->state, netdev->trans_start,

   215

		       netdev->last_rx);

   216

	}

   217

   218

	/* Print Registers */

   219

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

   220

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

   221

	for (reginfo = (struct e1000_reg_info *)e1000_reg_info_tbl;

   222

	     reginfo->name; reginfo++) {

   223

		e1000_regdump(hw, reginfo);

   224

	}

   225

   226

	/* Print Tx Ring Summary */

   227

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

   228

		goto exit;

   229

   230

	dev_info(&adapter->pdev->dev, "Tx Ring Summary\n");

   231

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

   232

	       " leng ntw timestamp\n");

   233

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

   234

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

   235

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

   236

	       (unsigned long long)buffer_info->dma,

   237

	       buffer_info->length,

   238

	       buffer_info->next_to_watch,

   239

	       (unsigned long long)buffer_info->time_stamp);

   240

   241

	/* Print Tx Ring */

   242

	if (!netif_msg_tx_done(adapter))

   243

		goto rx_ring_summary;

   244

   245

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

   246

   247

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

   248

	 *

   249

	 * Legacy Transmit Descriptor

   250

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

   251

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

   252

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

   253

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

   254

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

   255

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

   256

	 *

   257

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

   258

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

   259

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

   260

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

   261

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

   262

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

   263

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

   264

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

   265

	 *

   266

	 * Extended Data Descriptor (DTYP=0x1)

   267

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

   268

	 * 0 |                     Buffer Address [63:0]                      |

   269

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

   270

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

   271

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

   272

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

   273

	 */

   274

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

   275

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

   276

	       "<-- Legacy format\n");

   277

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

   278

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

   279

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

   280

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

   281

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

   282

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

   283

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

   284

		tx_desc = E1000_TX_DESC(*tx_ring, i);

   285

		buffer_info = &tx_ring->buffer_info[i];

   286

		u0 = (struct my_u0 *)tx_desc;

   287

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

   288

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

   289

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

   290

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

   291

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

   292

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

   293

		       (unsigned long long)buffer_info->dma,

   294

		       buffer_info->length, buffer_info->next_to_watch,

   295

		       (unsigned long long)buffer_info->time_stamp,

   296

		       buffer_info->skb);

   297

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

   298

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

   299

		else if (i == tx_ring->next_to_use)

   300

			printk(KERN_CONT " NTU\n");

   301

		else if (i == tx_ring->next_to_clean)

   302

			printk(KERN_CONT " NTC\n");

   303

		else

   304

			printk(KERN_CONT "\n");

   305

   306

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

   307

			print_hex_dump(KERN_INFO, "", DUMP_PREFIX_ADDRESS,

   308

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

   309

				       buffer_info->length, true);

   310

	}

   311

   312

	/* Print Rx Ring Summary */

   313

rx_ring_summary:

   314

	dev_info(&adapter->pdev->dev, "Rx Ring Summary\n");

   315

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

   316

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

   317

	       rx_ring->next_to_use, rx_ring->next_to_clean);

   318

   319

	/* Print Rx Ring */

   320

	if (!netif_msg_rx_status(adapter))

   321

		goto exit;

   322

   323

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

   324

	switch (adapter->rx_ps_pages) {

   325

	case 1:

   326

	case 2:

   327

	case 3:

   328

		/* [Extended] Packet Split Receive Descriptor Format

   329

		 *

   330

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

   331

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

   332

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

   333

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

   334

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

   335

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

   336

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

   337

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

   338

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

   339

		 */

   340

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

   341

		       "[buffer 1 63:0 ] "

   342

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

   343

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

   344

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

   345

		 *

   346

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

   347

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

   348

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

   349

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

   350

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

   351

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

   352

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

   353

		 *   63       48 47    32 31            20 19               0

   354

		 */

   355

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

   356

		       "[vl   l0 ee  es] "

   357

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

   358

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

   359

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

   360

			buffer_info = &rx_ring->buffer_info[i];

   361

			rx_desc_ps = E1000_RX_DESC_PS(*rx_ring, i);

   362

			u1 = (struct my_u1 *)rx_desc_ps;

   363

			staterr =

   364

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

   365

			if (staterr & E1000_RXD_STAT_DD) {

   366

				/* Descriptor Done */

   367

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

   368

				       "%016llX %016llX %016llX "

   369

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

   370

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

   371

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

   372

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

   373

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

   374

				       buffer_info->skb);

   375

			} else {

   376

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

   377

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

   378

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

   379

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

   380

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

   381

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

   382

				       (unsigned long long)buffer_info->dma,

   383

				       buffer_info->skb);

   384

   385

				if (netif_msg_pktdata(adapter))

   386

					print_hex_dump(KERN_INFO, "",

   387

						DUMP_PREFIX_ADDRESS, 16, 1,

   388

						phys_to_virt(buffer_info->dma),

   389

						adapter->rx_ps_bsize0, true);

   390

			}

   391

   392

			if (i == rx_ring->next_to_use)

   393

				printk(KERN_CONT " NTU\n");

   394

			else if (i == rx_ring->next_to_clean)

   395

				printk(KERN_CONT " NTC\n");

   396

			else

   397

				printk(KERN_CONT "\n");

   398

		}

   399

		break;

   400

	default:

   401

	case 0:

   402

		/* Extended Receive Descriptor (Read) Format

   403

		 *

   404

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

   405

		 * 0 |                Buffer Address [63:0]                |

   406

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

   407

		 * 8 |                      Reserved                       |

   408

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

   409

		 */

   410

		printk(KERN_INFO "R  [desc]      [buf addr 63:0 ] "

   411

		       "[reserved 63:0 ] [bi->dma       ] "

   412

		       "[bi->skb] <-- Ext (Read) format\n");

   413

		/* Extended Receive Descriptor (Write-Back) Format

   414

		 *

   415

		 *   63       48 47    32 31    24 23            4 3        0

   416

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

   417

		 *   |     RSS Hash      |        |               |         |

   418

		 * 0 +-------------------+  Rsvd  |   Reserved    | MRQ RSS |

   419

		 *   | Packet   | IP     |        |               |  Type   |

   420

		 *   | Checksum | Ident  |        |               |         |

   421

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

   422

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

   423

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

   424

		 *   63       48 47    32 31            20 19               0

   425

		 */

   426

		printk(KERN_INFO "RWB[desc]      [cs ipid    mrq] "

   427

		       "[vt   ln xe  xs] "

   428

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

   429

   430

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

   431

			buffer_info = &rx_ring->buffer_info[i];

   432

			rx_desc = E1000_RX_DESC_EXT(*rx_ring, i);

   433

			u1 = (struct my_u1 *)rx_desc;

   434

			staterr = le32_to_cpu(rx_desc->wb.upper.status_error);

   435

			if (staterr & E1000_RXD_STAT_DD) {

   436

				/* Descriptor Done */

   437

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

   438

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

   439

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

   440

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

   441

				       buffer_info->skb);

   442

			} else {

   443

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

   444

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

   445

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

   446

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

   447

				       (unsigned long long)buffer_info->dma,

   448

				       buffer_info->skb);

   449

   450

				if (netif_msg_pktdata(adapter))

   451

					print_hex_dump(KERN_INFO, "",

   452

						       DUMP_PREFIX_ADDRESS, 16,

   453

						       1,

   454

						       phys_to_virt

   455

						       (buffer_info->dma),

   456

						       adapter->rx_buffer_len,

   457

						       true);

   458

			}

   459

   460

			if (i == rx_ring->next_to_use)

   461

				printk(KERN_CONT " NTU\n");

   462

			else if (i == rx_ring->next_to_clean)

   463

				printk(KERN_CONT " NTC\n");

   464

			else

   465

				printk(KERN_CONT "\n");

   466

		}

   467

	}

   468

   469

exit:

   470

	return;

   471

}

   472

   473

/**

   474

 * e1000_desc_unused - calculate if we have unused descriptors

   475

 **/

   476

static int e1000_desc_unused(struct e1000_ring *ring)

   477

{

   478

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

   479

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

   480

   481

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

   482

}

   483

   484

/**

   485

 * e1000_receive_skb - helper function to handle Rx indications

   486

 * @adapter: board private structure

   487

 * @status: descriptor status field as written by hardware

   488

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

   489

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

   490

 **/

   491

static void e1000_receive_skb(struct e1000_adapter *adapter,

   492

			      struct net_device *netdev, struct sk_buff *skb,

   493

			      u8 status, __le16 vlan)

   494

{

   495

	u16 tag = le16_to_cpu(vlan);

   496

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

   497

   498

	if (status & E1000_RXD_STAT_VP)

   499

		__vlan_hwaccel_put_tag(skb, tag);

   500

   501

	napi_gro_receive(&adapter->napi, skb);

   502

}

   503

   504

/**

   505

 * e1000_rx_checksum - Receive Checksum Offload

   506

 * @adapter:     board private structure

   507

 * @status_err:  receive descriptor status and error fields

   508

 * @csum:	receive descriptor csum field

   509

 * @sk_buff:     socket buffer with received data

   510

 **/

   511

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

   512

			      u32 csum, struct sk_buff *skb)

   513

{

   514

	u16 status = (u16)status_err;

   515

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

   516

   517

	skb_checksum_none_assert(skb);

   518

   519

	/* Ignore Checksum bit is set */

   520

	if (status & E1000_RXD_STAT_IXSM)

   521

		return;

   522

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

   523

	if (errors & E1000_RXD_ERR_TCPE) {

   524

		/* let the stack verify checksum errors */

   525

		adapter->hw_csum_err++;

   526

		return;

   527

	}

   528

   529

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