1

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

     2

     3

  Intel PRO/1000 Linux driver

     4

  Copyright(c) 1999 - 2006 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 "e1000.h"

    30

#include <net/ip6_checksum.h>

    31

    32

char e1000_driver_name[] = "e1000";

    33

static char e1000_driver_string[] = "Intel(R) PRO/1000 Network Driver";

    34

#define DRV_VERSION "7.3.21-k5-NAPI"

    35

const char e1000_driver_version[] = DRV_VERSION;

    36

static const char e1000_copyright[] = "Copyright (c) 1999-2006 Intel Corporation.";

    37

    38

/* e1000_pci_tbl - PCI Device ID Table

    39

 *

    40

 * Last entry must be all 0s

    41

 *

    42

 * Macro expands to...

    43

 *   {PCI_DEVICE(PCI_VENDOR_ID_INTEL, device_id)}

    44

 */

    45

static struct pci_device_id e1000_pci_tbl[] = {

    46

	INTEL_E1000_ETHERNET_DEVICE(0x1000),

    47

	INTEL_E1000_ETHERNET_DEVICE(0x1001),

    48

	INTEL_E1000_ETHERNET_DEVICE(0x1004),

    49

	INTEL_E1000_ETHERNET_DEVICE(0x1008),

    50

	INTEL_E1000_ETHERNET_DEVICE(0x1009),

    51

	INTEL_E1000_ETHERNET_DEVICE(0x100C),

    52

	INTEL_E1000_ETHERNET_DEVICE(0x100D),

    53

	INTEL_E1000_ETHERNET_DEVICE(0x100E),

    54

	INTEL_E1000_ETHERNET_DEVICE(0x100F),

    55

	INTEL_E1000_ETHERNET_DEVICE(0x1010),

    56

	INTEL_E1000_ETHERNET_DEVICE(0x1011),

    57

	INTEL_E1000_ETHERNET_DEVICE(0x1012),

    58

	INTEL_E1000_ETHERNET_DEVICE(0x1013),

    59

	INTEL_E1000_ETHERNET_DEVICE(0x1014),

    60

	INTEL_E1000_ETHERNET_DEVICE(0x1015),

    61

	INTEL_E1000_ETHERNET_DEVICE(0x1016),

    62

	INTEL_E1000_ETHERNET_DEVICE(0x1017),

    63

	INTEL_E1000_ETHERNET_DEVICE(0x1018),

    64

	INTEL_E1000_ETHERNET_DEVICE(0x1019),

    65

	INTEL_E1000_ETHERNET_DEVICE(0x101A),

    66

	INTEL_E1000_ETHERNET_DEVICE(0x101D),

    67

	INTEL_E1000_ETHERNET_DEVICE(0x101E),

    68

	INTEL_E1000_ETHERNET_DEVICE(0x1026),

    69

	INTEL_E1000_ETHERNET_DEVICE(0x1027),

    70

	INTEL_E1000_ETHERNET_DEVICE(0x1028),

    71

	INTEL_E1000_ETHERNET_DEVICE(0x1075),

    72

	INTEL_E1000_ETHERNET_DEVICE(0x1076),

    73

	INTEL_E1000_ETHERNET_DEVICE(0x1077),

    74

	INTEL_E1000_ETHERNET_DEVICE(0x1078),

    75

	INTEL_E1000_ETHERNET_DEVICE(0x1079),

    76

	INTEL_E1000_ETHERNET_DEVICE(0x107A),

    77

	INTEL_E1000_ETHERNET_DEVICE(0x107B),

    78

	INTEL_E1000_ETHERNET_DEVICE(0x107C),

    79

	INTEL_E1000_ETHERNET_DEVICE(0x108A),

    80

	INTEL_E1000_ETHERNET_DEVICE(0x1099),

    81

	INTEL_E1000_ETHERNET_DEVICE(0x10B5),

    82

	/* required last entry */

    83

	{0,}

    84

};

    85

    86

MODULE_DEVICE_TABLE(pci, e1000_pci_tbl);

    87

    88

int e1000_up(struct e1000_adapter *adapter);

    89

void e1000_down(struct e1000_adapter *adapter);

    90

void e1000_reinit_locked(struct e1000_adapter *adapter);

    91

void e1000_reset(struct e1000_adapter *adapter);

    92

int e1000_set_spd_dplx(struct e1000_adapter *adapter, u16 spddplx);

    93

int e1000_setup_all_tx_resources(struct e1000_adapter *adapter);

    94

int e1000_setup_all_rx_resources(struct e1000_adapter *adapter);

    95

void e1000_free_all_tx_resources(struct e1000_adapter *adapter);

    96

void e1000_free_all_rx_resources(struct e1000_adapter *adapter);

    97

static int e1000_setup_tx_resources(struct e1000_adapter *adapter,

    98

                             struct e1000_tx_ring *txdr);

    99

static int e1000_setup_rx_resources(struct e1000_adapter *adapter,

   100

                             struct e1000_rx_ring *rxdr);

   101

static void e1000_free_tx_resources(struct e1000_adapter *adapter,

   102

                             struct e1000_tx_ring *tx_ring);

   103

static void e1000_free_rx_resources(struct e1000_adapter *adapter,

   104

                             struct e1000_rx_ring *rx_ring);

   105

void e1000_update_stats(struct e1000_adapter *adapter);

   106

   107

static int e1000_init_module(void);

   108

static void e1000_exit_module(void);

   109

static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent);

   110

static void __devexit e1000_remove(struct pci_dev *pdev);

   111

static int e1000_alloc_queues(struct e1000_adapter *adapter);

   112

static int e1000_sw_init(struct e1000_adapter *adapter);

   113

static int e1000_open(struct net_device *netdev);

   114

static int e1000_close(struct net_device *netdev);

   115

static void e1000_configure_tx(struct e1000_adapter *adapter);

   116

static void e1000_configure_rx(struct e1000_adapter *adapter);

   117

static void e1000_setup_rctl(struct e1000_adapter *adapter);

   118

static void e1000_clean_all_tx_rings(struct e1000_adapter *adapter);

   119

static void e1000_clean_all_rx_rings(struct e1000_adapter *adapter);

   120

static void e1000_clean_tx_ring(struct e1000_adapter *adapter,

   121

                                struct e1000_tx_ring *tx_ring);

   122

static void e1000_clean_rx_ring(struct e1000_adapter *adapter,

   123

                                struct e1000_rx_ring *rx_ring);

   124

static void e1000_set_rx_mode(struct net_device *netdev);

   125

static void e1000_update_phy_info(unsigned long data);

   126

static void e1000_watchdog(unsigned long data);

   127

static void e1000_82547_tx_fifo_stall(unsigned long data);

   128

static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,

   129

				    struct net_device *netdev);

   130

static struct net_device_stats * e1000_get_stats(struct net_device *netdev);

   131

static int e1000_change_mtu(struct net_device *netdev, int new_mtu);

   132

static int e1000_set_mac(struct net_device *netdev, void *p);

   133

static irqreturn_t e1000_intr(int irq, void *data);

   134

static bool e1000_clean_tx_irq(struct e1000_adapter *adapter,

   135

			       struct e1000_tx_ring *tx_ring);

   136

static int e1000_clean(struct napi_struct *napi, int budget);

   137

static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,

   138

			       struct e1000_rx_ring *rx_ring,

   139

			       int *work_done, int work_to_do);

   140

static bool e1000_clean_jumbo_rx_irq(struct e1000_adapter *adapter,

   141

				     struct e1000_rx_ring *rx_ring,

   142

				     int *work_done, int work_to_do);

   143

static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,

   144

				   struct e1000_rx_ring *rx_ring,

   145

				   int cleaned_count);

   146

static void e1000_alloc_jumbo_rx_buffers(struct e1000_adapter *adapter,

   147

					 struct e1000_rx_ring *rx_ring,

   148

					 int cleaned_count);

   149

static int e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd);

   150

static int e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr,

   151

			   int cmd);

   152

static void e1000_enter_82542_rst(struct e1000_adapter *adapter);

   153

static void e1000_leave_82542_rst(struct e1000_adapter *adapter);

   154

static void e1000_tx_timeout(struct net_device *dev);

   155

static void e1000_reset_task(struct work_struct *work);

   156

static void e1000_smartspeed(struct e1000_adapter *adapter);

   157

static int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,

   158

                                       struct sk_buff *skb);

   159

   160

static void e1000_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp);

   161

static void e1000_vlan_rx_add_vid(struct net_device *netdev, u16 vid);

   162

static void e1000_vlan_rx_kill_vid(struct net_device *netdev, u16 vid);

   163

static void e1000_restore_vlan(struct e1000_adapter *adapter);

   164

   165

#ifdef CONFIG_PM

   166

static int e1000_suspend(struct pci_dev *pdev, pm_message_t state);

   167

static int e1000_resume(struct pci_dev *pdev);

   168

#endif

   169

static void e1000_shutdown(struct pci_dev *pdev);

   170

   171

#ifdef CONFIG_NET_POLL_CONTROLLER

   172

/* for netdump / net console */

   173

static void e1000_netpoll (struct net_device *netdev);

   174

#endif

   175

   176

#define COPYBREAK_DEFAULT 256

   177

static unsigned int copybreak __read_mostly = COPYBREAK_DEFAULT;

   178

module_param(copybreak, uint, 0644);

   179

MODULE_PARM_DESC(copybreak,

   180

	"Maximum size of packet that is copied to a new buffer on receive");

   181

   182

static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev,

   183

                     pci_channel_state_t state);

   184

static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev);

   185

static void e1000_io_resume(struct pci_dev *pdev);

   186

   187

static struct pci_error_handlers e1000_err_handler = {

   188

	.error_detected = e1000_io_error_detected,

   189

	.slot_reset = e1000_io_slot_reset,

   190

	.resume = e1000_io_resume,

   191

};

   192

   193

static struct pci_driver e1000_driver = {

   194

	.name     = e1000_driver_name,

   195

	.id_table = e1000_pci_tbl,

   196

	.probe    = e1000_probe,

   197

	.remove   = __devexit_p(e1000_remove),

   198

#ifdef CONFIG_PM

   199

	/* Power Managment Hooks */

   200

	.suspend  = e1000_suspend,

   201

	.resume   = e1000_resume,

   202

#endif

   203

	.shutdown = e1000_shutdown,

   204

	.err_handler = &e1000_err_handler

   205

};

   206

   207

MODULE_AUTHOR("Intel Corporation, <linux.nics@intel.com>");

   208

MODULE_DESCRIPTION("Intel(R) PRO/1000 Network Driver");

   209

MODULE_LICENSE("GPL");

   210

MODULE_VERSION(DRV_VERSION);

   211

   212

static int debug = NETIF_MSG_DRV | NETIF_MSG_PROBE;

   213

module_param(debug, int, 0);

   214

MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");

   215

   216

/**

   217

 * e1000_init_module - Driver Registration Routine

   218

 *

   219

 * e1000_init_module is the first routine called when the driver is

   220

 * loaded. All it does is register with the PCI subsystem.

   221

 **/

   222

   223

static int __init e1000_init_module(void)

   224

{

   225

	int ret;

   226

	printk(KERN_INFO "%s - version %s\n",

   227

	       e1000_driver_string, e1000_driver_version);

   228

   229

	printk(KERN_INFO "%s\n", e1000_copyright);

   230

   231

	ret = pci_register_driver(&e1000_driver);

   232

	if (copybreak != COPYBREAK_DEFAULT) {

   233

		if (copybreak == 0)

   234

			printk(KERN_INFO "e1000: copybreak disabled\n");

   235

		else

   236

			printk(KERN_INFO "e1000: copybreak enabled for "

   237

			       "packets <= %u bytes\n", copybreak);

   238

	}

   239

	return ret;

   240

}

   241

   242

module_init(e1000_init_module);

   243

   244

/**

   245

 * e1000_exit_module - Driver Exit Cleanup Routine

   246

 *

   247

 * e1000_exit_module is called just before the driver is removed

   248

 * from memory.

   249

 **/

   250

   251

static void __exit e1000_exit_module(void)

   252

{

   253

	pci_unregister_driver(&e1000_driver);

   254

}

   255

   256

module_exit(e1000_exit_module);

   257

   258

static int e1000_request_irq(struct e1000_adapter *adapter)

   259

{

   260

	struct net_device *netdev = adapter->netdev;

   261

	irq_handler_t handler = e1000_intr;

   262

	int irq_flags = IRQF_SHARED;

   263

	int err;

   264

   265

	err = request_irq(adapter->pdev->irq, handler, irq_flags, netdev->name,

   266

	                  netdev);

   267

	if (err) {

   268

		DPRINTK(PROBE, ERR,

   269

		        "Unable to allocate interrupt Error: %d\n", err);

   270

	}

   271

   272

	return err;

   273

}

   274

   275

static void e1000_free_irq(struct e1000_adapter *adapter)

   276

{

   277

	struct net_device *netdev = adapter->netdev;

   278

   279

	free_irq(adapter->pdev->irq, netdev);

   280

}

   281

   282

/**

   283

 * e1000_irq_disable - Mask off interrupt generation on the NIC

   284

 * @adapter: board private structure

   285

 **/

   286

   287

static void e1000_irq_disable(struct e1000_adapter *adapter)

   288

{

   289

	struct e1000_hw *hw = &adapter->hw;

   290

   291

	ew32(IMC, ~0);

   292

	E1000_WRITE_FLUSH();

   293

	synchronize_irq(adapter->pdev->irq);

   294

}

   295

   296

/**

   297

 * e1000_irq_enable - Enable default interrupt generation settings

   298

 * @adapter: board private structure

   299

 **/

   300

   301

static void e1000_irq_enable(struct e1000_adapter *adapter)

   302

{

   303

	struct e1000_hw *hw = &adapter->hw;

   304

   305

	ew32(IMS, IMS_ENABLE_MASK);

   306

	E1000_WRITE_FLUSH();

   307

}

   308

   309

static void e1000_update_mng_vlan(struct e1000_adapter *adapter)

   310

{

   311

	struct e1000_hw *hw = &adapter->hw;

   312

	struct net_device *netdev = adapter->netdev;

   313

	u16 vid = hw->mng_cookie.vlan_id;

   314

	u16 old_vid = adapter->mng_vlan_id;

   315

	if (adapter->vlgrp) {

   316

		if (!vlan_group_get_device(adapter->vlgrp, vid)) {

   317

			if (hw->mng_cookie.status &

   318

				E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) {

   319

				e1000_vlan_rx_add_vid(netdev, vid);

   320

				adapter->mng_vlan_id = vid;

   321

			} else

   322

				adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;

   323

   324

			if ((old_vid != (u16)E1000_MNG_VLAN_NONE) &&

   325

					(vid != old_vid) &&

   326

			    !vlan_group_get_device(adapter->vlgrp, old_vid))

   327

				e1000_vlan_rx_kill_vid(netdev, old_vid);

   328

		} else

   329

			adapter->mng_vlan_id = vid;

   330

	}

   331

}

   332

   333

static void e1000_init_manageability(struct e1000_adapter *adapter)

   334

{

   335

	struct e1000_hw *hw = &adapter->hw;

   336

   337

	if (adapter->en_mng_pt) {

   338

		u32 manc = er32(MANC);

   339

   340

		/* disable hardware interception of ARP */

   341

		manc &= ~(E1000_MANC_ARP_EN);

   342

   343

		ew32(MANC, manc);

   344

	}

   345

}

   346

   347

static void e1000_release_manageability(struct e1000_adapter *adapter)

   348

{

   349

	struct e1000_hw *hw = &adapter->hw;

   350

   351

	if (adapter->en_mng_pt) {

   352

		u32 manc = er32(MANC);

   353

   354

		/* re-enable hardware interception of ARP */

   355

		manc |= E1000_MANC_ARP_EN;

   356

   357

		ew32(MANC, manc);

   358

	}

   359

}

   360

   361

/**

   362

 * e1000_configure - configure the hardware for RX and TX

   363

 * @adapter = private board structure

   364

 **/

   365

static void e1000_configure(struct e1000_adapter *adapter)

   366

{

   367

	struct net_device *netdev = adapter->netdev;

   368

	int i;

   369

   370

	e1000_set_rx_mode(netdev);

   371

   372

	e1000_restore_vlan(adapter);

   373

	e1000_init_manageability(adapter);

   374

   375

	e1000_configure_tx(adapter);

   376

	e1000_setup_rctl(adapter);

   377

	e1000_configure_rx(adapter);

   378

	/* call E1000_DESC_UNUSED which always leaves

   379

	 * at least 1 descriptor unused to make sure

   380

	 * next_to_use != next_to_clean */

   381

	for (i = 0; i < adapter->num_rx_queues; i++) {

   382

		struct e1000_rx_ring *ring = &adapter->rx_ring[i];

   383

		adapter->alloc_rx_buf(adapter, ring,

   384

		                      E1000_DESC_UNUSED(ring));

   385

	}

   386

   387

	adapter->tx_queue_len = netdev->tx_queue_len;

   388

}

   389

   390

int e1000_up(struct e1000_adapter *adapter)

   391

{

   392

	struct e1000_hw *hw = &adapter->hw;

   393

   394

	/* hardware has been reset, we need to reload some things */

   395

	e1000_configure(adapter);

   396

   397

	clear_bit(__E1000_DOWN, &adapter->flags);

   398

   399

	napi_enable(&adapter->napi);

   400

   401

	e1000_irq_enable(adapter);

   402

   403

	netif_wake_queue(adapter->netdev);

   404

   405

	/* fire a link change interrupt to start the watchdog */

   406

	ew32(ICS, E1000_ICS_LSC);

   407

	return 0;

   408

}

   409

   410

/**

   411

 * e1000_power_up_phy - restore link in case the phy was powered down

   412

 * @adapter: address of board private structure

   413

 *

   414

 * The phy may be powered down to save power and turn off link when the

   415

 * driver is unloaded and wake on lan is not enabled (among others)

   416

 * *** this routine MUST be followed by a call to e1000_reset ***

   417

 *

   418

 **/

   419

   420

void e1000_power_up_phy(struct e1000_adapter *adapter)

   421

{

   422

	struct e1000_hw *hw = &adapter->hw;

   423

	u16 mii_reg = 0;

   424

   425

	/* Just clear the power down bit to wake the phy back up */

   426

	if (hw->media_type == e1000_media_type_copper) {

   427

		/* according to the manual, the phy will retain its

   428

		 * settings across a power-down/up cycle */

   429

		e1000_read_phy_reg(hw, PHY_CTRL, &mii_reg);

   430

		mii_reg &= ~MII_CR_POWER_DOWN;

   431

		e1000_write_phy_reg(hw, PHY_CTRL, mii_reg);

   432

	}

   433

}

   434

   435

static void e1000_power_down_phy(struct e1000_adapter *adapter)

   436

{

   437

	struct e1000_hw *hw = &adapter->hw;

   438

   439

	/* Power down the PHY so no link is implied when interface is down *

   440

	 * The PHY cannot be powered down if any of the following is true *

   441

	 * (a) WoL is enabled

   442

	 * (b) AMT is active

   443

	 * (c) SoL/IDER session is active */

   444

	if (!adapter->wol && hw->mac_type >= e1000_82540 &&

   445

	   hw->media_type == e1000_media_type_copper) {

   446

		u16 mii_reg = 0;

   447

   448

		switch (hw->mac_type) {

   449

		case e1000_82540:

   450

		case e1000_82545:

   451

		case e1000_82545_rev_3:

   452

		case e1000_82546:

   453

		case e1000_82546_rev_3:

   454

		case e1000_82541:

   455

		case e1000_82541_rev_2:

   456

		case e1000_82547:

   457

		case e1000_82547_rev_2:

   458

			if (er32(MANC) & E1000_MANC_SMBUS_EN)

   459

				goto out;

   460

			break;

   461

		default:

   462

			goto out;

   463

		}

   464

		e1000_read_phy_reg(hw, PHY_CTRL, &mii_reg);

   465

		mii_reg |= MII_CR_POWER_DOWN;

   466

		e1000_write_phy_reg(hw, PHY_CTRL, mii_reg);

   467

		mdelay(1);

   468

	}

   469

out:

   470

	return;

   471

}

   472

   473

void e1000_down(struct e1000_adapter *adapter)

   474

{

   475

	struct e1000_hw *hw = &adapter->hw;

   476

	struct net_device *netdev = adapter->netdev;

   477

	u32 rctl, tctl;

   478

   479

	/* signal that we're down so the interrupt handler does not

   480

	 * reschedule our watchdog timer */

   481

	set_bit(__E1000_DOWN, &adapter->flags);

   482

   483

	/* disable receives in the hardware */

   484

	rctl = er32(RCTL);

   485

	ew32(RCTL, rctl & ~E1000_RCTL_EN);

   486

	/* flush and sleep below */

   487

   488

	netif_tx_disable(netdev);

   489

   490

	/* disable transmits in the hardware */

   491

	tctl = er32(TCTL);

   492

	tctl &= ~E1000_TCTL_EN;

   493

	ew32(TCTL, tctl);

   494

	/* flush both disables and wait for them to finish */

   495

	E1000_WRITE_FLUSH();

   496

	msleep(10);

   497

   498

	napi_disable(&adapter->napi);

   499

   500

	e1000_irq_disable(adapter);

   501

   502

	del_timer_sync(&adapter->tx_fifo_stall_timer);

   503

	del_timer_sync(&adapter->watchdog_timer);

   504

	del_timer_sync(&adapter->phy_info_timer);

   505

   506

	netdev->tx_queue_len = adapter->tx_queue_len;

   507

	adapter->link_speed = 0;

   508

	adapter->link_duplex = 0;

   509

	netif_carrier_off(netdev);

   510

   511

	e1000_reset(adapter);

   512

	e1000_clean_all_tx_rings(adapter);

   513

	e1000_clean_all_rx_rings(adapter);

   514

}

   515

   516

void e1000_reinit_locked(struct e1000_adapter *adapter)

   517

{

   518

	WARN_ON(in_interrupt());

   519

	while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))

   520

		msleep(1);

   521

	e1000_down(adapter);

   522

	e1000_up(adapter);

   523

	clear_bit(__E1000_RESETTING, &adapter->flags);

   524

}

   525

   526

void e1000_reset(struct e1000_adapter *adapter)

   527

{

   528

	struct e1000_hw *hw = &adapter->hw;

   529

	u32 pba = 0, tx_space, min_tx_space, min_rx_space;

   530

	bool legacy_pba_adjust = false;