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-2.6.29-ethercat.h"

    30

#include <net/ip6_checksum.h>

    31

    32

char e1000_driver_name[] = "ec_e1000";

    33

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

    34

#define DRV_VERSION "7.3.21-k3-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

// do not auto-load driver

    87

// MODULE_DEVICE_TABLE(pci, e1000_pci_tbl);

    88

    89

int e1000_up(struct e1000_adapter *adapter);

    90

void e1000_down(struct e1000_adapter *adapter);

    91

void e1000_reinit_locked(struct e1000_adapter *adapter);

    92

void e1000_reset(struct e1000_adapter *adapter);

    93

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

    94

int e1000_setup_all_tx_resources(struct e1000_adapter *adapter);

    95

int e1000_setup_all_rx_resources(struct e1000_adapter *adapter);

    96

void e1000_free_all_tx_resources(struct e1000_adapter *adapter);

    97

void e1000_free_all_rx_resources(struct e1000_adapter *adapter);

    98

static int e1000_setup_tx_resources(struct e1000_adapter *adapter,

    99

                             struct e1000_tx_ring *txdr);

   100

static int e1000_setup_rx_resources(struct e1000_adapter *adapter,

   101

                             struct e1000_rx_ring *rxdr);

   102

static void e1000_free_tx_resources(struct e1000_adapter *adapter,

   103

                             struct e1000_tx_ring *tx_ring);

   104

static void e1000_free_rx_resources(struct e1000_adapter *adapter,

   105

                             struct e1000_rx_ring *rx_ring);

   106

void e1000_update_stats(struct e1000_adapter *adapter);

   107

   108

static int e1000_init_module(void);

   109

static void e1000_exit_module(void);

   110

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

   111

static void __devexit e1000_remove(struct pci_dev *pdev);

   112

static int e1000_alloc_queues(struct e1000_adapter *adapter);

   113

static int e1000_sw_init(struct e1000_adapter *adapter);

   114

static int e1000_open(struct net_device *netdev);

   115

static int e1000_close(struct net_device *netdev);

   116

static void e1000_configure_tx(struct e1000_adapter *adapter);

   117

static void e1000_configure_rx(struct e1000_adapter *adapter);

   118

static void e1000_setup_rctl(struct e1000_adapter *adapter);

   119

static void e1000_clean_all_tx_rings(struct e1000_adapter *adapter);

   120

static void e1000_clean_all_rx_rings(struct e1000_adapter *adapter);

   121

static void e1000_clean_tx_ring(struct e1000_adapter *adapter,

   122

                                struct e1000_tx_ring *tx_ring);

   123

static void e1000_clean_rx_ring(struct e1000_adapter *adapter,

   124

                                struct e1000_rx_ring *rx_ring);

   125

static void e1000_set_rx_mode(struct net_device *netdev);

   126

static void e1000_update_phy_info(unsigned long data);

   127

static void e1000_watchdog(unsigned long data);

   128

static void e1000_82547_tx_fifo_stall(unsigned long data);

   129

static int e1000_xmit_frame(struct sk_buff *skb, 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

void ec_poll(struct net_device *);

   134

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

   135

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

   136

static bool e1000_clean_tx_irq(struct e1000_adapter *adapter,

   137

			       struct e1000_tx_ring *tx_ring);

   138

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

   139

static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,

   140

			       struct e1000_rx_ring *rx_ring,

   141

			       int *work_done, int work_to_do);

   142

static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,

   143

                                   struct e1000_rx_ring *rx_ring,

   144

				   int cleaned_count);

   145

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

   146

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

   147

			   int cmd);

   148

static void e1000_enter_82542_rst(struct e1000_adapter *adapter);

   149

static void e1000_leave_82542_rst(struct e1000_adapter *adapter);

   150

static void e1000_tx_timeout(struct net_device *dev);

   151

static void e1000_reset_task(struct work_struct *work);

   152

static void e1000_smartspeed(struct e1000_adapter *adapter);

   153

static int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,

   154

                                       struct sk_buff *skb);

   155

   156

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

   157

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

   158

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

   159

static void e1000_restore_vlan(struct e1000_adapter *adapter);

   160

   161

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

   162

#ifdef CONFIG_PM

   163

static int e1000_resume(struct pci_dev *pdev);

   164

#endif

   165

static void e1000_shutdown(struct pci_dev *pdev);

   166

   167

#ifdef CONFIG_NET_POLL_CONTROLLER

   168

/* for netdump / net console */

   169

static void e1000_netpoll (struct net_device *netdev);

   170

#endif

   171

   172

#define COPYBREAK_DEFAULT 256

   173

static unsigned int copybreak __read_mostly = COPYBREAK_DEFAULT;

   174

module_param(copybreak, uint, 0644);

   175

MODULE_PARM_DESC(copybreak,

   176

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

   177

   178

static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev,

   179

                     pci_channel_state_t state);

   180

static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev);

   181

static void e1000_io_resume(struct pci_dev *pdev);

   182

   183

static struct pci_error_handlers e1000_err_handler = {

   184

	.error_detected = e1000_io_error_detected,

   185

	.slot_reset = e1000_io_slot_reset,

   186

	.resume = e1000_io_resume,

   187

};

   188

   189

static struct pci_driver e1000_driver = {

   190

	.name     = e1000_driver_name,

   191

	.id_table = e1000_pci_tbl,

   192

	.probe    = e1000_probe,

   193

	.remove   = __devexit_p(e1000_remove),

   194

#ifdef CONFIG_PM

   195

	/* Power Managment Hooks */

   196

	.suspend  = e1000_suspend,

   197

	.resume   = e1000_resume,

   198

#endif

   199

	.shutdown = e1000_shutdown,

   200

	.err_handler = &e1000_err_handler

   201

};

   202

   203

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

   204

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

   205

MODULE_LICENSE("GPL");

   206

MODULE_VERSION(DRV_VERSION);

   207

   208

static int debug = NETIF_MSG_DRV | NETIF_MSG_PROBE;

   209

module_param(debug, int, 0);

   210

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

   211

   212

/**

   213

 * e1000_init_module - Driver Registration Routine

   214

 *

   215

 * e1000_init_module is the first routine called when the driver is

   216

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

   217

 **/

   218

   219

static int __init e1000_init_module(void)

   220

{

   221

	int ret;

   222

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

   223

	       e1000_driver_string, e1000_driver_version);

   224

   225

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

   226

   227

	ret = pci_register_driver(&e1000_driver);

   228

	if (copybreak != COPYBREAK_DEFAULT) {

   229

		if (copybreak == 0)

   230

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

   231

		else

   232

			printk(KERN_INFO "e1000: copybreak enabled for "

   233

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

   234

	}

   235

	return ret;

   236

}

   237

   238

module_init(e1000_init_module);

   239

   240

/**

   241

 * e1000_exit_module - Driver Exit Cleanup Routine

   242

 *

   243

 * e1000_exit_module is called just before the driver is removed

   244

 * from memory.

   245

 **/

   246

   247

static void __exit e1000_exit_module(void)

   248

{

   249

	pci_unregister_driver(&e1000_driver);

   250

}

   251

   252

module_exit(e1000_exit_module);

   253

   254

static int e1000_request_irq(struct e1000_adapter *adapter)

   255

{

   256

	struct e1000_hw *hw = &adapter->hw;

   257

	struct net_device *netdev = adapter->netdev;

   258

	irq_handler_t handler = e1000_intr;

   259

	int irq_flags = IRQF_SHARED;

   260

	int err;

   261

   262

 	if (adapter->ecdev)

   263

 		return 0;

   264

   265

	if (hw->mac_type >= e1000_82571) {

   266

		adapter->have_msi = !pci_enable_msi(adapter->pdev);

   267

		if (adapter->have_msi) {

   268

			handler = e1000_intr_msi;

   269

			irq_flags = 0;

   270

		}

   271

	}

   272

   273

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

   274

	                  netdev);

   275

	if (err) {

   276

		if (adapter->have_msi)

   277

			pci_disable_msi(adapter->pdev);

   278

		DPRINTK(PROBE, ERR,

   279

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

   280

	}

   281

   282

	return err;

   283

}

   284

   285

static void e1000_free_irq(struct e1000_adapter *adapter)

   286

{

   287

	struct net_device *netdev = adapter->netdev;

   288

   289

	if (adapter->ecdev)

   290

		return;

   291

   292

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

   293

   294

	if (adapter->have_msi)

   295

		pci_disable_msi(adapter->pdev);

   296

}

   297

   298

/**

   299

 * e1000_irq_disable - Mask off interrupt generation on the NIC

   300

 * @adapter: board private structure

   301

 **/

   302

   303

static void e1000_irq_disable(struct e1000_adapter *adapter)

   304

{

   305

	struct e1000_hw *hw = &adapter->hw;

   306

   307

	if (adapter->ecdev)

   308

		return;

   309

   310

	ew32(IMC, ~0);

   311

	E1000_WRITE_FLUSH();

   312

	synchronize_irq(adapter->pdev->irq);

   313

}

   314

   315

/**

   316

 * e1000_irq_enable - Enable default interrupt generation settings

   317

 * @adapter: board private structure

   318

 **/

   319

   320

static void e1000_irq_enable(struct e1000_adapter *adapter)

   321

{

   322

	struct e1000_hw *hw = &adapter->hw;

   323

   324

	if (adapter->ecdev)

   325

		return;

   326

   327

	ew32(IMS, IMS_ENABLE_MASK);

   328

	E1000_WRITE_FLUSH();

   329

}

   330

   331

static void e1000_update_mng_vlan(struct e1000_adapter *adapter)

   332

{

   333

	struct e1000_hw *hw = &adapter->hw;

   334

	struct net_device *netdev = adapter->netdev;

   335

	u16 vid = hw->mng_cookie.vlan_id;

   336

	u16 old_vid = adapter->mng_vlan_id;

   337

	if (adapter->vlgrp) {

   338

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

   339

			if (hw->mng_cookie.status &

   340

				E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) {

   341

				e1000_vlan_rx_add_vid(netdev, vid);

   342

				adapter->mng_vlan_id = vid;

   343

			} else

   344

				adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;

   345

   346

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

   347

					(vid != old_vid) &&

   348

			    !vlan_group_get_device(adapter->vlgrp, old_vid))

   349

				e1000_vlan_rx_kill_vid(netdev, old_vid);

   350

		} else

   351

			adapter->mng_vlan_id = vid;

   352

	}

   353

}

   354

   355

/**

   356

 * e1000_release_hw_control - release control of the h/w to f/w

   357

 * @adapter: address of board private structure

   358

 *

   359

 * e1000_release_hw_control resets {CTRL_EXT|FWSM}:DRV_LOAD bit.

   360

 * For ASF and Pass Through versions of f/w this means that the

   361

 * driver is no longer loaded. For AMT version (only with 82573) i

   362

 * of the f/w this means that the network i/f is closed.

   363

 *

   364

 **/

   365

   366

static void e1000_release_hw_control(struct e1000_adapter *adapter)

   367

{

   368

	u32 ctrl_ext;

   369

	u32 swsm;

   370

	struct e1000_hw *hw = &adapter->hw;

   371

   372

	/* Let firmware taken over control of h/w */

   373

	switch (hw->mac_type) {

   374

	case e1000_82573:

   375

		swsm = er32(SWSM);

   376

		ew32(SWSM, swsm & ~E1000_SWSM_DRV_LOAD);

   377

		break;

   378

	case e1000_82571:

   379

	case e1000_82572:

   380

	case e1000_80003es2lan:

   381

	case e1000_ich8lan:

   382

		ctrl_ext = er32(CTRL_EXT);

   383

		ew32(CTRL_EXT, ctrl_ext & ~E1000_CTRL_EXT_DRV_LOAD);

   384

		break;

   385

	default:

   386

		break;

   387

	}

   388

}

   389

   390

/**

   391

 * e1000_get_hw_control - get control of the h/w from f/w

   392

 * @adapter: address of board private structure

   393

 *

   394

 * e1000_get_hw_control sets {CTRL_EXT|FWSM}:DRV_LOAD bit.

   395

 * For ASF and Pass Through versions of f/w this means that

   396

 * the driver is loaded. For AMT version (only with 82573)

   397

 * of the f/w this means that the network i/f is open.

   398

 *

   399

 **/

   400

   401

static void e1000_get_hw_control(struct e1000_adapter *adapter)

   402

{

   403

	u32 ctrl_ext;

   404

	u32 swsm;

   405

	struct e1000_hw *hw = &adapter->hw;

   406

   407

	/* Let firmware know the driver has taken over */

   408

	switch (hw->mac_type) {

   409

	case e1000_82573:

   410

		swsm = er32(SWSM);

   411

		ew32(SWSM, swsm | E1000_SWSM_DRV_LOAD);

   412

		break;

   413

	case e1000_82571:

   414

	case e1000_82572:

   415

	case e1000_80003es2lan:

   416

	case e1000_ich8lan:

   417

		ctrl_ext = er32(CTRL_EXT);

   418

		ew32(CTRL_EXT, ctrl_ext | E1000_CTRL_EXT_DRV_LOAD);

   419

		break;

   420

	default:

   421

		break;

   422

	}

   423

}

   424

   425

static void e1000_init_manageability(struct e1000_adapter *adapter)

   426

{

   427

	struct e1000_hw *hw = &adapter->hw;

   428

   429

	if (adapter->en_mng_pt) {

   430

		u32 manc = er32(MANC);

   431

   432

		/* disable hardware interception of ARP */

   433

		manc &= ~(E1000_MANC_ARP_EN);

   434

   435

		/* enable receiving management packets to the host */

   436

		/* this will probably generate destination unreachable messages

   437

		 * from the host OS, but the packets will be handled on SMBUS */

   438

		if (hw->has_manc2h) {

   439

			u32 manc2h = er32(MANC2H);

   440

   441

			manc |= E1000_MANC_EN_MNG2HOST;

   442

#define E1000_MNG2HOST_PORT_623 (1 << 5)

   443

#define E1000_MNG2HOST_PORT_664 (1 << 6)

   444

			manc2h |= E1000_MNG2HOST_PORT_623;

   445

			manc2h |= E1000_MNG2HOST_PORT_664;

   446

			ew32(MANC2H, manc2h);

   447

		}

   448

   449

		ew32(MANC, manc);

   450

	}

   451

}

   452

   453

static void e1000_release_manageability(struct e1000_adapter *adapter)

   454

{

   455

	struct e1000_hw *hw = &adapter->hw;

   456

   457

	if (adapter->en_mng_pt) {

   458

		u32 manc = er32(MANC);

   459

   460

		/* re-enable hardware interception of ARP */

   461

		manc |= E1000_MANC_ARP_EN;

   462

   463

		if (hw->has_manc2h)

   464

			manc &= ~E1000_MANC_EN_MNG2HOST;

   465

   466

		/* don't explicitly have to mess with MANC2H since

   467

		 * MANC has an enable disable that gates MANC2H */

   468

   469

		ew32(MANC, manc);

   470

	}

   471

}

   472

   473

/**

   474

 * e1000_configure - configure the hardware for RX and TX

   475

 * @adapter = private board structure

   476

 **/

   477

static void e1000_configure(struct e1000_adapter *adapter)

   478

{

   479

	struct net_device *netdev = adapter->netdev;

   480

	int i;

   481

   482

	e1000_set_rx_mode(netdev);

   483

   484

	e1000_restore_vlan(adapter);

   485

	e1000_init_manageability(adapter);

   486

   487

	e1000_configure_tx(adapter);

   488

	e1000_setup_rctl(adapter);

   489

	e1000_configure_rx(adapter);

   490

	/* call E1000_DESC_UNUSED which always leaves

   491

	 * at least 1 descriptor unused to make sure

   492

	 * next_to_use != next_to_clean */

   493

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

   494

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

   495

		if (adapter->ecdev) {

   496

			/* fill rx ring completely! */

   497

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

   498

		} else {

   499

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

   500

			adapter->alloc_rx_buf(adapter, ring,

   501

					E1000_DESC_UNUSED(ring));

   502

		}

   503

	}

   504

   505

	adapter->tx_queue_len = netdev->tx_queue_len;

   506

}

   507

   508

int e1000_up(struct e1000_adapter *adapter)

   509

{

   510

	struct e1000_hw *hw = &adapter->hw;

   511

   512

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

   513

	e1000_configure(adapter);

   514

   515

	clear_bit(__E1000_DOWN, &adapter->flags);

   516

   517

	if (!adapter->ecdev) {

   518

		napi_enable(&adapter->napi);

   519

   520

		e1000_irq_enable(adapter);

   521

   522

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

   523

		ew32(ICS, E1000_ICS_LSC);

   524

	}

   525

	return 0;

   526

}

   527

   528

/**

   529

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