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

#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 <net/checksum.h>

    42

#include <net/ip6_checksum.h>

    43

#include <linux/mii.h>

    44

#include <linux/ethtool.h>

    45

#include <linux/if_vlan.h>

    46

#include <linux/cpu.h>

    47

#include <linux/smp.h>

    48

#include <linux/pm_qos_params.h>

    49

#include <linux/aer.h>

    50

    51

#include "e1000-2.6.33-ethercat.h"

    52

    53

#define DRV_VERSION "1.0.2-k2"

    54

char e1000e_driver_name[] = "ec_e1000e";

    55

const char e1000e_driver_version[] = DRV_VERSION;

    56

    57

static const struct e1000_info *e1000_info_tbl[] = {

    58

	[board_82571]		= &e1000_82571_info,

    59

	[board_82572]		= &e1000_82572_info,

    60

	[board_82573]		= &e1000_82573_info,

    61

	[board_82574]		= &e1000_82574_info,

    62

	[board_82583]		= &e1000_82583_info,

    63

	[board_80003es2lan]	= &e1000_es2_info,

    64

	[board_ich8lan]		= &e1000_ich8_info,

    65

	[board_ich9lan]		= &e1000_ich9_info,

    66

	[board_ich10lan]	= &e1000_ich10_info,

    67

	[board_pchlan]		= &e1000_pch_info,

    68

};

    69

    70

/**

    71

 * e1000_desc_unused - calculate if we have unused descriptors

    72

 **/

    73

static int e1000_desc_unused(struct e1000_ring *ring)

    74

{

    75

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

    76

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

    77

    78

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

    79

}

    80

    81

/**

    82

 * e1000_receive_skb - helper function to handle Rx indications

    83

 * @adapter: board private structure

    84

 * @status: descriptor status field as written by hardware

    85

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

    86

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

    87

 **/

    88

static void e1000_receive_skb(struct e1000_adapter *adapter,

    89

			      struct net_device *netdev,

    90

			      struct sk_buff *skb,

    91

			      u8 status, __le16 vlan)

    92

{

    93

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

    94

    95

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

    96

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

    97

				 le16_to_cpu(vlan), skb);

    98

	else

    99

		napi_gro_receive(&adapter->napi, skb);

   100

}

   101

   102

/**

   103

 * e1000_rx_checksum - Receive Checksum Offload for 82543

   104

 * @adapter:     board private structure

   105

 * @status_err:  receive descriptor status and error fields

   106

 * @csum:	receive descriptor csum field

   107

 * @sk_buff:     socket buffer with received data

   108

 **/

   109

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

   110

			      u32 csum, struct sk_buff *skb)

   111

{

   112

	u16 status = (u16)status_err;

   113

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

   114

	skb->ip_summed = CHECKSUM_NONE;

   115

   116

	/* Ignore Checksum bit is set */

   117

	if (status & E1000_RXD_STAT_IXSM)

   118

		return;

   119

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

   120

	if (errors & E1000_RXD_ERR_TCPE) {

   121

		/* let the stack verify checksum errors */

   122

		adapter->hw_csum_err++;

   123

		return;

   124

	}

   125

   126

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

   127

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

   128

		return;

   129

   130

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

   131

	if (status & E1000_RXD_STAT_TCPCS) {

   132

		/* TCP checksum is good */

   133

		skb->ip_summed = CHECKSUM_UNNECESSARY;

   134

	} else {

   135

		/*

   136

		 * IP fragment with UDP payload

   137

		 * Hardware complements the payload checksum, so we undo it

   138

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

   139

		 */

   140

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

   141

		skb->csum = csum_unfold(~sum);

   142

		skb->ip_summed = CHECKSUM_COMPLETE;

   143

	}

   144

	adapter->hw_csum_good++;

   145

}

   146

   147

/**

   148

 * e1000_alloc_rx_buffers - Replace used receive buffers; legacy & extended

   149

 * @adapter: address of board private structure

   150

 **/

   151

static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,

   152

				   int cleaned_count)

   153

{

   154

	struct net_device *netdev = adapter->netdev;

   155

	struct pci_dev *pdev = adapter->pdev;

   156

	struct e1000_ring *rx_ring = adapter->rx_ring;

   157

	struct e1000_rx_desc *rx_desc;

   158

	struct e1000_buffer *buffer_info;

   159

	struct sk_buff *skb;

   160

	unsigned int i;

   161

	unsigned int bufsz = adapter->rx_buffer_len;

   162

   163

	i = rx_ring->next_to_use;

   164

	buffer_info = &rx_ring->buffer_info[i];

   165

   166

	while (cleaned_count--) {

   167

		skb = buffer_info->skb;

   168

		if (skb) {

   169

			skb_trim(skb, 0);

   170

			goto map_skb;

   171

		}

   172

   173

		skb = netdev_alloc_skb_ip_align(netdev, bufsz);

   174

		if (!skb) {

   175

			/* Better luck next round */

   176

			adapter->alloc_rx_buff_failed++;

   177

			break;

   178

		}

   179

   180

		buffer_info->skb = skb;

   181

map_skb:

   182

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

   183

						  adapter->rx_buffer_len,

   184

						  PCI_DMA_FROMDEVICE);

   185

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

   186

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

   187

			adapter->rx_dma_failed++;

   188

			break;

   189

		}

   190

   191

		rx_desc = E1000_RX_DESC(*rx_ring, i);

   192

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

   193

   194

		i++;

   195

		if (i == rx_ring->count)

   196

			i = 0;

   197

		buffer_info = &rx_ring->buffer_info[i];

   198

	}

   199

   200

	if (rx_ring->next_to_use != i) {

   201

		rx_ring->next_to_use = i;

   202

		if (i-- == 0)

   203

			i = (rx_ring->count - 1);

   204

   205

		/*

   206

		 * Force memory writes to complete before letting h/w

   207

		 * know there are new descriptors to fetch.  (Only

   208

		 * applicable for weak-ordered memory model archs,

   209

		 * such as IA-64).

   210

		 */

   211

		wmb();

   212

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

   213

	}

   214

}

   215

   216

/**

   217

 * e1000_alloc_rx_buffers_ps - Replace used receive buffers; packet split

   218

 * @adapter: address of board private structure

   219

 **/

   220

static void e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter,

   221

				      int cleaned_count)

   222

{

   223

	struct net_device *netdev = adapter->netdev;

   224

	struct pci_dev *pdev = adapter->pdev;

   225

	union e1000_rx_desc_packet_split *rx_desc;

   226

	struct e1000_ring *rx_ring = adapter->rx_ring;

   227

	struct e1000_buffer *buffer_info;

   228

	struct e1000_ps_page *ps_page;

   229

	struct sk_buff *skb;

   230

	unsigned int i, j;

   231

   232

	i = rx_ring->next_to_use;

   233

	buffer_info = &rx_ring->buffer_info[i];

   234

   235

	while (cleaned_count--) {

   236

		rx_desc = E1000_RX_DESC_PS(*rx_ring, i);

   237

   238

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

   239

			ps_page = &buffer_info->ps_pages[j];

   240

			if (j >= adapter->rx_ps_pages) {

   241

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

   242

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

   243

				continue;

   244

			}

   245

			if (!ps_page->page) {

   246

				ps_page->page = alloc_page(GFP_ATOMIC);

   247

				if (!ps_page->page) {

   248

					adapter->alloc_rx_buff_failed++;

   249

					goto no_buffers;

   250

				}

   251

				ps_page->dma = pci_map_page(pdev,

   252

						   ps_page->page,

   253

						   0, PAGE_SIZE,

   254

						   PCI_DMA_FROMDEVICE);

   255

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

   256

					dev_err(&adapter->pdev->dev,

   257

					  "RX DMA page map failed\n");

   258

					adapter->rx_dma_failed++;

   259

					goto no_buffers;

   260

				}

   261

			}

   262

			/*

   263

			 * Refresh the desc even if buffer_addrs

   264

			 * didn't change because each write-back

   265

			 * erases this info.

   266

			 */

   267

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

   268

			     cpu_to_le64(ps_page->dma);

   269

		}

   270

   271

		skb = netdev_alloc_skb_ip_align(netdev,

   272

						adapter->rx_ps_bsize0);

   273

   274

		if (!skb) {

   275

			adapter->alloc_rx_buff_failed++;

   276

			break;

   277

		}

   278

   279

		buffer_info->skb = skb;

   280

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

   281

						  adapter->rx_ps_bsize0,

   282

						  PCI_DMA_FROMDEVICE);

   283

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

   284

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

   285

			adapter->rx_dma_failed++;

   286

			/* cleanup skb */

   287

			dev_kfree_skb_any(skb);

   288

			buffer_info->skb = NULL;

   289

			break;

   290

		}

   291

   292

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

   293

   294

		i++;

   295

		if (i == rx_ring->count)

   296

			i = 0;

   297

		buffer_info = &rx_ring->buffer_info[i];

   298

	}

   299

   300

no_buffers:

   301

	if (rx_ring->next_to_use != i) {

   302

		rx_ring->next_to_use = i;

   303

   304

		if (!(i--))

   305

			i = (rx_ring->count - 1);

   306

   307

		/*

   308

		 * Force memory writes to complete before letting h/w

   309

		 * know there are new descriptors to fetch.  (Only

   310

		 * applicable for weak-ordered memory model archs,

   311

		 * such as IA-64).

   312

		 */

   313

		wmb();

   314

		/*

   315

		 * Hardware increments by 16 bytes, but packet split

   316

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

   317

		 * twice as much.

   318

		 */

   319

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

   320

	}

   321

}

   322

   323

/**

   324

 * e1000_alloc_jumbo_rx_buffers - Replace used jumbo receive buffers

   325

 * @adapter: address of board private structure

   326

 * @cleaned_count: number of buffers to allocate this pass

   327

 **/

   328

   329

static void e1000_alloc_jumbo_rx_buffers(struct e1000_adapter *adapter,

   330

                                         int cleaned_count)

   331

{

   332

	struct net_device *netdev = adapter->netdev;

   333

	struct pci_dev *pdev = adapter->pdev;

   334

	struct e1000_rx_desc *rx_desc;

   335

	struct e1000_ring *rx_ring = adapter->rx_ring;

   336

	struct e1000_buffer *buffer_info;

   337

	struct sk_buff *skb;

   338

	unsigned int i;

   339

	unsigned int bufsz = 256 - 16 /* for skb_reserve */;

   340

   341

	i = rx_ring->next_to_use;

   342

	buffer_info = &rx_ring->buffer_info[i];

   343

   344

	while (cleaned_count--) {

   345

		skb = buffer_info->skb;

   346

		if (skb) {

   347

			skb_trim(skb, 0);

   348

			goto check_page;

   349

		}

   350

   351

		skb = netdev_alloc_skb_ip_align(netdev, bufsz);

   352

		if (unlikely(!skb)) {

   353

			/* Better luck next round */

   354

			adapter->alloc_rx_buff_failed++;

   355

			break;

   356

		}

   357

   358

		buffer_info->skb = skb;

   359

check_page:

   360

		/* allocate a new page if necessary */

   361

		if (!buffer_info->page) {

   362

			buffer_info->page = alloc_page(GFP_ATOMIC);

   363

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

   364

				adapter->alloc_rx_buff_failed++;

   365

				break;

   366

			}

   367

		}

   368

   369

		if (!buffer_info->dma)

   370

			buffer_info->dma = pci_map_page(pdev,

   371

			                                buffer_info->page, 0,

   372

			                                PAGE_SIZE,

   373

			                                PCI_DMA_FROMDEVICE);

   374

   375

		rx_desc = E1000_RX_DESC(*rx_ring, i);

   376

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

   377

   378

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

   379

			i = 0;

   380

		buffer_info = &rx_ring->buffer_info[i];

   381

	}

   382

   383

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

   384

		rx_ring->next_to_use = i;

   385

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

   386

			i = (rx_ring->count - 1);

   387

   388

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

   389

		 * know there are new descriptors to fetch.  (Only

   390

		 * applicable for weak-ordered memory model archs,

   391

		 * such as IA-64). */

   392

		wmb();

   393

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

   394

	}

   395

}

   396

   397

/**

   398

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

   399

 * @adapter: board private structure

   400

 *

   401

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

   402

 * is no guarantee that everything was cleaned

   403

 **/

   404

static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,

   405

			       int *work_done, int work_to_do)

   406

{

   407

	struct net_device *netdev = adapter->netdev;

   408

	struct pci_dev *pdev = adapter->pdev;

   409

	struct e1000_hw *hw = &adapter->hw;

   410

	struct e1000_ring *rx_ring = adapter->rx_ring;

   411

	struct e1000_rx_desc *rx_desc, *next_rxd;

   412

	struct e1000_buffer *buffer_info, *next_buffer;

   413

	u32 length;

   414

	unsigned int i;

   415

	int cleaned_count = 0;

   416

	bool cleaned = 0;

   417

	unsigned int total_rx_bytes = 0, total_rx_packets = 0;

   418

   419

	i = rx_ring->next_to_clean;

   420

	rx_desc = E1000_RX_DESC(*rx_ring, i);

   421

	buffer_info = &rx_ring->buffer_info[i];

   422

   423

	while (rx_desc->status & E1000_RXD_STAT_DD) {

   424

		struct sk_buff *skb;

   425

		u8 status;

   426

   427

		if (*work_done >= work_to_do)

   428

			break;

   429

		(*work_done)++;

   430

   431

		status = rx_desc->status;

   432

		skb = buffer_info->skb;

   433

   434

		if (!adapter->ecdev)

   435

			buffer_info->skb = NULL;

   436

   437

		prefetch(skb->data - NET_IP_ALIGN);

   438

   439

		i++;

   440

		if (i == rx_ring->count)

   441

			i = 0;

   442

		next_rxd = E1000_RX_DESC(*rx_ring, i);

   443

		prefetch(next_rxd);

   444

   445

		next_buffer = &rx_ring->buffer_info[i];

   446

   447

		cleaned = 1;

   448

		cleaned_count++;

   449

		pci_unmap_single(pdev,

   450

				 buffer_info->dma,

   451

				 adapter->rx_buffer_len,

   452

				 PCI_DMA_FROMDEVICE);

   453

		buffer_info->dma = 0;

   454

   455

		length = le16_to_cpu(rx_desc->length);

   456

   457

		/*

   458

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

   459

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

   460

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

   461

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

   462

		 * definition only a frame fragment

   463

		 */

   464

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

   465

			adapter->flags2 |= FLAG2_IS_DISCARDING;

   466

   467

		if (adapter->flags2 & FLAG2_IS_DISCARDING) {

   468

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

   469

			e_dbg("Receive packet consumed multiple buffers\n");

   470

			/* recycle */

   471

			buffer_info->skb = skb;

   472

			if (status & E1000_RXD_STAT_EOP)

   473

				adapter->flags2 &= ~FLAG2_IS_DISCARDING;

   474

			goto next_desc;

   475

		}

   476

   477

		if (!adapter->ecdev && (rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK)) {

   478

			/* recycle */

   479

			buffer_info->skb = skb;

   480

			goto next_desc;

   481

		}

   482

   483

		/* adjust length to remove Ethernet CRC */

   484

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

   485

			length -= 4;

   486

   487

		total_rx_bytes += length;

   488

		total_rx_packets++;

   489

   490

		/*

   491

		 * code added for copybreak, this should improve

   492

		 * performance for small packets with large amounts

   493

		 * of reassembly being done in the stack

   494

		 */

   495

		if (!adapter->ecdev && length < copybreak) {

   496

			struct sk_buff *new_skb =

   497

			    netdev_alloc_skb_ip_align(netdev, length);

   498

			if (new_skb) {

   499

				skb_copy_to_linear_data_offset(new_skb,

   500

							       -NET_IP_ALIGN,

   501

							       (skb->data -

   502

								NET_IP_ALIGN),

   503

							       (length +

   504

								NET_IP_ALIGN));

   505

				/* save the skb in buffer_info as good */

   506

				buffer_info->skb = skb;

   507

				skb = new_skb;

   508

			}

   509

			/* else just continue with the old one */

   510

		}

   511

		/* end copybreak code */

   512

		skb_put(skb, length);

   513

   514

		/* Receive Checksum Offload */

   515

		e1000_rx_checksum(adapter,

   516

				  (u32)(status) |

   517

				  ((u32)(rx_desc->errors) << 24),

   518

				  le16_to_cpu(rx_desc->csum), skb);

   519

   520

		if (adapter->ecdev) {

   521

			ecdev_receive(adapter->ecdev, skb->data, length);

   522

			adapter->ec_watchdog_jiffies = jiffies;

   523

		} else {

   524

			e1000_receive_skb(adapter, netdev, skb,status,rx_desc->special);

   525

		}

   526

   527

next_desc:

   528

		rx_desc->status = 0;

   529

   530

		/* return some buffers to hardware, one at a time is too slow */