1

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

     2

     3

  Intel PRO/1000 Linux driver

     4

  Copyright(c) 1999 - 2008 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

#include <linux/module.h>

    30

#include <linux/types.h>

    31

#include <linux/init.h>

    32

#include <linux/pci.h>

    33

#include <linux/vmalloc.h>

    34

#include <linux/pagemap.h>

    35

#include <linux/delay.h>

    36

#include <linux/netdevice.h>

    37

#include <linux/tcp.h>

    38

#include <linux/ipv6.h>

    39

#include <net/checksum.h>

    40

#include <net/ip6_checksum.h>

    41

#include <linux/mii.h>

    42

#include <linux/ethtool.h>

    43

#include <linux/if_vlan.h>

    44

#include <linux/cpu.h>

    45

#include <linux/smp.h>

    46

#include <linux/pm_qos_params.h>

    47

#include <linux/aer.h>

    48

    49

#include "e1000.h"

    50

    51

#define DRV_VERSION "1.0.2-k2"

    52

char e1000e_driver_name[] = "e1000e";

    53

const char e1000e_driver_version[] = DRV_VERSION;

    54

    55

static const struct e1000_info *e1000_info_tbl[] = {

    56

	[board_82571]		= &e1000_82571_info,

    57

	[board_82572]		= &e1000_82572_info,

    58

	[board_82573]		= &e1000_82573_info,

    59

	[board_82574]		= &e1000_82574_info,

    60

	[board_82583]		= &e1000_82583_info,

    61

	[board_80003es2lan]	= &e1000_es2_info,

    62

	[board_ich8lan]		= &e1000_ich8_info,

    63

	[board_ich9lan]		= &e1000_ich9_info,

    64

	[board_ich10lan]	= &e1000_ich10_info,

    65

	[board_pchlan]		= &e1000_pch_info,

    66

};

    67

    68

#ifdef DEBUG

    69

/**

    70

 * e1000_get_hw_dev_name - return device name string

    71

 * used by hardware layer to print debugging information

    72

 **/

    73

char *e1000e_get_hw_dev_name(struct e1000_hw *hw)

    74

{

    75

	return hw->adapter->netdev->name;

    76

}

    77

#endif

    78

    79

/**

    80

 * e1000_desc_unused - calculate if we have unused descriptors

    81

 **/

    82

static int e1000_desc_unused(struct e1000_ring *ring)

    83

{

    84

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

    85

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

    86

    87

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

    88

}

    89

    90

/**

    91

 * e1000_receive_skb - helper function to handle Rx indications

    92

 * @adapter: board private structure

    93

 * @status: descriptor status field as written by hardware

    94

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

    95

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

    96

 **/

    97

static void e1000_receive_skb(struct e1000_adapter *adapter,

    98

			      struct net_device *netdev,

    99

			      struct sk_buff *skb,

   100

			      u8 status, __le16 vlan)

   101

{

   102

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

   103

   104

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

   105

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

   106

				 le16_to_cpu(vlan), skb);

   107

	else

   108

		napi_gro_receive(&adapter->napi, skb);

   109

}

   110

   111

/**

   112

 * e1000_rx_checksum - Receive Checksum Offload for 82543

   113

 * @adapter:     board private structure

   114

 * @status_err:  receive descriptor status and error fields

   115

 * @csum:	receive descriptor csum field

   116

 * @sk_buff:     socket buffer with received data

   117

 **/

   118

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

   119

			      u32 csum, struct sk_buff *skb)

   120

{

   121

	u16 status = (u16)status_err;

   122

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

   123

	skb->ip_summed = CHECKSUM_NONE;

   124

   125

	/* Ignore Checksum bit is set */

   126

	if (status & E1000_RXD_STAT_IXSM)

   127

		return;

   128

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

   129

	if (errors & E1000_RXD_ERR_TCPE) {

   130

		/* let the stack verify checksum errors */

   131

		adapter->hw_csum_err++;

   132

		return;

   133

	}

   134

   135

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

   136

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

   137

		return;

   138

   139

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

   140

	if (status & E1000_RXD_STAT_TCPCS) {

   141

		/* TCP checksum is good */

   142

		skb->ip_summed = CHECKSUM_UNNECESSARY;

   143

	} else {

   144

		/*

   145

		 * IP fragment with UDP payload

   146

		 * Hardware complements the payload checksum, so we undo it

   147

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

   148

		 */

   149

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

   150

		skb->csum = csum_unfold(~sum);

   151

		skb->ip_summed = CHECKSUM_COMPLETE;

   152

	}

   153

	adapter->hw_csum_good++;

   154

}

   155

   156

/**

   157

 * e1000_alloc_rx_buffers - Replace used receive buffers; legacy & extended

   158

 * @adapter: address of board private structure

   159

 **/

   160

static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,

   161

				   int cleaned_count)

   162

{

   163

	struct net_device *netdev = adapter->netdev;

   164

	struct pci_dev *pdev = adapter->pdev;

   165

	struct e1000_ring *rx_ring = adapter->rx_ring;

   166

	struct e1000_rx_desc *rx_desc;

   167

	struct e1000_buffer *buffer_info;

   168

	struct sk_buff *skb;

   169

	unsigned int i;

   170

	unsigned int bufsz = adapter->rx_buffer_len + NET_IP_ALIGN;

   171

   172

	i = rx_ring->next_to_use;

   173

	buffer_info = &rx_ring->buffer_info[i];

   174

   175

	while (cleaned_count--) {

   176

		skb = buffer_info->skb;

   177

		if (skb) {

   178

			skb_trim(skb, 0);

   179

			goto map_skb;

   180

		}

   181

   182

		skb = netdev_alloc_skb(netdev, bufsz);

   183

		if (!skb) {

   184

			/* Better luck next round */

   185

			adapter->alloc_rx_buff_failed++;

   186

			break;

   187

		}

   188

   189

		/*

   190

		 * Make buffer alignment 2 beyond a 16 byte boundary

   191

		 * this will result in a 16 byte aligned IP header after

   192

		 * the 14 byte MAC header is removed

   193

		 */

   194

		skb_reserve(skb, NET_IP_ALIGN);

   195

   196

		buffer_info->skb = skb;

   197

map_skb:

   198

		buffer_info->dma = pci_map_single(pdev, skb->data,

   199

						  adapter->rx_buffer_len,

   200

						  PCI_DMA_FROMDEVICE);

   201

		if (pci_dma_mapping_error(pdev, buffer_info->dma)) {

   202

			dev_err(&pdev->dev, "RX DMA map failed\n");

   203

			adapter->rx_dma_failed++;

   204

			break;

   205

		}

   206

   207

		rx_desc = E1000_RX_DESC(*rx_ring, i);

   208

		rx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);

   209

   210

		i++;

   211

		if (i == rx_ring->count)

   212

			i = 0;

   213

		buffer_info = &rx_ring->buffer_info[i];

   214

	}

   215

   216

	if (rx_ring->next_to_use != i) {

   217

		rx_ring->next_to_use = i;

   218

		if (i-- == 0)

   219

			i = (rx_ring->count - 1);

   220

   221

		/*

   222

		 * Force memory writes to complete before letting h/w

   223

		 * know there are new descriptors to fetch.  (Only

   224

		 * applicable for weak-ordered memory model archs,

   225

		 * such as IA-64).

   226

		 */

   227

		wmb();

   228

		writel(i, adapter->hw.hw_addr + rx_ring->tail);

   229

	}

   230

}

   231

   232

/**

   233

 * e1000_alloc_rx_buffers_ps - Replace used receive buffers; packet split

   234

 * @adapter: address of board private structure

   235

 **/

   236

static void e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter,

   237

				      int cleaned_count)

   238

{

   239

	struct net_device *netdev = adapter->netdev;

   240

	struct pci_dev *pdev = adapter->pdev;

   241

	union e1000_rx_desc_packet_split *rx_desc;

   242

	struct e1000_ring *rx_ring = adapter->rx_ring;

   243

	struct e1000_buffer *buffer_info;

   244

	struct e1000_ps_page *ps_page;

   245

	struct sk_buff *skb;

   246

	unsigned int i, j;

   247

   248

	i = rx_ring->next_to_use;

   249

	buffer_info = &rx_ring->buffer_info[i];

   250

   251

	while (cleaned_count--) {

   252

		rx_desc = E1000_RX_DESC_PS(*rx_ring, i);

   253

   254

		for (j = 0; j < PS_PAGE_BUFFERS; j++) {

   255

			ps_page = &buffer_info->ps_pages[j];

   256

			if (j >= adapter->rx_ps_pages) {

   257

				/* all unused desc entries get hw null ptr */

   258

				rx_desc->read.buffer_addr[j+1] = ~cpu_to_le64(0);

   259

				continue;

   260

			}

   261

			if (!ps_page->page) {

   262

				ps_page->page = alloc_page(GFP_ATOMIC);

   263

				if (!ps_page->page) {

   264

					adapter->alloc_rx_buff_failed++;

   265

					goto no_buffers;

   266

				}

   267

				ps_page->dma = pci_map_page(pdev,

   268

						   ps_page->page,

   269

						   0, PAGE_SIZE,

   270

						   PCI_DMA_FROMDEVICE);

   271

				if (pci_dma_mapping_error(pdev, ps_page->dma)) {

   272

					dev_err(&adapter->pdev->dev,

   273

					  "RX DMA page map failed\n");

   274

					adapter->rx_dma_failed++;

   275

					goto no_buffers;

   276

				}

   277

			}

   278

			/*

   279

			 * Refresh the desc even if buffer_addrs

   280

			 * didn't change because each write-back

   281

			 * erases this info.

   282

			 */

   283

			rx_desc->read.buffer_addr[j+1] =

   284

			     cpu_to_le64(ps_page->dma);

   285

		}

   286

   287

		skb = netdev_alloc_skb(netdev,

   288

				       adapter->rx_ps_bsize0 + NET_IP_ALIGN);

   289

   290

		if (!skb) {

   291

			adapter->alloc_rx_buff_failed++;

   292

			break;

   293

		}

   294

   295

		/*

   296

		 * Make buffer alignment 2 beyond a 16 byte boundary

   297

		 * this will result in a 16 byte aligned IP header after

   298

		 * the 14 byte MAC header is removed

   299

		 */

   300

		skb_reserve(skb, NET_IP_ALIGN);

   301

   302

		buffer_info->skb = skb;

   303

		buffer_info->dma = pci_map_single(pdev, skb->data,

   304

						  adapter->rx_ps_bsize0,

   305

						  PCI_DMA_FROMDEVICE);

   306

		if (pci_dma_mapping_error(pdev, buffer_info->dma)) {

   307

			dev_err(&pdev->dev, "RX DMA map failed\n");

   308

			adapter->rx_dma_failed++;

   309

			/* cleanup skb */

   310

			dev_kfree_skb_any(skb);

   311

			buffer_info->skb = NULL;

   312

			break;

   313

		}

   314

   315

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

   316

   317

		i++;

   318

		if (i == rx_ring->count)

   319

			i = 0;

   320

		buffer_info = &rx_ring->buffer_info[i];

   321

	}

   322

   323

no_buffers:

   324

	if (rx_ring->next_to_use != i) {

   325

		rx_ring->next_to_use = i;

   326

   327

		if (!(i--))

   328

			i = (rx_ring->count - 1);

   329

   330

		/*

   331

		 * Force memory writes to complete before letting h/w

   332

		 * know there are new descriptors to fetch.  (Only

   333

		 * applicable for weak-ordered memory model archs,

   334

		 * such as IA-64).

   335

		 */

   336

		wmb();

   337

		/*

   338

		 * Hardware increments by 16 bytes, but packet split

   339

		 * descriptors are 32 bytes...so we increment tail

   340

		 * twice as much.

   341

		 */

   342

		writel(i<<1, adapter->hw.hw_addr + rx_ring->tail);

   343

	}

   344

}

   345

   346

/**

   347

 * e1000_alloc_jumbo_rx_buffers - Replace used jumbo receive buffers

   348

 * @adapter: address of board private structure

   349

 * @cleaned_count: number of buffers to allocate this pass

   350

 **/

   351

   352

static void e1000_alloc_jumbo_rx_buffers(struct e1000_adapter *adapter,

   353

                                         int cleaned_count)

   354

{

   355

	struct net_device *netdev = adapter->netdev;

   356

	struct pci_dev *pdev = adapter->pdev;

   357

	struct e1000_rx_desc *rx_desc;

   358

	struct e1000_ring *rx_ring = adapter->rx_ring;

   359

	struct e1000_buffer *buffer_info;

   360

	struct sk_buff *skb;

   361

	unsigned int i;

   362

	unsigned int bufsz = 256 -

   363

	                     16 /* for skb_reserve */ -

   364

	                     NET_IP_ALIGN;

   365

   366

	i = rx_ring->next_to_use;

   367

	buffer_info = &rx_ring->buffer_info[i];

   368

   369

	while (cleaned_count--) {

   370

		skb = buffer_info->skb;

   371

		if (skb) {

   372

			skb_trim(skb, 0);

   373

			goto check_page;

   374

		}

   375

   376

		skb = netdev_alloc_skb(netdev, bufsz);

   377

		if (unlikely(!skb)) {

   378

			/* Better luck next round */

   379

			adapter->alloc_rx_buff_failed++;

   380

			break;

   381

		}

   382

   383

		/* Make buffer alignment 2 beyond a 16 byte boundary

   384

		 * this will result in a 16 byte aligned IP header after

   385

		 * the 14 byte MAC header is removed

   386

		 */

   387

		skb_reserve(skb, NET_IP_ALIGN);

   388

   389

		buffer_info->skb = skb;

   390

check_page:

   391

		/* allocate a new page if necessary */

   392

		if (!buffer_info->page) {

   393

			buffer_info->page = alloc_page(GFP_ATOMIC);

   394

			if (unlikely(!buffer_info->page)) {

   395

				adapter->alloc_rx_buff_failed++;

   396

				break;

   397

			}

   398

		}

   399

   400

		if (!buffer_info->dma)

   401

			buffer_info->dma = pci_map_page(pdev,

   402

			                                buffer_info->page, 0,

   403

			                                PAGE_SIZE,

   404

			                                PCI_DMA_FROMDEVICE);

   405

   406

		rx_desc = E1000_RX_DESC(*rx_ring, i);

   407

		rx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);

   408

   409

		if (unlikely(++i == rx_ring->count))

   410

			i = 0;

   411

		buffer_info = &rx_ring->buffer_info[i];

   412

	}

   413

   414

	if (likely(rx_ring->next_to_use != i)) {

   415

		rx_ring->next_to_use = i;

   416

		if (unlikely(i-- == 0))

   417

			i = (rx_ring->count - 1);

   418

   419

		/* Force memory writes to complete before letting h/w

   420

		 * know there are new descriptors to fetch.  (Only

   421

		 * applicable for weak-ordered memory model archs,

   422

		 * such as IA-64). */

   423

		wmb();

   424

		writel(i, adapter->hw.hw_addr + rx_ring->tail);

   425

	}

   426

}

   427

   428

/**

   429

 * e1000_clean_rx_irq - Send received data up the network stack; legacy

   430

 * @adapter: board private structure

   431

 *

   432

 * the return value indicates whether actual cleaning was done, there

   433

 * is no guarantee that everything was cleaned

   434

 **/

   435

static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,

   436

			       int *work_done, int work_to_do)

   437

{

   438

	struct net_device *netdev = adapter->netdev;

   439

	struct pci_dev *pdev = adapter->pdev;

   440

	struct e1000_ring *rx_ring = adapter->rx_ring;

   441

	struct e1000_rx_desc *rx_desc, *next_rxd;

   442

	struct e1000_buffer *buffer_info, *next_buffer;

   443

	u32 length;

   444

	unsigned int i;

   445

	int cleaned_count = 0;

   446

	bool cleaned = 0;

   447

	unsigned int total_rx_bytes = 0, total_rx_packets = 0;

   448

   449

	i = rx_ring->next_to_clean;

   450

	rx_desc = E1000_RX_DESC(*rx_ring, i);

   451

	buffer_info = &rx_ring->buffer_info[i];

   452

   453

	while (rx_desc->status & E1000_RXD_STAT_DD) {

   454

		struct sk_buff *skb;

   455

		u8 status;

   456

   457

		if (*work_done >= work_to_do)

   458

			break;

   459

		(*work_done)++;

   460

   461

		status = rx_desc->status;

   462

		skb = buffer_info->skb;

   463

		buffer_info->skb = NULL;

   464

   465

		prefetch(skb->data - NET_IP_ALIGN);

   466

   467

		i++;

   468

		if (i == rx_ring->count)

   469

			i = 0;

   470

		next_rxd = E1000_RX_DESC(*rx_ring, i);

   471

		prefetch(next_rxd);

   472

   473

		next_buffer = &rx_ring->buffer_info[i];

   474

   475

		cleaned = 1;

   476

		cleaned_count++;

   477

		pci_unmap_single(pdev,

   478

				 buffer_info->dma,

   479

				 adapter->rx_buffer_len,

   480

				 PCI_DMA_FROMDEVICE);

   481

		buffer_info->dma = 0;

   482

   483

		length = le16_to_cpu(rx_desc->length);

   484

   485

		/*

   486

		 * !EOP means multiple descriptors were used to store a single

   487

		 * packet, if that's the case we need to toss it.  In fact, we

   488

		 * need to toss every packet with the EOP bit clear and the

   489

		 * next frame that _does_ have the EOP bit set, as it is by

   490

		 * definition only a frame fragment

   491

		 */

   492

		if (unlikely(!(status & E1000_RXD_STAT_EOP)))

   493

			adapter->flags2 |= FLAG2_IS_DISCARDING;

   494

   495

		if (adapter->flags2 & FLAG2_IS_DISCARDING) {

   496

			/* All receives must fit into a single buffer */

   497

			e_dbg("%s: Receive packet consumed multiple buffers\n",

   498

			      netdev->name);

   499

			/* recycle */

   500

			buffer_info->skb = skb;

   501

			if (status & E1000_RXD_STAT_EOP)

   502

				adapter->flags2 &= ~FLAG2_IS_DISCARDING;

   503

			goto next_desc;

   504

		}

   505

   506

		if (rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK) {

   507

			/* recycle */

   508

			buffer_info->skb = skb;

   509

			goto next_desc;

   510

		}

   511

   512

		/* adjust length to remove Ethernet CRC */

   513

		if (!(adapter->flags2 & FLAG2_CRC_STRIPPING))

   514

			length -= 4;

   515

   516

		total_rx_bytes += length;

   517

		total_rx_packets++;

   518

   519

		/*

   520

		 * code added for copybreak, this should improve

   521

		 * performance for small packets with large amounts

   522

		 * of reassembly being done in the stack

   523

		 */

   524

		if (length < copybreak) {

   525

			struct sk_buff *new_skb =

   526

			    netdev_alloc_skb(netdev, length + NET_IP_ALIGN);

   527

			if (new_skb) {

   528

				skb_reserve(new_skb, NET_IP_ALIGN);

   529

				skb_copy_to_linear_data_offset(new_skb,

   530

							       -NET_IP_ALIGN,