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 <linux/slab.h>

    42

#include <net/checksum.h>

    43

#include <net/ip6_checksum.h>

    44

#include <linux/mii.h>

    45

#include <linux/ethtool.h>

    46

#include <linux/if_vlan.h>

    47

#include <linux/cpu.h>

    48

#include <linux/smp.h>

    49

#include <linux/pm_qos_params.h>

    50

#include <linux/aer.h>

    51

    52

#include "e1000-2.6.34-ethercat.h"

    53

    54

#define DRV_VERSION "1.0.2-k2(ethercat)"

    55

char e1000e_driver_name[] = "ec_e1000e";

    56

const char e1000e_driver_version[] = DRV_VERSION;

    57

    58

static const struct e1000_info *e1000_info_tbl[] = {

    59

	[board_82571]		= &e1000_82571_info,

    60

	[board_82572]		= &e1000_82572_info,

    61

	[board_82573]		= &e1000_82573_info,

    62

	[board_82574]		= &e1000_82574_info,

    63

	[board_82583]		= &e1000_82583_info,

    64

	[board_80003es2lan]	= &e1000_es2_info,

    65

	[board_ich8lan]		= &e1000_ich8_info,

    66

	[board_ich9lan]		= &e1000_ich9_info,

    67

	[board_ich10lan]	= &e1000_ich10_info,

    68

	[board_pchlan]		= &e1000_pch_info,

    69

};

    70

    71

/**

    72

 * e1000_desc_unused - calculate if we have unused descriptors

    73

 **/

    74

static int e1000_desc_unused(struct e1000_ring *ring)

    75

{

    76

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

    77

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

    78

    79

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

    80

}

    81

    82

/**

    83

 * e1000_receive_skb - helper function to handle Rx indications

    84

 * @adapter: board private structure

    85

 * @status: descriptor status field as written by hardware

    86

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

    87

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

    88

 **/

    89

static void e1000_receive_skb(struct e1000_adapter *adapter,

    90

			      struct net_device *netdev,

    91

			      struct sk_buff *skb,

    92

			      u8 status, __le16 vlan)

    93

{

    94

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

    95

    96

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

    97

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

    98

				 le16_to_cpu(vlan), skb);

    99

	else

   100

		napi_gro_receive(&adapter->napi, skb);

   101

}

   102

   103

/**

   104

 * e1000_rx_checksum - Receive Checksum Offload for 82543

   105

 * @adapter:     board private structure

   106

 * @status_err:  receive descriptor status and error fields

   107

 * @csum:	receive descriptor csum field

   108

 * @sk_buff:     socket buffer with received data

   109

 **/

   110

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

   111

			      u32 csum, struct sk_buff *skb)

   112

{

   113

	u16 status = (u16)status_err;

   114

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

   115

	skb->ip_summed = CHECKSUM_NONE;

   116

   117

	/* Ignore Checksum bit is set */

   118

	if (status & E1000_RXD_STAT_IXSM)

   119

		return;

   120

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

   121

	if (errors & E1000_RXD_ERR_TCPE) {

   122

		/* let the stack verify checksum errors */

   123

		adapter->hw_csum_err++;

   124

		return;

   125

	}

   126

   127

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

   128

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

   129

		return;

   130

   131

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

   132

	if (status & E1000_RXD_STAT_TCPCS) {

   133

		/* TCP checksum is good */

   134

		skb->ip_summed = CHECKSUM_UNNECESSARY;

   135

	} else {

   136

		/*

   137

		 * IP fragment with UDP payload

   138

		 * Hardware complements the payload checksum, so we undo it

   139

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

   140

		 */

   141

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

   142

		skb->csum = csum_unfold(~sum);

   143

		skb->ip_summed = CHECKSUM_COMPLETE;

   144

	}

   145

	adapter->hw_csum_good++;

   146

}

   147

   148

/**

   149

 * e1000_alloc_rx_buffers - Replace used receive buffers; legacy & extended

   150

 * @adapter: address of board private structure

   151

 **/

   152

static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,

   153

				   int cleaned_count)

   154

{

   155

	struct net_device *netdev = adapter->netdev;

   156

	struct pci_dev *pdev = adapter->pdev;

   157

	struct e1000_ring *rx_ring = adapter->rx_ring;

   158

	struct e1000_rx_desc *rx_desc;

   159

	struct e1000_buffer *buffer_info;

   160

	struct sk_buff *skb;

   161

	unsigned int i;

   162

	unsigned int bufsz = adapter->rx_buffer_len;

   163

   164

	i = rx_ring->next_to_use;

   165

	buffer_info = &rx_ring->buffer_info[i];

   166

   167

	while (cleaned_count--) {

   168

		skb = buffer_info->skb;

   169

		if (skb) {

   170

			skb_trim(skb, 0);

   171

			goto map_skb;

   172

		}

   173

   174

		skb = netdev_alloc_skb_ip_align(netdev, bufsz);

   175

		if (!skb) {

   176

			/* Better luck next round */

   177

			adapter->alloc_rx_buff_failed++;

   178

			break;

   179

		}

   180

   181

		buffer_info->skb = skb;

   182

map_skb:

   183

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

   184

						  adapter->rx_buffer_len,

   185

						  PCI_DMA_FROMDEVICE);

   186

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

   187

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

   188

			adapter->rx_dma_failed++;

   189

			break;

   190

		}

   191

   192

		rx_desc = E1000_RX_DESC(*rx_ring, i);

   193

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

   194

   195

		i++;

   196

		if (i == rx_ring->count)

   197

			i = 0;

   198

		buffer_info = &rx_ring->buffer_info[i];

   199

	}

   200

   201

	if (rx_ring->next_to_use != i) {

   202

		rx_ring->next_to_use = i;

   203

		if (i-- == 0)

   204

			i = (rx_ring->count - 1);

   205

   206

		/*

   207

		 * Force memory writes to complete before letting h/w

   208

		 * know there are new descriptors to fetch.  (Only

   209

		 * applicable for weak-ordered memory model archs,

   210

		 * such as IA-64).

   211

		 */

   212

		wmb();

   213

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

   214

	}

   215

}

   216

   217

/**

   218

 * e1000_alloc_rx_buffers_ps - Replace used receive buffers; packet split

   219

 * @adapter: address of board private structure

   220

 **/

   221

static void e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter,

   222

				      int cleaned_count)

   223

{

   224

	struct net_device *netdev = adapter->netdev;

   225

	struct pci_dev *pdev = adapter->pdev;

   226

	union e1000_rx_desc_packet_split *rx_desc;

   227

	struct e1000_ring *rx_ring = adapter->rx_ring;

   228

	struct e1000_buffer *buffer_info;

   229

	struct e1000_ps_page *ps_page;

   230

	struct sk_buff *skb;

   231

	unsigned int i, j;

   232

   233

	i = rx_ring->next_to_use;

   234

	buffer_info = &rx_ring->buffer_info[i];

   235

   236

	while (cleaned_count--) {

   237

		rx_desc = E1000_RX_DESC_PS(*rx_ring, i);

   238

   239

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

   240

			ps_page = &buffer_info->ps_pages[j];

   241

			if (j >= adapter->rx_ps_pages) {

   242

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

   243

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

   244

				continue;

   245

			}

   246

			if (!ps_page->page) {

   247

				ps_page->page = alloc_page(GFP_ATOMIC);

   248

				if (!ps_page->page) {

   249

					adapter->alloc_rx_buff_failed++;

   250

					goto no_buffers;

   251

				}

   252

				ps_page->dma = pci_map_page(pdev,

   253

						   ps_page->page,

   254

						   0, PAGE_SIZE,

   255

						   PCI_DMA_FROMDEVICE);

   256

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

   257

					dev_err(&adapter->pdev->dev,

   258

					  "RX DMA page map failed\n");

   259

					adapter->rx_dma_failed++;

   260

					goto no_buffers;

   261

				}

   262

			}

   263

			/*

   264

			 * Refresh the desc even if buffer_addrs

   265

			 * didn't change because each write-back

   266

			 * erases this info.

   267

			 */

   268

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

   269

			     cpu_to_le64(ps_page->dma);

   270

		}

   271

   272

		skb = netdev_alloc_skb_ip_align(netdev,

   273

						adapter->rx_ps_bsize0);

   274

   275

		if (!skb) {

   276

			adapter->alloc_rx_buff_failed++;

   277

			break;

   278

		}

   279

   280

		buffer_info->skb = skb;

   281

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

   282

						  adapter->rx_ps_bsize0,

   283

						  PCI_DMA_FROMDEVICE);

   284

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

   285

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

   286

			adapter->rx_dma_failed++;

   287

			/* cleanup skb */

   288

			dev_kfree_skb_any(skb);

   289

			buffer_info->skb = NULL;

   290

			break;

   291

		}

   292

   293

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

   294

   295

		i++;

   296

		if (i == rx_ring->count)

   297

			i = 0;

   298

		buffer_info = &rx_ring->buffer_info[i];

   299

	}

   300

   301

no_buffers:

   302

	if (rx_ring->next_to_use != i) {

   303

		rx_ring->next_to_use = i;

   304

   305

		if (!(i--))

   306

			i = (rx_ring->count - 1);

   307

   308

		/*

   309

		 * Force memory writes to complete before letting h/w

   310

		 * know there are new descriptors to fetch.  (Only

   311

		 * applicable for weak-ordered memory model archs,

   312

		 * such as IA-64).

   313

		 */

   314

		wmb();

   315

		/*

   316

		 * Hardware increments by 16 bytes, but packet split

   317

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

   318

		 * twice as much.

   319

		 */

   320

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

   321

	}

   322

}

   323

   324

/**

   325

 * e1000_alloc_jumbo_rx_buffers - Replace used jumbo receive buffers

   326

 * @adapter: address of board private structure

   327

 * @cleaned_count: number of buffers to allocate this pass

   328

 **/

   329

   330

static void e1000_alloc_jumbo_rx_buffers(struct e1000_adapter *adapter,

   331

                                         int cleaned_count)

   332

{

   333

	struct net_device *netdev = adapter->netdev;

   334

	struct pci_dev *pdev = adapter->pdev;

   335

	struct e1000_rx_desc *rx_desc;

   336

	struct e1000_ring *rx_ring = adapter->rx_ring;

   337

	struct e1000_buffer *buffer_info;

   338

	struct sk_buff *skb;

   339

	unsigned int i;

   340

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

   341

   342

	i = rx_ring->next_to_use;

   343

	buffer_info = &rx_ring->buffer_info[i];

   344

   345

	while (cleaned_count--) {

   346

		skb = buffer_info->skb;

   347

		if (skb) {

   348

			skb_trim(skb, 0);

   349

			goto check_page;

   350

		}

   351

   352

		skb = netdev_alloc_skb_ip_align(netdev, bufsz);

   353

		if (unlikely(!skb)) {

   354

			/* Better luck next round */

   355

			adapter->alloc_rx_buff_failed++;

   356

			break;

   357

		}

   358

   359

		buffer_info->skb = skb;

   360

check_page:

   361

		/* allocate a new page if necessary */

   362

		if (!buffer_info->page) {

   363

			buffer_info->page = alloc_page(GFP_ATOMIC);

   364

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

   365

				adapter->alloc_rx_buff_failed++;

   366

				break;

   367

			}

   368

		}

   369

   370

		if (!buffer_info->dma)

   371

			buffer_info->dma = pci_map_page(pdev,

   372

			                                buffer_info->page, 0,

   373

			                                PAGE_SIZE,

   374

			                                PCI_DMA_FROMDEVICE);

   375

   376

		rx_desc = E1000_RX_DESC(*rx_ring, i);

   377

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

   378

   379

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

   380

			i = 0;

   381

		buffer_info = &rx_ring->buffer_info[i];

   382

	}

   383

   384

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

   385

		rx_ring->next_to_use = i;

   386

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

   387

			i = (rx_ring->count - 1);

   388

   389

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

   390

		 * know there are new descriptors to fetch.  (Only

   391

		 * applicable for weak-ordered memory model archs,

   392

		 * such as IA-64). */

   393

		wmb();

   394

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

   395

	}

   396

}

   397

   398

/**

   399

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

   400

 * @adapter: board private structure

   401

 *

   402

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

   403

 * is no guarantee that everything was cleaned

   404

 **/

   405

static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,

   406

			       int *work_done, int work_to_do)

   407

{

   408

	struct net_device *netdev = adapter->netdev;

   409

	struct pci_dev *pdev = adapter->pdev;

   410

	struct e1000_hw *hw = &adapter->hw;

   411

	struct e1000_ring *rx_ring = adapter->rx_ring;

   412

	struct e1000_rx_desc *rx_desc, *next_rxd;

   413

	struct e1000_buffer *buffer_info, *next_buffer;

   414

	u32 length;

   415

	unsigned int i;

   416

	int cleaned_count = 0;

   417

	bool cleaned = 0;

   418

	unsigned int total_rx_bytes = 0, total_rx_packets = 0;

   419

   420

	i = rx_ring->next_to_clean;

   421

	rx_desc = E1000_RX_DESC(*rx_ring, i);

   422

	buffer_info = &rx_ring->buffer_info[i];

   423

   424

	while (rx_desc->status & E1000_RXD_STAT_DD) {

   425

		struct sk_buff *skb;

   426

		u8 status;

   427

   428

		if (*work_done >= work_to_do)

   429

			break;

   430

		(*work_done)++;

   431

   432

		status = rx_desc->status;

   433

		skb = buffer_info->skb;

   434

   435

		if (!adapter->ecdev)

   436

			buffer_info->skb = NULL;

   437

   438

		prefetch(skb->data - NET_IP_ALIGN);

   439

   440

		i++;

   441

		if (i == rx_ring->count)

   442

			i = 0;

   443

		next_rxd = E1000_RX_DESC(*rx_ring, i);

   444

		prefetch(next_rxd);

   445

   446

		next_buffer = &rx_ring->buffer_info[i];

   447

   448

		cleaned = 1;

   449

		cleaned_count++;

   450

		pci_unmap_single(pdev,

   451

				 buffer_info->dma,

   452

				 adapter->rx_buffer_len,

   453

				 PCI_DMA_FROMDEVICE);

   454

		buffer_info->dma = 0;

   455

   456

		length = le16_to_cpu(rx_desc->length);

   457

   458

		/*

   459

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

   460

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

   461

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

   462

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

   463

		 * definition only a frame fragment

   464

		 */

   465

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

   466

			adapter->flags2 |= FLAG2_IS_DISCARDING;

   467

   468

		if (adapter->flags2 & FLAG2_IS_DISCARDING) {

   469

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

   470

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

   471

			/* recycle */

   472

			buffer_info->skb = skb;

   473

			if (status & E1000_RXD_STAT_EOP)

   474

				adapter->flags2 &= ~FLAG2_IS_DISCARDING;

   475

			goto next_desc;

   476

		}

   477

   478

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

   479

			/* recycle */

   480

			buffer_info->skb = skb;

   481

			goto next_desc;

   482

		}

   483

   484

		/* adjust length to remove Ethernet CRC */

   485

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

   486

			length -= 4;

   487

   488

		total_rx_bytes += length;

   489

		total_rx_packets++;

   490

   491

		/*

   492

		 * code added for copybreak, this should improve

   493

		 * performance for small packets with large amounts

   494

		 * of reassembly being done in the stack

   495

		 */

   496

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

   497

			struct sk_buff *new_skb =

   498

			    netdev_alloc_skb_ip_align(netdev, length);

   499

			if (new_skb) {

   500

				skb_copy_to_linear_data_offset(new_skb,

   501

							       -NET_IP_ALIGN,

   502

							       (skb->data -

   503

								NET_IP_ALIGN),

   504

							       (length +

   505

								NET_IP_ALIGN));

   506

				/* save the skb in buffer_info as good */

   507

				buffer_info->skb = skb;

   508

				skb = new_skb;

   509

			}

   510

			/* else just continue with the old one */

   511

		}

   512

		/* end copybreak code */

   513

		skb_put(skb, length);

   514

   515

		/* Receive Checksum Offload */

   516

		e1000_rx_checksum(adapter,

   517

				  (u32)(status) |

   518

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

   519

				  le16_to_cpu(rx_desc->csum), skb);

   520

   521

		if (adapter->ecdev) {

   522

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

   523

			adapter->ec_watchdog_jiffies = jiffies;

   524

		} else {

   525

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

   526

		}

   527

   528

next_desc:

   529

		rx_desc->status = 0;

   530