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

  vim: noexpandtab

    28

    29

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

    30

    31

#include "e1000-3.14-ethercat.h"

    32

#include <net/ip6_checksum.h>

    33

#include <linux/io.h>

    34

#include <linux/prefetch.h>

    35

#include <linux/bitops.h>

    36

#include <linux/if_vlan.h>

    37

    38

char e1000_driver_name[] = "ec_e1000";

    39

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

    40

#define DRV_VERSION "7.3.21-k8-NAPI"

    41

const char e1000_driver_version[] = DRV_VERSION;

    42

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

    43

    44

/* e1000_pci_tbl - PCI Device ID Table

    45

 *

    46

 * Last entry must be all 0s

    47

 *

    48

 * Macro expands to...

    49

 *   {PCI_DEVICE(PCI_VENDOR_ID_INTEL, device_id)}

    50

 */

    51

static DEFINE_PCI_DEVICE_TABLE(e1000_pci_tbl) = {

    52

	INTEL_E1000_ETHERNET_DEVICE(0x1000),

    53

	INTEL_E1000_ETHERNET_DEVICE(0x1001),

    54

	INTEL_E1000_ETHERNET_DEVICE(0x1004),

    55

	INTEL_E1000_ETHERNET_DEVICE(0x1008),

    56

	INTEL_E1000_ETHERNET_DEVICE(0x1009),

    57

	INTEL_E1000_ETHERNET_DEVICE(0x100C),

    58

	INTEL_E1000_ETHERNET_DEVICE(0x100D),

    59

	INTEL_E1000_ETHERNET_DEVICE(0x100E),

    60

	INTEL_E1000_ETHERNET_DEVICE(0x100F),

    61

	INTEL_E1000_ETHERNET_DEVICE(0x1010),

    62

	INTEL_E1000_ETHERNET_DEVICE(0x1011),

    63

	INTEL_E1000_ETHERNET_DEVICE(0x1012),

    64

	INTEL_E1000_ETHERNET_DEVICE(0x1013),

    65

	INTEL_E1000_ETHERNET_DEVICE(0x1014),

    66

	INTEL_E1000_ETHERNET_DEVICE(0x1015),

    67

	INTEL_E1000_ETHERNET_DEVICE(0x1016),

    68

	INTEL_E1000_ETHERNET_DEVICE(0x1017),

    69

	INTEL_E1000_ETHERNET_DEVICE(0x1018),

    70

	INTEL_E1000_ETHERNET_DEVICE(0x1019),

    71

	INTEL_E1000_ETHERNET_DEVICE(0x101A),

    72

	INTEL_E1000_ETHERNET_DEVICE(0x101D),

    73

	INTEL_E1000_ETHERNET_DEVICE(0x101E),

    74

	INTEL_E1000_ETHERNET_DEVICE(0x1026),

    75

	INTEL_E1000_ETHERNET_DEVICE(0x1027),

    76

	INTEL_E1000_ETHERNET_DEVICE(0x1028),

    77

	INTEL_E1000_ETHERNET_DEVICE(0x1075),

    78

	INTEL_E1000_ETHERNET_DEVICE(0x1076),

    79

	INTEL_E1000_ETHERNET_DEVICE(0x1077),

    80

	INTEL_E1000_ETHERNET_DEVICE(0x1078),

    81

	INTEL_E1000_ETHERNET_DEVICE(0x1079),

    82

	INTEL_E1000_ETHERNET_DEVICE(0x107A),

    83

	INTEL_E1000_ETHERNET_DEVICE(0x107B),

    84

	INTEL_E1000_ETHERNET_DEVICE(0x107C),

    85

	INTEL_E1000_ETHERNET_DEVICE(0x108A),

    86

	INTEL_E1000_ETHERNET_DEVICE(0x1099),

    87

	INTEL_E1000_ETHERNET_DEVICE(0x10B5),

    88

	INTEL_E1000_ETHERNET_DEVICE(0x2E6E),

    89

	/* required last entry */

    90

	{0,}

    91

};

    92

    93

// do not auto-load driver

    94

// MODULE_DEVICE_TABLE(pci, e1000_pci_tbl);

    95

    96

int e1000_up(struct e1000_adapter *adapter);

    97

void e1000_down(struct e1000_adapter *adapter);

    98

void e1000_reinit_locked(struct e1000_adapter *adapter);

    99

void e1000_reset(struct e1000_adapter *adapter);

   100

int e1000_setup_all_tx_resources(struct e1000_adapter *adapter);

   101

int e1000_setup_all_rx_resources(struct e1000_adapter *adapter);

   102

void e1000_free_all_tx_resources(struct e1000_adapter *adapter);

   103

void e1000_free_all_rx_resources(struct e1000_adapter *adapter);

   104

static int e1000_setup_tx_resources(struct e1000_adapter *adapter,

   105

                             struct e1000_tx_ring *txdr);

   106

static int e1000_setup_rx_resources(struct e1000_adapter *adapter,

   107

                             struct e1000_rx_ring *rxdr);

   108

static void e1000_free_tx_resources(struct e1000_adapter *adapter,

   109

                             struct e1000_tx_ring *tx_ring);

   110

static void e1000_free_rx_resources(struct e1000_adapter *adapter,

   111

                             struct e1000_rx_ring *rx_ring);

   112

void e1000_update_stats(struct e1000_adapter *adapter);

   113

   114

static int e1000_init_module(void);

   115

static void e1000_exit_module(void);

   116

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

   117

static void e1000_remove(struct pci_dev *pdev);

   118

static int e1000_alloc_queues(struct e1000_adapter *adapter);

   119

static int e1000_sw_init(struct e1000_adapter *adapter);

   120

static int e1000_open(struct net_device *netdev);

   121

static int e1000_close(struct net_device *netdev);

   122

static void e1000_configure_tx(struct e1000_adapter *adapter);

   123

static void e1000_configure_rx(struct e1000_adapter *adapter);

   124

static void e1000_setup_rctl(struct e1000_adapter *adapter);

   125

static void e1000_clean_all_tx_rings(struct e1000_adapter *adapter);

   126

static void e1000_clean_all_rx_rings(struct e1000_adapter *adapter);

   127

static void e1000_clean_tx_ring(struct e1000_adapter *adapter,

   128

                                struct e1000_tx_ring *tx_ring);

   129

static void e1000_clean_rx_ring(struct e1000_adapter *adapter,

   130

                                struct e1000_rx_ring *rx_ring);

   131

static void e1000_set_rx_mode(struct net_device *netdev);

   132

static void e1000_update_phy_info_task(struct work_struct *work);

   133

static void e1000_watchdog(struct work_struct *work);

   134

static void e1000_82547_tx_fifo_stall_task(struct work_struct *work);

   135

static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,

   136

				    struct net_device *netdev);

   137

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

   138

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

   139

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

   140

void ec_poll(struct net_device *);

   141

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

   142

static bool e1000_clean_tx_irq(struct e1000_adapter *adapter,

   143

			       struct e1000_tx_ring *tx_ring);

   144

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

   145

static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,

   146

			       struct e1000_rx_ring *rx_ring,

   147

			       int *work_done, int work_to_do);

   148

static bool e1000_clean_jumbo_rx_irq(struct e1000_adapter *adapter,

   149

				     struct e1000_rx_ring *rx_ring,

   150

				     int *work_done, int work_to_do);

   151

static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,

   152

				   struct e1000_rx_ring *rx_ring,

   153

				   int cleaned_count);

   154

static void e1000_alloc_jumbo_rx_buffers(struct e1000_adapter *adapter,

   155

					 struct e1000_rx_ring *rx_ring,

   156

					 int cleaned_count);

   157

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

   158

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

   159

			   int cmd);

   160

static void e1000_enter_82542_rst(struct e1000_adapter *adapter);

   161

static void e1000_leave_82542_rst(struct e1000_adapter *adapter);

   162

static void e1000_tx_timeout(struct net_device *dev);

   163

static void e1000_reset_task(struct work_struct *work);

   164

static void e1000_smartspeed(struct e1000_adapter *adapter);

   165

static int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,

   166

                                       struct sk_buff *skb);

   167

   168

static bool e1000_vlan_used(struct e1000_adapter *adapter);

   169

static void e1000_vlan_mode(struct net_device *netdev,

   170

			    netdev_features_t features);

   171

static void e1000_vlan_filter_on_off(struct e1000_adapter *adapter,

   172

				     bool filter_on);

   173

static int e1000_vlan_rx_add_vid(struct net_device *netdev,

   174

				 __be16 proto, u16 vid);

   175

static int e1000_vlan_rx_kill_vid(struct net_device *netdev,

   176

				  __be16 proto, u16 vid);

   177

static void e1000_restore_vlan(struct e1000_adapter *adapter);

   178

   179

#ifdef CONFIG_PM

   180

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

   181

static int e1000_resume(struct pci_dev *pdev);

   182

#endif

   183

static void e1000_shutdown(struct pci_dev *pdev);

   184

   185

#ifdef CONFIG_NET_POLL_CONTROLLER

   186

/* for netdump / net console */

   187

static void e1000_netpoll (struct net_device *netdev);

   188

#endif

   189

   190

#define COPYBREAK_DEFAULT 256

   191

static unsigned int copybreak __read_mostly = COPYBREAK_DEFAULT;

   192

module_param(copybreak, uint, 0644);

   193

MODULE_PARM_DESC(copybreak,

   194

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

   195

   196

static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev,

   197

                     pci_channel_state_t state);

   198

static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev);

   199

static void e1000_io_resume(struct pci_dev *pdev);

   200

   201

static const struct pci_error_handlers e1000_err_handler = {

   202

	.error_detected = e1000_io_error_detected,

   203

	.slot_reset = e1000_io_slot_reset,

   204

	.resume = e1000_io_resume,

   205

};

   206

   207

static struct pci_driver e1000_driver = {

   208

	.name     = e1000_driver_name,

   209

	.id_table = e1000_pci_tbl,

   210

	.probe    = e1000_probe,

   211

	.remove   = e1000_remove,

   212

#ifdef CONFIG_PM

   213

	/* Power Management Hooks */

   214

	.suspend  = e1000_suspend,

   215

	.resume   = e1000_resume,

   216

#endif

   217

	.shutdown = e1000_shutdown,

   218

	.err_handler = &e1000_err_handler

   219

};

   220

   221

MODULE_AUTHOR("Florian Pose <fp@igh-essen.com>");

   222

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

   223

MODULE_LICENSE("GPL");

   224

MODULE_VERSION(DRV_VERSION);

   225

   226

#define DEFAULT_MSG_ENABLE (NETIF_MSG_DRV|NETIF_MSG_PROBE|NETIF_MSG_LINK)

   227

static int debug = -1;

   228

module_param(debug, int, 0);

   229

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

   230

   231

/**

   232

 * e1000_get_hw_dev - return device

   233

 * used by hardware layer to print debugging information

   234

 *

   235

 **/

   236

struct net_device *e1000_get_hw_dev(struct e1000_hw *hw)

   237

{

   238

	struct e1000_adapter *adapter = hw->back;

   239

	return adapter->netdev;

   240

}

   241

   242

/**

   243

 * e1000_init_module - Driver Registration Routine

   244

 *

   245

 * e1000_init_module is the first routine called when the driver is

   246

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

   247

 **/

   248

static int __init e1000_init_module(void)

   249

{

   250

	int ret;

   251

	pr_info("%s - version %s\n", e1000_driver_string, e1000_driver_version);

   252

   253

	pr_info("%s\n", e1000_copyright);

   254

   255

	ret = pci_register_driver(&e1000_driver);

   256

	if (copybreak != COPYBREAK_DEFAULT) {

   257

		if (copybreak == 0)

   258

			pr_info("copybreak disabled\n");

   259

		else

   260

			pr_info("copybreak enabled for "

   261

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

   262

	}

   263

	return ret;

   264

}

   265

   266

module_init(e1000_init_module);

   267

   268

/**

   269

 * e1000_exit_module - Driver Exit Cleanup Routine

   270

 *

   271

 * e1000_exit_module is called just before the driver is removed

   272

 * from memory.

   273

 **/

   274

static void __exit e1000_exit_module(void)

   275

{

   276

	pci_unregister_driver(&e1000_driver);

   277

}

   278

   279

module_exit(e1000_exit_module);

   280

   281

static int e1000_request_irq(struct e1000_adapter *adapter)

   282

{

   283

	struct net_device *netdev = adapter->netdev;

   284

	irq_handler_t handler = e1000_intr;

   285

	int irq_flags = IRQF_SHARED;

   286

	int err;

   287

   288

	if (adapter->ecdev) {

   289

		return 0;

   290

	}

   291

   292

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

   293

	                  netdev);

   294

	if (err) {

   295

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

   296

	}

   297

   298

	return err;

   299

}

   300

   301

static void e1000_free_irq(struct e1000_adapter *adapter)

   302

{

   303

	struct net_device *netdev = adapter->netdev;

   304

   305

	if (adapter->ecdev) {

   306

		return;

   307

	}

   308

   309

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

   310

}

   311

   312

/**

   313

 * e1000_irq_disable - Mask off interrupt generation on the NIC

   314

 * @adapter: board private structure

   315

 **/

   316

static void e1000_irq_disable(struct e1000_adapter *adapter)

   317

{

   318

	struct e1000_hw *hw = &adapter->hw;

   319

   320

	if (adapter->ecdev) {

   321

		return;

   322

	}

   323

   324

	ew32(IMC, ~0);

   325

	E1000_WRITE_FLUSH();

   326

	synchronize_irq(adapter->pdev->irq);

   327

}

   328

   329

/**

   330

 * e1000_irq_enable - Enable default interrupt generation settings

   331

 * @adapter: board private structure

   332

 **/

   333

static void e1000_irq_enable(struct e1000_adapter *adapter)

   334

{

   335

	struct e1000_hw *hw = &adapter->hw;

   336

   337

	if (adapter->ecdev) {

   338

		return;

   339

	}

   340

   341

	ew32(IMS, IMS_ENABLE_MASK);

   342

	E1000_WRITE_FLUSH();

   343

}

   344

   345

static void e1000_update_mng_vlan(struct e1000_adapter *adapter)

   346

{

   347

	struct e1000_hw *hw = &adapter->hw;

   348

	struct net_device *netdev = adapter->netdev;

   349

	u16 vid = hw->mng_cookie.vlan_id;

   350

	u16 old_vid = adapter->mng_vlan_id;

   351

   352

	if (!e1000_vlan_used(adapter))

   353

		return;

   354

   355

	if (!test_bit(vid, adapter->active_vlans)) {

   356

		if (hw->mng_cookie.status &

   357

		    E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) {

   358

			e1000_vlan_rx_add_vid(netdev, htons(ETH_P_8021Q), vid);

   359

			adapter->mng_vlan_id = vid;

   360

		} else {

   361

			adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;

   362

		}

   363

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

   364

		    (vid != old_vid) &&

   365

		    !test_bit(old_vid, adapter->active_vlans))

   366

			e1000_vlan_rx_kill_vid(netdev, htons(ETH_P_8021Q),

   367

					       old_vid);

   368

	} else {

   369

		adapter->mng_vlan_id = vid;

   370

	}

   371

}

   372

   373

static void e1000_init_manageability(struct e1000_adapter *adapter)

   374

{

   375

	struct e1000_hw *hw = &adapter->hw;

   376

   377

	if (adapter->en_mng_pt) {

   378

		u32 manc = er32(MANC);

   379

   380

		/* disable hardware interception of ARP */

   381

		manc &= ~(E1000_MANC_ARP_EN);

   382

   383

		ew32(MANC, manc);

   384

	}

   385

}

   386

   387

static void e1000_release_manageability(struct e1000_adapter *adapter)

   388

{

   389

	struct e1000_hw *hw = &adapter->hw;

   390

   391

	if (adapter->en_mng_pt) {

   392

		u32 manc = er32(MANC);

   393

   394

		/* re-enable hardware interception of ARP */

   395

		manc |= E1000_MANC_ARP_EN;

   396

   397

		ew32(MANC, manc);

   398

	}

   399

}

   400

   401

/**

   402

 * e1000_configure - configure the hardware for RX and TX

   403

 * @adapter = private board structure

   404

 **/

   405

static void e1000_configure(struct e1000_adapter *adapter)

   406

{

   407

	struct net_device *netdev = adapter->netdev;

   408

	int i;

   409

   410

	e1000_set_rx_mode(netdev);

   411

   412

	e1000_restore_vlan(adapter);

   413

	e1000_init_manageability(adapter);

   414

   415

	e1000_configure_tx(adapter);

   416

	e1000_setup_rctl(adapter);

   417

	e1000_configure_rx(adapter);

   418

	/* call E1000_DESC_UNUSED which always leaves

   419

	 * at least 1 descriptor unused to make sure

   420

	 * next_to_use != next_to_clean

   421

	 */

   422

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

   423

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

   424

		if (adapter->ecdev) {

   425

			/* fill rx ring completely! */

   426

			adapter->alloc_rx_buf(adapter, ring, ring->count);

   427

		} else {

   428

			/* this one leaves the last ring element unallocated! */

   429

			adapter->alloc_rx_buf(adapter, ring,

   430

					E1000_DESC_UNUSED(ring));

   431

		}

   432

	}

   433

}

   434

   435

int e1000_up(struct e1000_adapter *adapter)

   436

{

   437

	struct e1000_hw *hw = &adapter->hw;

   438

   439

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

   440

	e1000_configure(adapter);

   441

   442

	clear_bit(__E1000_DOWN, &adapter->flags);

   443

   444

	if (!adapter->ecdev) {

   445

		napi_enable(&adapter->napi);

   446

   447

		e1000_irq_enable(adapter);

   448

   449

		netif_wake_queue(adapter->netdev);

   450

   451

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

   452

		ew32(ICS, E1000_ICS_LSC);

   453

	}

   454

	return 0;

   455

}

   456

   457

/**

   458

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

   459

 * @adapter: address of board private structure

   460

 *

   461

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

   462

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

   463

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

   464

 **/

   465

void e1000_power_up_phy(struct e1000_adapter *adapter)

   466

{

   467

	struct e1000_hw *hw = &adapter->hw;

   468

	u16 mii_reg = 0;

   469

   470

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

   471

	if (hw->media_type == e1000_media_type_copper) {

   472

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

   473

		 * settings across a power-down/up cycle

   474

		 */

   475

		e1000_read_phy_reg(hw, PHY_CTRL, &mii_reg);

   476

		mii_reg &= ~MII_CR_POWER_DOWN;

   477

		e1000_write_phy_reg(hw, PHY_CTRL, mii_reg);

   478

	}

   479

}

   480

   481

static void e1000_power_down_phy(struct e1000_adapter *adapter)

   482

{

   483

	struct e1000_hw *hw = &adapter->hw;

   484

   485

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

   486

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

   487

	 * (a) WoL is enabled

   488

	 * (b) AMT is active

   489

	 * (c) SoL/IDER session is active

   490

	 */

   491

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

   492

	   hw->media_type == e1000_media_type_copper) {

   493

		u16 mii_reg = 0;

   494

   495

		switch (hw->mac_type) {

   496

		case e1000_82540:

   497

		case e1000_82545:

   498

		case e1000_82545_rev_3:

   499

		case e1000_82546:

   500

		case e1000_ce4100:

   501

		case e1000_82546_rev_3:

   502

		case e1000_82541:

   503

		case e1000_82541_rev_2:

   504

		case e1000_82547:

   505

		case e1000_82547_rev_2:

   506

			if (er32(MANC) & E1000_MANC_SMBUS_EN)

   507

				goto out;

   508

			break;

   509

		default:

   510

			goto out;

   511

		}

   512

		e1000_read_phy_reg(hw, PHY_CTRL, &mii_reg);

   513

		mii_reg |= MII_CR_POWER_DOWN;

   514

		e1000_write_phy_reg(hw, PHY_CTRL, mii_reg);

   515

		msleep(1);

   516

	}

   517

out:

   518

	return;

   519

}

   520

   521

static void e1000_down_and_stop(struct e1000_adapter *adapter)

   522

{

   523

	set_bit(__E1000_DOWN, &adapter->flags);

   524

   525

	if (!adapter->ecdev) {

   526

		cancel_delayed_work_sync(&adapter->watchdog_task);

   527

	}

   528

   529

	/*

   530